1. Registry
  2. Packages
  3. incident.io
  4. API Docs
  5. EscalationPathTemplate
Viewing docs for incident.io v0.4.1
published on Wednesday, Oct 21, 2026 by incident-io
incident logo incident.io
Viewing docs for incident.io v0.4.1
published on Wednesday, Oct 21, 2026 by incident-io

    Create and manage escalation path templates: an escalation path with parameters, from which many escalation paths can be built.

    A template is written the same way as incident.EscalationPath, as a flat map of named node sequences, with two additions. It declares params, and a level or notifyChannel target may carry a binding to one of them instead of naming an id. An incident.EscalationPath built from the template sets kind = "templated" and templateId, and binds each parameter in paramBindings, and the template’s nodes, working hours and repeat config apply to every path built from it.

    Beta, and what happens next

    This resource is new in this version, so its schema may still change in ways that are not backwards compatible. Pin the provider version if that matters to you.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
    import * as incident from "@incident-io/pulumi";
    
    // A template pages a team's primary schedule, then their backup, with the schedule and
    // backup left as parameters for each team to fill in.
    const teamOncall = new incident.EscalationPathTemplate("team_oncall", {
        name: "Team on-call",
        description: "Primary schedule, then a backup responder",
        params: {
            primary_schedule: {
                label: "Primary schedule",
                type: "CatalogEntry[\"Schedule\"]",
            },
            backup: {
                label: "Backup responder",
                type: "CatalogEntry[\"User\"]",
            },
        },
        start: "main",
        sequences: {
            main: {
                nodes: [
                    {
                        level: {
                            targets: [{
                                type: "schedule",
                                urgency: "high",
                                binding: {
                                    valueReference: "primary_schedule",
                                },
                            }],
                            timeToAckSeconds: 300,
                        },
                    },
                    {
                        level: {
                            targets: [{
                                type: "user",
                                urgency: "high",
                                binding: {
                                    valueReference: "backup",
                                },
                            }],
                            timeToAckSeconds: 600,
                        },
                    },
                ],
            },
        },
    });
    // The paths built from it. Each names the template and binds its params, and has no
    // sequences of its own.
    const payments = new incident.Schedule("payments", {
        name: "Payments primary",
        timezone: "Europe/London",
    });
    const paymentsLead = incident.getUser({
        email: "payments-lead@example.com",
    });
    const paymentsEscalationPath = new incident.EscalationPath("payments", {
        name: "Payments on-call",
        kind: "templated",
        templateId: teamOncall.id,
        paramBindings: {
            primary_schedule: {
                valueLiteral: payments.id,
            },
            backup: {
                valueLiteral: paymentsLead.then(paymentsLead => paymentsLead.id),
            },
        },
    });
    // To page one rotation of a bound schedule, bind the target to an expression that
    // navigates the schedule's rotations and keeps the one with that name.
    const primaryRotation = new incident.EscalationPathTemplate("primary_rotation", {
        name: "Primary rotation",
        params: {
            schedule: {
                label: "Schedule",
                type: "CatalogEntry[\"Schedule\"]",
            },
        },
        expressions: [{
            label: "Primary rotation",
            reference: "primary_rotation",
            rootReference: "schedule",
            operations: [
                {
                    operationType: "navigate",
                    navigate: {
                        reference: "rotations",
                    },
                },
                {
                    operationType: "filter",
                    filter: {
                        conditionGroups: [{
                            conditions: [{
                                subject: "input.name",
                                operation: "equals",
                                paramBindings: [{
                                    value: {
                                        literal: "Primary",
                                    },
                                }],
                            }],
                        }],
                    },
                },
            ],
        }],
        start: "main",
        sequences: {
            main: {
                nodes: [{
                    level: {
                        targets: [{
                            type: "schedule",
                            urgency: "high",
                            scheduleMode: "currently_on_call_for_rota",
                            binding: {
                                expressionRef: "primary_rotation",
                            },
                        }],
                        timeToAckSeconds: 300,
                    },
                }],
            },
        },
    });
    
    import pulumi
    import pulumi_incident as incident
    
    # A template pages a team's primary schedule, then their backup, with the schedule and
    # backup left as parameters for each team to fill in.
    team_oncall = incident.EscalationPathTemplate("team_oncall",
        name="Team on-call",
        description="Primary schedule, then a backup responder",
        params={
            "primary_schedule": {
                "label": "Primary schedule",
                "type": "CatalogEntry[\"Schedule\"]",
            },
            "backup": {
                "label": "Backup responder",
                "type": "CatalogEntry[\"User\"]",
            },
        },
        start="main",
        sequences={
            "main": {
                "nodes": [
                    {
                        "level": {
                            "targets": [{
                                "type": "schedule",
                                "urgency": "high",
                                "binding": {
                                    "value_reference": "primary_schedule",
                                },
                            }],
                            "time_to_ack_seconds": 300,
                        },
                    },
                    {
                        "level": {
                            "targets": [{
                                "type": "user",
                                "urgency": "high",
                                "binding": {
                                    "value_reference": "backup",
                                },
                            }],
                            "time_to_ack_seconds": 600,
                        },
                    },
                ],
            },
        })
    # The paths built from it. Each names the template and binds its params, and has no
    # sequences of its own.
    payments = incident.Schedule("payments",
        name="Payments primary",
        timezone="Europe/London")
    payments_lead = incident.get_user(email="payments-lead@example.com")
    payments_escalation_path = incident.EscalationPath("payments",
        name="Payments on-call",
        kind="templated",
        template_id=team_oncall.id,
        param_bindings={
            "primary_schedule": {
                "value_literal": payments.id,
            },
            "backup": {
                "value_literal": payments_lead.id,
            },
        })
    # To page one rotation of a bound schedule, bind the target to an expression that
    # navigates the schedule's rotations and keeps the one with that name.
    primary_rotation = incident.EscalationPathTemplate("primary_rotation",
        name="Primary rotation",
        params={
            "schedule": {
                "label": "Schedule",
                "type": "CatalogEntry[\"Schedule\"]",
            },
        },
        expressions=[{
            "label": "Primary rotation",
            "reference": "primary_rotation",
            "root_reference": "schedule",
            "operations": [
                {
                    "operation_type": "navigate",
                    "navigate": {
                        "reference": "rotations",
                    },
                },
                {
                    "operation_type": "filter",
                    "filter": {
                        "condition_groups": [{
                            "conditions": [{
                                "subject": "input.name",
                                "operation": "equals",
                                "param_bindings": [{
                                    "value": {
                                        "literal": "Primary",
                                    },
                                }],
                            }],
                        }],
                    },
                },
            ],
        }],
        start="main",
        sequences={
            "main": {
                "nodes": [{
                    "level": {
                        "targets": [{
                            "type": "schedule",
                            "urgency": "high",
                            "schedule_mode": "currently_on_call_for_rota",
                            "binding": {
                                "expression_ref": "primary_rotation",
                            },
                        }],
                        "time_to_ack_seconds": 300,
                    },
                }],
            },
        })
    
    package main
    
    import (
    	"github.com/incident-io/pulumi-incident/sdk/go/incident"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		// A template pages a team's primary schedule, then their backup, with the schedule and
    		// backup left as parameters for each team to fill in.
    		teamOncall, err := incident.NewEscalationPathTemplate(ctx, "team_oncall", &incident.EscalationPathTemplateArgs{
    			Name:        pulumi.String("Team on-call"),
    			Description: pulumi.String("Primary schedule, then a backup responder"),
    			Params: incident.EscalationPathTemplateParamsMap{
    				"primary_schedule": &incident.EscalationPathTemplateParamsArgs{
    					Label: pulumi.String("Primary schedule"),
    					Type:  pulumi.String("CatalogEntry[\"Schedule\"]"),
    				},
    				"backup": &incident.EscalationPathTemplateParamsArgs{
    					Label: pulumi.String("Backup responder"),
    					Type:  pulumi.String("CatalogEntry[\"User\"]"),
    				},
    			},
    			Start: pulumi.String("main"),
    			Sequences: incident.EscalationPathTemplateSequencesMap{
    				"main": &incident.EscalationPathTemplateSequencesArgs{
    					Nodes: incident.EscalationPathTemplateSequencesNodeArray{
    						&incident.EscalationPathTemplateSequencesNodeArgs{
    							Level: &incident.EscalationPathTemplateSequencesNodeLevelArgs{
    								Targets: incident.EscalationPathTemplateSequencesNodeLevelTargetArray{
    									&incident.EscalationPathTemplateSequencesNodeLevelTargetArgs{
    										Type:    pulumi.String("schedule"),
    										Urgency: pulumi.String("high"),
    										Binding: &incident.EscalationPathTemplateSequencesNodeLevelTargetBindingArgs{
    											ValueReference: pulumi.String("primary_schedule"),
    										},
    									},
    								},
    								TimeToAckSeconds: pulumi.Int(300),
    							},
    						},
    						&incident.EscalationPathTemplateSequencesNodeArgs{
    							Level: &incident.EscalationPathTemplateSequencesNodeLevelArgs{
    								Targets: incident.EscalationPathTemplateSequencesNodeLevelTargetArray{
    									&incident.EscalationPathTemplateSequencesNodeLevelTargetArgs{
    										Type:    pulumi.String("user"),
    										Urgency: pulumi.String("high"),
    										Binding: &incident.EscalationPathTemplateSequencesNodeLevelTargetBindingArgs{
    											ValueReference: pulumi.String("backup"),
    										},
    									},
    								},
    								TimeToAckSeconds: pulumi.Int(600),
    							},
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		// The paths built from it. Each names the template and binds its params, and has no
    		// sequences of its own.
    		payments, err := incident.NewSchedule(ctx, "payments", &incident.ScheduleArgs{
    			Name:     pulumi.String("Payments primary"),
    			Timezone: pulumi.String("Europe/London"),
    		})
    		if err != nil {
    			return err
    		}
    		paymentsLead, err := incident.GetUser(ctx, &incident.GetUserArgs{
    			Email: pulumi.StringRef("payments-lead@example.com"),
    		}, nil)
    		if err != nil {
    			return err
    		}
    		_, err = incident.NewEscalationPath(ctx, "payments", &incident.EscalationPathArgs{
    			Name:       pulumi.String("Payments on-call"),
    			Kind:       pulumi.String("templated"),
    			TemplateId: teamOncall.ID().ToIDOutput().ToStringOutput(),
    			ParamBindings: incident.EscalationPathParamBindingsMap{
    				"primary_schedule": &incident.EscalationPathParamBindingsArgs{
    					ValueLiteral: payments.ID().ToIDOutput().ToStringOutput(),
    				},
    				"backup": &incident.EscalationPathParamBindingsArgs{
    					ValueLiteral: pulumi.String(paymentsLead.Id),
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		// To page one rotation of a bound schedule, bind the target to an expression that
    		// navigates the schedule's rotations and keeps the one with that name.
    		_, err = incident.NewEscalationPathTemplate(ctx, "primary_rotation", &incident.EscalationPathTemplateArgs{
    			Name: pulumi.String("Primary rotation"),
    			Params: incident.EscalationPathTemplateParamsMap{
    				"schedule": &incident.EscalationPathTemplateParamsArgs{
    					Label: pulumi.String("Schedule"),
    					Type:  pulumi.String("CatalogEntry[\"Schedule\"]"),
    				},
    			},
    			Expressions: incident.EscalationPathTemplateExpressionArray{
    				&incident.EscalationPathTemplateExpressionArgs{
    					Label:         pulumi.String("Primary rotation"),
    					Reference:     pulumi.String("primary_rotation"),
    					RootReference: pulumi.String("schedule"),
    					Operations: incident.EscalationPathTemplateExpressionOperationArray{
    						&incident.EscalationPathTemplateExpressionOperationArgs{
    							OperationType: pulumi.String("navigate"),
    							Navigate: &incident.EscalationPathTemplateExpressionOperationNavigateArgs{
    								Reference: pulumi.String("rotations"),
    							},
    						},
    						&incident.EscalationPathTemplateExpressionOperationArgs{
    							OperationType: pulumi.String("filter"),
    							Filter: &incident.EscalationPathTemplateExpressionOperationFilterArgs{
    								ConditionGroups: incident.EscalationPathTemplateExpressionOperationFilterConditionGroupArray{
    									&incident.EscalationPathTemplateExpressionOperationFilterConditionGroupArgs{
    										Conditions: incident.EscalationPathTemplateExpressionOperationFilterConditionGroupConditionArray{
    											&incident.EscalationPathTemplateExpressionOperationFilterConditionGroupConditionArgs{
    												Subject:   pulumi.String("input.name"),
    												Operation: pulumi.String("equals"),
    												ParamBindings: incident.EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingArray{
    													&incident.EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingArgs{
    														Value: &incident.EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingValueArgs{
    															Literal: pulumi.String("Primary"),
    														},
    													},
    												},
    											},
    										},
    									},
    								},
    							},
    						},
    					},
    				},
    			},
    			Start: pulumi.String("main"),
    			Sequences: incident.EscalationPathTemplateSequencesMap{
    				"main": &incident.EscalationPathTemplateSequencesArgs{
    					Nodes: incident.EscalationPathTemplateSequencesNodeArray{
    						&incident.EscalationPathTemplateSequencesNodeArgs{
    							Level: &incident.EscalationPathTemplateSequencesNodeLevelArgs{
    								Targets: incident.EscalationPathTemplateSequencesNodeLevelTargetArray{
    									&incident.EscalationPathTemplateSequencesNodeLevelTargetArgs{
    										Type:         pulumi.String("schedule"),
    										Urgency:      pulumi.String("high"),
    										ScheduleMode: pulumi.String("currently_on_call_for_rota"),
    										Binding: &incident.EscalationPathTemplateSequencesNodeLevelTargetBindingArgs{
    											ExpressionRef: pulumi.String("primary_rotation"),
    										},
    									},
    								},
    								TimeToAckSeconds: pulumi.Int(300),
    							},
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Incident = Pulumi.Incident;
    
    return await Deployment.RunAsync(() => 
    {
        // A template pages a team's primary schedule, then their backup, with the schedule and
        // backup left as parameters for each team to fill in.
        var teamOncall = new Incident.EscalationPathTemplate("team_oncall", new()
        {
            Name = "Team on-call",
            Description = "Primary schedule, then a backup responder",
            Params = 
            {
                { "primary_schedule", new Incident.Inputs.EscalationPathTemplateParamsArgs
                {
                    Label = "Primary schedule",
                    Type = "CatalogEntry[\"Schedule\"]",
                } },
                { "backup", new Incident.Inputs.EscalationPathTemplateParamsArgs
                {
                    Label = "Backup responder",
                    Type = "CatalogEntry[\"User\"]",
                } },
            },
            Start = "main",
            Sequences = 
            {
                { "main", new Incident.Inputs.EscalationPathTemplateSequencesArgs
                {
                    Nodes = new[]
                    {
                        new Incident.Inputs.EscalationPathTemplateSequencesNodeArgs
                        {
                            Level = new Incident.Inputs.EscalationPathTemplateSequencesNodeLevelArgs
                            {
                                Targets = new[]
                                {
                                    new Incident.Inputs.EscalationPathTemplateSequencesNodeLevelTargetArgs
                                    {
                                        Type = "schedule",
                                        Urgency = "high",
                                        Binding = new Incident.Inputs.EscalationPathTemplateSequencesNodeLevelTargetBindingArgs
                                        {
                                            ValueReference = "primary_schedule",
                                        },
                                    },
                                },
                                TimeToAckSeconds = 300,
                            },
                        },
                        new Incident.Inputs.EscalationPathTemplateSequencesNodeArgs
                        {
                            Level = new Incident.Inputs.EscalationPathTemplateSequencesNodeLevelArgs
                            {
                                Targets = new[]
                                {
                                    new Incident.Inputs.EscalationPathTemplateSequencesNodeLevelTargetArgs
                                    {
                                        Type = "user",
                                        Urgency = "high",
                                        Binding = new Incident.Inputs.EscalationPathTemplateSequencesNodeLevelTargetBindingArgs
                                        {
                                            ValueReference = "backup",
                                        },
                                    },
                                },
                                TimeToAckSeconds = 600,
                            },
                        },
                    },
                } },
            },
        });
    
        // The paths built from it. Each names the template and binds its params, and has no
        // sequences of its own.
        var payments = new Incident.Schedule("payments", new()
        {
            Name = "Payments primary",
            Timezone = "Europe/London",
        });
    
        var paymentsLead = Incident.GetUser.Invoke(new()
        {
            Email = "payments-lead@example.com",
        });
    
        var paymentsEscalationPath = new Incident.EscalationPath("payments", new()
        {
            Name = "Payments on-call",
            Kind = "templated",
            TemplateId = teamOncall.Id,
            ParamBindings = 
            {
                { "primary_schedule", new Incident.Inputs.EscalationPathParamBindingsArgs
                {
                    ValueLiteral = payments.Id,
                } },
                { "backup", new Incident.Inputs.EscalationPathParamBindingsArgs
                {
                    ValueLiteral = paymentsLead.Apply(getUserResult => getUserResult.Id),
                } },
            },
        });
    
        // To page one rotation of a bound schedule, bind the target to an expression that
        // navigates the schedule's rotations and keeps the one with that name.
        var primaryRotation = new Incident.EscalationPathTemplate("primary_rotation", new()
        {
            Name = "Primary rotation",
            Params = 
            {
                { "schedule", new Incident.Inputs.EscalationPathTemplateParamsArgs
                {
                    Label = "Schedule",
                    Type = "CatalogEntry[\"Schedule\"]",
                } },
            },
            Expressions = new[]
            {
                new Incident.Inputs.EscalationPathTemplateExpressionArgs
                {
                    Label = "Primary rotation",
                    Reference = "primary_rotation",
                    RootReference = "schedule",
                    Operations = new[]
                    {
                        new Incident.Inputs.EscalationPathTemplateExpressionOperationArgs
                        {
                            OperationType = "navigate",
                            Navigate = new Incident.Inputs.EscalationPathTemplateExpressionOperationNavigateArgs
                            {
                                Reference = "rotations",
                            },
                        },
                        new Incident.Inputs.EscalationPathTemplateExpressionOperationArgs
                        {
                            OperationType = "filter",
                            Filter = new Incident.Inputs.EscalationPathTemplateExpressionOperationFilterArgs
                            {
                                ConditionGroups = new[]
                                {
                                    new Incident.Inputs.EscalationPathTemplateExpressionOperationFilterConditionGroupArgs
                                    {
                                        Conditions = new[]
                                        {
                                            new Incident.Inputs.EscalationPathTemplateExpressionOperationFilterConditionGroupConditionArgs
                                            {
                                                Subject = "input.name",
                                                Operation = "equals",
                                                ParamBindings = new[]
                                                {
                                                    new Incident.Inputs.EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingArgs
                                                    {
                                                        Value = new Incident.Inputs.EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingValueArgs
                                                        {
                                                            Literal = "Primary",
                                                        },
                                                    },
                                                },
                                            },
                                        },
                                    },
                                },
                            },
                        },
                    },
                },
            },
            Start = "main",
            Sequences = 
            {
                { "main", new Incident.Inputs.EscalationPathTemplateSequencesArgs
                {
                    Nodes = new[]
                    {
                        new Incident.Inputs.EscalationPathTemplateSequencesNodeArgs
                        {
                            Level = new Incident.Inputs.EscalationPathTemplateSequencesNodeLevelArgs
                            {
                                Targets = new[]
                                {
                                    new Incident.Inputs.EscalationPathTemplateSequencesNodeLevelTargetArgs
                                    {
                                        Type = "schedule",
                                        Urgency = "high",
                                        ScheduleMode = "currently_on_call_for_rota",
                                        Binding = new Incident.Inputs.EscalationPathTemplateSequencesNodeLevelTargetBindingArgs
                                        {
                                            ExpressionRef = "primary_rotation",
                                        },
                                    },
                                },
                                TimeToAckSeconds = 300,
                            },
                        },
                    },
                } },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.incident.EscalationPathTemplate;
    import com.pulumi.incident.EscalationPathTemplateArgs;
    import com.pulumi.incident.inputs.EscalationPathTemplateParamsArgs;
    import com.pulumi.incident.inputs.EscalationPathTemplateSequencesArgs;
    import com.pulumi.incident.inputs.EscalationPathTemplateSequencesNodeArgs;
    import com.pulumi.incident.inputs.EscalationPathTemplateSequencesNodeLevelArgs;
    import com.pulumi.incident.inputs.EscalationPathTemplateSequencesNodeLevelTargetArgs;
    import com.pulumi.incident.inputs.EscalationPathTemplateSequencesNodeLevelTargetBindingArgs;
    import com.pulumi.incident.Schedule;
    import com.pulumi.incident.ScheduleArgs;
    import com.pulumi.incident.IncidentFunctions;
    import com.pulumi.incident.inputs.GetUserArgs;
    import com.pulumi.incident.EscalationPath;
    import com.pulumi.incident.EscalationPathArgs;
    import com.pulumi.incident.inputs.EscalationPathParamBindingsArgs;
    import com.pulumi.incident.inputs.EscalationPathTemplateExpressionArgs;
    import com.pulumi.incident.inputs.EscalationPathTemplateExpressionOperationArgs;
    import com.pulumi.incident.inputs.EscalationPathTemplateExpressionOperationNavigateArgs;
    import com.pulumi.incident.inputs.EscalationPathTemplateExpressionOperationFilterArgs;
    import com.pulumi.incident.inputs.EscalationPathTemplateExpressionOperationFilterConditionGroupArgs;
    import com.pulumi.incident.inputs.EscalationPathTemplateExpressionOperationFilterConditionGroupConditionArgs;
    import com.pulumi.incident.inputs.EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingArgs;
    import com.pulumi.incident.inputs.EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingValueArgs;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            // A template pages a team's primary schedule, then their backup, with the schedule and
            // backup left as parameters for each team to fill in.
            var teamOncall = new EscalationPathTemplate("teamOncall", EscalationPathTemplateArgs.builder()
                .name("Team on-call")
                .description("Primary schedule, then a backup responder")
                .params(Map.ofEntries(
                    Map.entry("primary_schedule", EscalationPathTemplateParamsArgs.builder()
                        .label("Primary schedule")
                        .type("CatalogEntry[\"Schedule\"]")
                        .build()),
                    Map.entry("backup", EscalationPathTemplateParamsArgs.builder()
                        .label("Backup responder")
                        .type("CatalogEntry[\"User\"]")
                        .build())
                ))
                .start("main")
                .sequences(Map.of("main", EscalationPathTemplateSequencesArgs.builder()
                    .nodes(                
                        EscalationPathTemplateSequencesNodeArgs.builder()
                            .level(EscalationPathTemplateSequencesNodeLevelArgs.builder()
                                .targets(EscalationPathTemplateSequencesNodeLevelTargetArgs.builder()
                                    .type("schedule")
                                    .urgency("high")
                                    .binding(EscalationPathTemplateSequencesNodeLevelTargetBindingArgs.builder()
                                        .valueReference("primary_schedule")
                                        .build())
                                    .build())
                                .timeToAckSeconds(300)
                                .build())
                            .build(),
                        EscalationPathTemplateSequencesNodeArgs.builder()
                            .level(EscalationPathTemplateSequencesNodeLevelArgs.builder()
                                .targets(EscalationPathTemplateSequencesNodeLevelTargetArgs.builder()
                                    .type("user")
                                    .urgency("high")
                                    .binding(EscalationPathTemplateSequencesNodeLevelTargetBindingArgs.builder()
                                        .valueReference("backup")
                                        .build())
                                    .build())
                                .timeToAckSeconds(600)
                                .build())
                            .build())
                    .build()))
                .build());
    
            // The paths built from it. Each names the template and binds its params, and has no
            // sequences of its own.
            var payments = new Schedule("payments", ScheduleArgs.builder()
                .name("Payments primary")
                .timezone("Europe/London")
                .build());
    
            final var paymentsLead = IncidentFunctions.getUser(GetUserArgs.builder()
                .email("payments-lead@example.com")
                .build());
    
            var paymentsEscalationPath = new EscalationPath("paymentsEscalationPath", EscalationPathArgs.builder()
                .name("Payments on-call")
                .kind("templated")
                .templateId(teamOncall.id())
                .paramBindings(Map.ofEntries(
                    Map.entry("primary_schedule", EscalationPathParamBindingsArgs.builder()
                        .valueLiteral(payments.id())
                        .build()),
                    Map.entry("backup", EscalationPathParamBindingsArgs.builder()
                        .valueLiteral(paymentsLead.id())
                        .build())
                ))
                .build());
    
            // To page one rotation of a bound schedule, bind the target to an expression that
            // navigates the schedule's rotations and keeps the one with that name.
            var primaryRotation = new EscalationPathTemplate("primaryRotation", EscalationPathTemplateArgs.builder()
                .name("Primary rotation")
                .params(Map.of("schedule", EscalationPathTemplateParamsArgs.builder()
                    .label("Schedule")
                    .type("CatalogEntry[\"Schedule\"]")
                    .build()))
                .expressions(EscalationPathTemplateExpressionArgs.builder()
                    .label("Primary rotation")
                    .reference("primary_rotation")
                    .rootReference("schedule")
                    .operations(                
                        EscalationPathTemplateExpressionOperationArgs.builder()
                            .operationType("navigate")
                            .navigate(EscalationPathTemplateExpressionOperationNavigateArgs.builder()
                                .reference("rotations")
                                .build())
                            .build(),
                        EscalationPathTemplateExpressionOperationArgs.builder()
                            .operationType("filter")
                            .filter(EscalationPathTemplateExpressionOperationFilterArgs.builder()
                                .conditionGroups(EscalationPathTemplateExpressionOperationFilterConditionGroupArgs.builder()
                                    .conditions(EscalationPathTemplateExpressionOperationFilterConditionGroupConditionArgs.builder()
                                        .subject("input.name")
                                        .operation("equals")
                                        .paramBindings(EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingArgs.builder()
                                            .value(EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingValueArgs.builder()
                                                .literal("Primary")
                                                .build())
                                            .build())
                                        .build())
                                    .build())
                                .build())
                            .build())
                    .build())
                .start("main")
                .sequences(Map.of("main", EscalationPathTemplateSequencesArgs.builder()
                    .nodes(EscalationPathTemplateSequencesNodeArgs.builder()
                        .level(EscalationPathTemplateSequencesNodeLevelArgs.builder()
                            .targets(EscalationPathTemplateSequencesNodeLevelTargetArgs.builder()
                                .type("schedule")
                                .urgency("high")
                                .scheduleMode("currently_on_call_for_rota")
                                .binding(EscalationPathTemplateSequencesNodeLevelTargetBindingArgs.builder()
                                    .expressionRef("primary_rotation")
                                    .build())
                                .build())
                            .timeToAckSeconds(300)
                            .build())
                        .build())
                    .build()))
                .build());
    
        }
    }
    
    resources:
      # A template pages a team's primary schedule, then their backup, with the schedule and
      # backup left as parameters for each team to fill in.
      teamOncall:
        type: incident:EscalationPathTemplate
        name: team_oncall
        properties:
          name: Team on-call
          description: Primary schedule, then a backup responder
          params:
            primary_schedule:
              label: Primary schedule
              type: CatalogEntry["Schedule"]
            backup:
              label: Backup responder
              type: CatalogEntry["User"]
          start: main
          sequences:
            main:
              nodes:
                - level:
                    targets:
                      - type: schedule
                        urgency: high
                        binding:
                          valueReference: primary_schedule
                    timeToAckSeconds: 300
                - level:
                    targets:
                      - type: user
                        urgency: high
                        binding:
                          valueReference: backup
                    timeToAckSeconds: 600
      # The paths built from it. Each names the template and binds its params, and has no
      # sequences of its own.
      payments:
        type: incident:Schedule
        properties:
          name: Payments primary
          timezone: Europe/London
      paymentsEscalationPath:
        type: incident:EscalationPath
        name: payments
        properties:
          name: Payments on-call
          kind: templated
          templateId: ${teamOncall.id}
          paramBindings:
            primary_schedule:
              valueLiteral: ${payments.id}
            backup:
              valueLiteral: ${paymentsLead.id}
      # To page one rotation of a bound schedule, bind the target to an expression that
      # navigates the schedule's rotations and keeps the one with that name.
      primaryRotation:
        type: incident:EscalationPathTemplate
        name: primary_rotation
        properties:
          name: Primary rotation
          params:
            schedule:
              label: Schedule
              type: CatalogEntry["Schedule"]
          expressions:
            - label: Primary rotation
              reference: primary_rotation
              rootReference: schedule
              operations:
                - operationType: navigate
                  navigate:
                    reference: rotations
                - operationType: filter
                  filter:
                    conditionGroups:
                      - conditions:
                          - subject: input.name
                            operation: equals
                            paramBindings:
                              - value:
                                  literal: Primary
          start: main
          sequences:
            main:
              nodes:
                - level:
                    targets:
                      - type: schedule
                        urgency: high
                        scheduleMode: currently_on_call_for_rota
                        binding:
                          expressionRef: primary_rotation
                    timeToAckSeconds: 300
    variables:
      paymentsLead:
        fn::invoke:
          function: incident:getUser
          arguments:
            email: payments-lead@example.com
    
    pulumi {
      required_providers {
        incident = {
          source = "pulumi/incident"
        }
      }
    }
    
    data "incident_getuser" "paymentsLead" {
      email = "payments-lead@example.com"
    }
    
    # A template pages a team's primary schedule, then their backup, with the schedule and
    # backup left as parameters for each team to fill in.
    resource "incident_escalationpathtemplate" "team_oncall" {
      name        = "Team on-call"
      description = "Primary schedule, then a backup responder"
      params = {
        "primary_schedule" = {
          label = "Primary schedule"
          type  = "CatalogEntry[\"Schedule\"]"
        }
        "backup" = {
          label = "Backup responder"
          type  = "CatalogEntry[\"User\"]"
        }
      }
      start = "main"
      sequences = {
        "main" = {
          nodes = [{
            "level" = {
              "targets" = [{
                "type"    = "schedule"
                "urgency" = "high"
                "binding" = {
                  "valueReference" = "primary_schedule"
                }
              }]
              "timeToAckSeconds" = 300
            }
            }, {
            "level" = {
              "targets" = [{
                "type"    = "user"
                "urgency" = "high"
                "binding" = {
                  "valueReference" = "backup"
                }
              }]
              "timeToAckSeconds" = 600
            }
          }]
        }
      }
    }
    # The paths built from it. Each names the template and binds its params, and has no
    # sequences of its own.
    resource "incident_schedule" "payments" {
      name     = "Payments primary"
      timezone = "Europe/London"
    }
    resource "incident_escalationpath" "payments" {
      name        = "Payments on-call"
      kind        = "templated"
      template_id = incident_escalationpathtemplate.team_oncall.id
      param_bindings = {
        "primary_schedule" = {
          value_literal = incident_schedule.payments.id
        }
        "backup" = {
          value_literal = data.incident_getuser.paymentsLead.id
        }
      }
    }
    # To page one rotation of a bound schedule, bind the target to an expression that
    # navigates the schedule's rotations and keeps the one with that name.
    resource "incident_escalationpathtemplate" "primary_rotation" {
      name = "Primary rotation"
      params = {
        "schedule" = {
          label = "Schedule"
          type  = "CatalogEntry[\"Schedule\"]"
        }
      }
      expressions {
        label          = "Primary rotation"
        reference      = "primary_rotation"
        root_reference = "schedule"
        operations {
          operation_type = "navigate"
          navigate = {
            reference = "rotations"
          }
        }
        operations {
          operation_type = "filter"
          filter = {
            condition_groups = [{
              "conditions" = [{
                "subject"   = "input.name"
                "operation" = "equals"
                "paramBindings" = [{
                  "value" = {
                    "literal" = "Primary"
                  }
                }]
              }]
            }]
          }
        }
      }
      start = "main"
      sequences = {
        "main" = {
          nodes = [{
            "level" = {
              "targets" = [{
                "type"         = "schedule"
                "urgency"      = "high"
                "scheduleMode" = "currently_on_call_for_rota"
                "binding" = {
                  "expressionRef" = "primary_rotation"
                }
              }]
              "timeToAckSeconds" = 300
            }
          }]
        }
      }
    }
    

    Create EscalationPathTemplate Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new EscalationPathTemplate(name: string, args: EscalationPathTemplateArgs, opts?: CustomResourceOptions);
    @overload
    def EscalationPathTemplate(resource_name: str,
                               args: EscalationPathTemplateArgs,
                               opts: Optional[ResourceOptions] = None)
    
    @overload
    def EscalationPathTemplate(resource_name: str,
                               opts: Optional[ResourceOptions] = None,
                               sequences: Optional[Mapping[str, EscalationPathTemplateSequencesArgs]] = None,
                               start: Optional[str] = None,
                               description: Optional[str] = None,
                               expressions: Optional[Sequence[EscalationPathTemplateExpressionArgs]] = None,
                               name: Optional[str] = None,
                               params: Optional[Mapping[str, EscalationPathTemplateParamsArgs]] = None,
                               repeat_config: Optional[EscalationPathTemplateRepeatConfigArgs] = None,
                               unlock_in_dashboard: Optional[bool] = None,
                               working_hours: Optional[Sequence[EscalationPathTemplateWorkingHourArgs]] = None)
    func NewEscalationPathTemplate(ctx *Context, name string, args EscalationPathTemplateArgs, opts ...ResourceOption) (*EscalationPathTemplate, error)
    public EscalationPathTemplate(string name, EscalationPathTemplateArgs args, CustomResourceOptions? opts = null)
    public EscalationPathTemplate(String name, EscalationPathTemplateArgs args)
    public EscalationPathTemplate(String name, EscalationPathTemplateArgs args, CustomResourceOptions options)
    
    type: incident:EscalationPathTemplate
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    
    resource "incident_escalation_path_template" "name" {
        # resource properties
    }

    Parameters

    name string
    The unique name of the resource.
    args EscalationPathTemplateArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args EscalationPathTemplateArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args EscalationPathTemplateArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args EscalationPathTemplateArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args EscalationPathTemplateArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var escalationPathTemplateResource = new Incident.EscalationPathTemplate("escalationPathTemplateResource", new()
    {
        Sequences = 
        {
            { "string", new Incident.Inputs.EscalationPathTemplateSequencesArgs
            {
                Nodes = new[]
                {
                    new Incident.Inputs.EscalationPathTemplateSequencesNodeArgs
                    {
                        Branch = new Incident.Inputs.EscalationPathTemplateSequencesNodeBranchArgs
                        {
                            If = new Incident.Inputs.EscalationPathTemplateSequencesNodeBranchIfArgs
                            {
                                PriorityOneOfs = new[]
                                {
                                    "string",
                                },
                                WorkingHoursActive = "string",
                            },
                            Then = "string",
                            Else = "string",
                        },
                        Delay = new Incident.Inputs.EscalationPathTemplateSequencesNodeDelayArgs
                        {
                            DelayIntervalCondition = "string",
                            DelaySeconds = 0,
                            DelayWeekdayIntervalConfigId = "string",
                        },
                        EscalationPath = new Incident.Inputs.EscalationPathTemplateSequencesNodeEscalationPathArgs
                        {
                            EscalationPathId = "string",
                        },
                        Id = "string",
                        Level = new Incident.Inputs.EscalationPathTemplateSequencesNodeLevelArgs
                        {
                            Targets = new[]
                            {
                                new Incident.Inputs.EscalationPathTemplateSequencesNodeLevelTargetArgs
                                {
                                    Type = "string",
                                    Urgency = "string",
                                    Binding = new Incident.Inputs.EscalationPathTemplateSequencesNodeLevelTargetBindingArgs
                                    {
                                        ArrayValues = new[]
                                        {
                                            new Incident.Inputs.EscalationPathTemplateSequencesNodeLevelTargetBindingArrayValueArgs
                                            {
                                                Literal = "string",
                                                Reference = "string",
                                            },
                                        },
                                        ExpressionRef = "string",
                                        Value = new Incident.Inputs.EscalationPathTemplateSequencesNodeLevelTargetBindingValueArgs
                                        {
                                            Literal = "string",
                                            Reference = "string",
                                        },
                                        ValueLiteral = "string",
                                        ValueReference = "string",
                                        Values = new[]
                                        {
                                            "string",
                                        },
                                    },
                                    Id = "string",
                                    ScheduleMode = "string",
                                    SelectedRotaId = "string",
                                },
                            },
                            AckMode = "string",
                            RetryConfig = new Incident.Inputs.EscalationPathTemplateSequencesNodeLevelRetryConfigArgs
                            {
                                Attempts = 0,
                                IntervalSeconds = 0,
                            },
                            RoundRobinConfig = new Incident.Inputs.EscalationPathTemplateSequencesNodeLevelRoundRobinConfigArgs
                            {
                                Enabled = false,
                                RotateAfterSeconds = 0,
                            },
                            TimeToAckIntervalCondition = "string",
                            TimeToAckSeconds = 0,
                            TimeToAckWeekdayIntervalConfigId = "string",
                        },
                        Loop = new Incident.Inputs.EscalationPathTemplateSequencesNodeLoopArgs
                        {
                            BackTo = "string",
                            Times = 0,
                        },
                        NotifyChannel = new Incident.Inputs.EscalationPathTemplateSequencesNodeNotifyChannelArgs
                        {
                            Targets = new[]
                            {
                                new Incident.Inputs.EscalationPathTemplateSequencesNodeNotifyChannelTargetArgs
                                {
                                    Type = "string",
                                    Urgency = "string",
                                    Binding = new Incident.Inputs.EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingArgs
                                    {
                                        ArrayValues = new[]
                                        {
                                            new Incident.Inputs.EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingArrayValueArgs
                                            {
                                                Literal = "string",
                                                Reference = "string",
                                            },
                                        },
                                        ExpressionRef = "string",
                                        Value = new Incident.Inputs.EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingValueArgs
                                        {
                                            Literal = "string",
                                            Reference = "string",
                                        },
                                        ValueLiteral = "string",
                                        ValueReference = "string",
                                        Values = new[]
                                        {
                                            "string",
                                        },
                                    },
                                    Id = "string",
                                    ScheduleMode = "string",
                                    SelectedRotaId = "string",
                                },
                            },
                            TimeToAckIntervalCondition = "string",
                            TimeToAckSeconds = 0,
                            TimeToAckWeekdayIntervalConfigId = "string",
                        },
                    },
                },
            } },
        },
        Start = "string",
        Description = "string",
        Expressions = new[]
        {
            new Incident.Inputs.EscalationPathTemplateExpressionArgs
            {
                Label = "string",
                Operations = new[]
                {
                    new Incident.Inputs.EscalationPathTemplateExpressionOperationArgs
                    {
                        OperationType = "string",
                        Branches = new Incident.Inputs.EscalationPathTemplateExpressionOperationBranchesArgs
                        {
                            Branches = new[]
                            {
                                new Incident.Inputs.EscalationPathTemplateExpressionOperationBranchesBranchArgs
                                {
                                    ConditionGroups = new[]
                                    {
                                        new Incident.Inputs.EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupArgs
                                        {
                                            Conditions = new[]
                                            {
                                                new Incident.Inputs.EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionArgs
                                                {
                                                    Operation = "string",
                                                    ParamBindings = new[]
                                                    {
                                                        new Incident.Inputs.EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArgs
                                                        {
                                                            ArrayValues = new[]
                                                            {
                                                                new Incident.Inputs.EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArrayValueArgs
                                                                {
                                                                    Literal = "string",
                                                                    Reference = "string",
                                                                },
                                                            },
                                                            ExpressionRef = "string",
                                                            Value = new Incident.Inputs.EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingValueArgs
                                                            {
                                                                Literal = "string",
                                                                Reference = "string",
                                                            },
                                                            ValueLiteral = "string",
                                                            ValueReference = "string",
                                                            Values = new[]
                                                            {
                                                                "string",
                                                            },
                                                        },
                                                    },
                                                    Subject = "string",
                                                },
                                            },
                                        },
                                    },
                                    Result = new Incident.Inputs.EscalationPathTemplateExpressionOperationBranchesBranchResultArgs
                                    {
                                        ArrayValues = new[]
                                        {
                                            new Incident.Inputs.EscalationPathTemplateExpressionOperationBranchesBranchResultArrayValueArgs
                                            {
                                                Literal = "string",
                                                Reference = "string",
                                            },
                                        },
                                        ExpressionRef = "string",
                                        Value = new Incident.Inputs.EscalationPathTemplateExpressionOperationBranchesBranchResultValueArgs
                                        {
                                            Literal = "string",
                                            Reference = "string",
                                        },
                                        ValueLiteral = "string",
                                        ValueReference = "string",
                                        Values = new[]
                                        {
                                            "string",
                                        },
                                    },
                                },
                            },
                            Returns = new Incident.Inputs.EscalationPathTemplateExpressionOperationBranchesReturnsArgs
                            {
                                Array = false,
                                Type = "string",
                            },
                        },
                        Cast = new Incident.Inputs.EscalationPathTemplateExpressionOperationCastArgs
                        {
                            Returns = new Incident.Inputs.EscalationPathTemplateExpressionOperationCastReturnsArgs
                            {
                                Array = false,
                                Type = "string",
                            },
                        },
                        Concatenate = new Incident.Inputs.EscalationPathTemplateExpressionOperationConcatenateArgs
                        {
                            Reference = "string",
                        },
                        Filter = new Incident.Inputs.EscalationPathTemplateExpressionOperationFilterArgs
                        {
                            ConditionGroups = new[]
                            {
                                new Incident.Inputs.EscalationPathTemplateExpressionOperationFilterConditionGroupArgs
                                {
                                    Conditions = new[]
                                    {
                                        new Incident.Inputs.EscalationPathTemplateExpressionOperationFilterConditionGroupConditionArgs
                                        {
                                            Operation = "string",
                                            ParamBindings = new[]
                                            {
                                                new Incident.Inputs.EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingArgs
                                                {
                                                    ArrayValues = new[]
                                                    {
                                                        new Incident.Inputs.EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingArrayValueArgs
                                                        {
                                                            Literal = "string",
                                                            Reference = "string",
                                                        },
                                                    },
                                                    ExpressionRef = "string",
                                                    Value = new Incident.Inputs.EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingValueArgs
                                                    {
                                                        Literal = "string",
                                                        Reference = "string",
                                                    },
                                                    ValueLiteral = "string",
                                                    ValueReference = "string",
                                                    Values = new[]
                                                    {
                                                        "string",
                                                    },
                                                },
                                            },
                                            Subject = "string",
                                        },
                                    },
                                },
                            },
                        },
                        Navigate = new Incident.Inputs.EscalationPathTemplateExpressionOperationNavigateArgs
                        {
                            Reference = "string",
                        },
                        Parse = new Incident.Inputs.EscalationPathTemplateExpressionOperationParseArgs
                        {
                            Returns = new Incident.Inputs.EscalationPathTemplateExpressionOperationParseReturnsArgs
                            {
                                Array = false,
                                Type = "string",
                            },
                            Source = "string",
                        },
                    },
                },
                Reference = "string",
                RootReference = "string",
                ElseBranch = new Incident.Inputs.EscalationPathTemplateExpressionElseBranchArgs
                {
                    Result = new Incident.Inputs.EscalationPathTemplateExpressionElseBranchResultArgs
                    {
                        ArrayValues = new[]
                        {
                            new Incident.Inputs.EscalationPathTemplateExpressionElseBranchResultArrayValueArgs
                            {
                                Literal = "string",
                                Reference = "string",
                            },
                        },
                        ExpressionRef = "string",
                        Value = new Incident.Inputs.EscalationPathTemplateExpressionElseBranchResultValueArgs
                        {
                            Literal = "string",
                            Reference = "string",
                        },
                        ValueLiteral = "string",
                        ValueReference = "string",
                        Values = new[]
                        {
                            "string",
                        },
                    },
                },
            },
        },
        Name = "string",
        Params = 
        {
            { "string", new Incident.Inputs.EscalationPathTemplateParamsArgs
            {
                Label = "string",
                Type = "string",
                Array = false,
                Description = "string",
                Optional = false,
            } },
        },
        RepeatConfig = new Incident.Inputs.EscalationPathTemplateRepeatConfigArgs
        {
            DelayRepeatOnActivity = false,
            RepeatAfterSeconds = 0,
        },
        UnlockInDashboard = false,
        WorkingHours = new[]
        {
            new Incident.Inputs.EscalationPathTemplateWorkingHourArgs
            {
                Id = "string",
                Name = "string",
                Timezone = "string",
                WeekdayIntervals = new[]
                {
                    new Incident.Inputs.EscalationPathTemplateWorkingHourWeekdayIntervalArgs
                    {
                        EndTime = "string",
                        StartTime = "string",
                        Weekday = "string",
                    },
                },
            },
        },
    });
    
    example, err := incident.NewEscalationPathTemplate(ctx, "escalationPathTemplateResource", &incident.EscalationPathTemplateArgs{
    	Sequences: incident.EscalationPathTemplateSequencesMap{
    		"string": &incident.EscalationPathTemplateSequencesArgs{
    			Nodes: incident.EscalationPathTemplateSequencesNodeArray{
    				&incident.EscalationPathTemplateSequencesNodeArgs{
    					Branch: &incident.EscalationPathTemplateSequencesNodeBranchArgs{
    						If: &incident.EscalationPathTemplateSequencesNodeBranchIfArgs{
    							PriorityOneOfs: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							WorkingHoursActive: pulumi.String("string"),
    						},
    						Then: pulumi.String("string"),
    						Else: pulumi.String("string"),
    					},
    					Delay: &incident.EscalationPathTemplateSequencesNodeDelayArgs{
    						DelayIntervalCondition:       pulumi.String("string"),
    						DelaySeconds:                 pulumi.Int(0),
    						DelayWeekdayIntervalConfigId: pulumi.String("string"),
    					},
    					EscalationPath: &incident.EscalationPathTemplateSequencesNodeEscalationPathArgs{
    						EscalationPathId: pulumi.String("string"),
    					},
    					Id: pulumi.String("string"),
    					Level: &incident.EscalationPathTemplateSequencesNodeLevelArgs{
    						Targets: incident.EscalationPathTemplateSequencesNodeLevelTargetArray{
    							&incident.EscalationPathTemplateSequencesNodeLevelTargetArgs{
    								Type:    pulumi.String("string"),
    								Urgency: pulumi.String("string"),
    								Binding: &incident.EscalationPathTemplateSequencesNodeLevelTargetBindingArgs{
    									ArrayValues: incident.EscalationPathTemplateSequencesNodeLevelTargetBindingArrayValueArray{
    										&incident.EscalationPathTemplateSequencesNodeLevelTargetBindingArrayValueArgs{
    											Literal:   pulumi.String("string"),
    											Reference: pulumi.String("string"),
    										},
    									},
    									ExpressionRef: pulumi.String("string"),
    									Value: &incident.EscalationPathTemplateSequencesNodeLevelTargetBindingValueArgs{
    										Literal:   pulumi.String("string"),
    										Reference: pulumi.String("string"),
    									},
    									ValueLiteral:   pulumi.String("string"),
    									ValueReference: pulumi.String("string"),
    									Values: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    								},
    								Id:             pulumi.String("string"),
    								ScheduleMode:   pulumi.String("string"),
    								SelectedRotaId: pulumi.String("string"),
    							},
    						},
    						AckMode: pulumi.String("string"),
    						RetryConfig: &incident.EscalationPathTemplateSequencesNodeLevelRetryConfigArgs{
    							Attempts:        pulumi.Int(0),
    							IntervalSeconds: pulumi.Int(0),
    						},
    						RoundRobinConfig: &incident.EscalationPathTemplateSequencesNodeLevelRoundRobinConfigArgs{
    							Enabled:            pulumi.Bool(false),
    							RotateAfterSeconds: pulumi.Int(0),
    						},
    						TimeToAckIntervalCondition:       pulumi.String("string"),
    						TimeToAckSeconds:                 pulumi.Int(0),
    						TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    					},
    					Loop: &incident.EscalationPathTemplateSequencesNodeLoopArgs{
    						BackTo: pulumi.String("string"),
    						Times:  pulumi.Int(0),
    					},
    					NotifyChannel: &incident.EscalationPathTemplateSequencesNodeNotifyChannelArgs{
    						Targets: incident.EscalationPathTemplateSequencesNodeNotifyChannelTargetArray{
    							&incident.EscalationPathTemplateSequencesNodeNotifyChannelTargetArgs{
    								Type:    pulumi.String("string"),
    								Urgency: pulumi.String("string"),
    								Binding: &incident.EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingArgs{
    									ArrayValues: incident.EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingArrayValueArray{
    										&incident.EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingArrayValueArgs{
    											Literal:   pulumi.String("string"),
    											Reference: pulumi.String("string"),
    										},
    									},
    									ExpressionRef: pulumi.String("string"),
    									Value: &incident.EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingValueArgs{
    										Literal:   pulumi.String("string"),
    										Reference: pulumi.String("string"),
    									},
    									ValueLiteral:   pulumi.String("string"),
    									ValueReference: pulumi.String("string"),
    									Values: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    								},
    								Id:             pulumi.String("string"),
    								ScheduleMode:   pulumi.String("string"),
    								SelectedRotaId: pulumi.String("string"),
    							},
    						},
    						TimeToAckIntervalCondition:       pulumi.String("string"),
    						TimeToAckSeconds:                 pulumi.Int(0),
    						TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    					},
    				},
    			},
    		},
    	},
    	Start:       pulumi.String("string"),
    	Description: pulumi.String("string"),
    	Expressions: incident.EscalationPathTemplateExpressionArray{
    		&incident.EscalationPathTemplateExpressionArgs{
    			Label: pulumi.String("string"),
    			Operations: incident.EscalationPathTemplateExpressionOperationArray{
    				&incident.EscalationPathTemplateExpressionOperationArgs{
    					OperationType: pulumi.String("string"),
    					Branches: &incident.EscalationPathTemplateExpressionOperationBranchesArgs{
    						Branches: incident.EscalationPathTemplateExpressionOperationBranchesBranchArray{
    							&incident.EscalationPathTemplateExpressionOperationBranchesBranchArgs{
    								ConditionGroups: incident.EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupArray{
    									&incident.EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupArgs{
    										Conditions: incident.EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionArray{
    											&incident.EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionArgs{
    												Operation: pulumi.String("string"),
    												ParamBindings: incident.EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArray{
    													&incident.EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArgs{
    														ArrayValues: incident.EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArrayValueArray{
    															&incident.EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArrayValueArgs{
    																Literal:   pulumi.String("string"),
    																Reference: pulumi.String("string"),
    															},
    														},
    														ExpressionRef: pulumi.String("string"),
    														Value: &incident.EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingValueArgs{
    															Literal:   pulumi.String("string"),
    															Reference: pulumi.String("string"),
    														},
    														ValueLiteral:   pulumi.String("string"),
    														ValueReference: pulumi.String("string"),
    														Values: pulumi.StringArray{
    															pulumi.String("string"),
    														},
    													},
    												},
    												Subject: pulumi.String("string"),
    											},
    										},
    									},
    								},
    								Result: &incident.EscalationPathTemplateExpressionOperationBranchesBranchResultArgs{
    									ArrayValues: incident.EscalationPathTemplateExpressionOperationBranchesBranchResultArrayValueArray{
    										&incident.EscalationPathTemplateExpressionOperationBranchesBranchResultArrayValueArgs{
    											Literal:   pulumi.String("string"),
    											Reference: pulumi.String("string"),
    										},
    									},
    									ExpressionRef: pulumi.String("string"),
    									Value: &incident.EscalationPathTemplateExpressionOperationBranchesBranchResultValueArgs{
    										Literal:   pulumi.String("string"),
    										Reference: pulumi.String("string"),
    									},
    									ValueLiteral:   pulumi.String("string"),
    									ValueReference: pulumi.String("string"),
    									Values: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    								},
    							},
    						},
    						Returns: &incident.EscalationPathTemplateExpressionOperationBranchesReturnsArgs{
    							Array: pulumi.Bool(false),
    							Type:  pulumi.String("string"),
    						},
    					},
    					Cast: &incident.EscalationPathTemplateExpressionOperationCastArgs{
    						Returns: &incident.EscalationPathTemplateExpressionOperationCastReturnsArgs{
    							Array: pulumi.Bool(false),
    							Type:  pulumi.String("string"),
    						},
    					},
    					Concatenate: &incident.EscalationPathTemplateExpressionOperationConcatenateArgs{
    						Reference: pulumi.String("string"),
    					},
    					Filter: &incident.EscalationPathTemplateExpressionOperationFilterArgs{
    						ConditionGroups: incident.EscalationPathTemplateExpressionOperationFilterConditionGroupArray{
    							&incident.EscalationPathTemplateExpressionOperationFilterConditionGroupArgs{
    								Conditions: incident.EscalationPathTemplateExpressionOperationFilterConditionGroupConditionArray{
    									&incident.EscalationPathTemplateExpressionOperationFilterConditionGroupConditionArgs{
    										Operation: pulumi.String("string"),
    										ParamBindings: incident.EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingArray{
    											&incident.EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingArgs{
    												ArrayValues: incident.EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingArrayValueArray{
    													&incident.EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingArrayValueArgs{
    														Literal:   pulumi.String("string"),
    														Reference: pulumi.String("string"),
    													},
    												},
    												ExpressionRef: pulumi.String("string"),
    												Value: &incident.EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingValueArgs{
    													Literal:   pulumi.String("string"),
    													Reference: pulumi.String("string"),
    												},
    												ValueLiteral:   pulumi.String("string"),
    												ValueReference: pulumi.String("string"),
    												Values: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    											},
    										},
    										Subject: pulumi.String("string"),
    									},
    								},
    							},
    						},
    					},
    					Navigate: &incident.EscalationPathTemplateExpressionOperationNavigateArgs{
    						Reference: pulumi.String("string"),
    					},
    					Parse: &incident.EscalationPathTemplateExpressionOperationParseArgs{
    						Returns: &incident.EscalationPathTemplateExpressionOperationParseReturnsArgs{
    							Array: pulumi.Bool(false),
    							Type:  pulumi.String("string"),
    						},
    						Source: pulumi.String("string"),
    					},
    				},
    			},
    			Reference:     pulumi.String("string"),
    			RootReference: pulumi.String("string"),
    			ElseBranch: &incident.EscalationPathTemplateExpressionElseBranchArgs{
    				Result: &incident.EscalationPathTemplateExpressionElseBranchResultArgs{
    					ArrayValues: incident.EscalationPathTemplateExpressionElseBranchResultArrayValueArray{
    						&incident.EscalationPathTemplateExpressionElseBranchResultArrayValueArgs{
    							Literal:   pulumi.String("string"),
    							Reference: pulumi.String("string"),
    						},
    					},
    					ExpressionRef: pulumi.String("string"),
    					Value: &incident.EscalationPathTemplateExpressionElseBranchResultValueArgs{
    						Literal:   pulumi.String("string"),
    						Reference: pulumi.String("string"),
    					},
    					ValueLiteral:   pulumi.String("string"),
    					ValueReference: pulumi.String("string"),
    					Values: pulumi.StringArray{
    						pulumi.String("string"),
    					},
    				},
    			},
    		},
    	},
    	Name: pulumi.String("string"),
    	Params: incident.EscalationPathTemplateParamsMap{
    		"string": &incident.EscalationPathTemplateParamsArgs{
    			Label:       pulumi.String("string"),
    			Type:        pulumi.String("string"),
    			Array:       pulumi.Bool(false),
    			Description: pulumi.String("string"),
    			Optional:    pulumi.Bool(false),
    		},
    	},
    	RepeatConfig: &incident.EscalationPathTemplateRepeatConfigArgs{
    		DelayRepeatOnActivity: pulumi.Bool(false),
    		RepeatAfterSeconds:    pulumi.Int(0),
    	},
    	UnlockInDashboard: pulumi.Bool(false),
    	WorkingHours: incident.EscalationPathTemplateWorkingHourArray{
    		&incident.EscalationPathTemplateWorkingHourArgs{
    			Id:       pulumi.String("string"),
    			Name:     pulumi.String("string"),
    			Timezone: pulumi.String("string"),
    			WeekdayIntervals: incident.EscalationPathTemplateWorkingHourWeekdayIntervalArray{
    				&incident.EscalationPathTemplateWorkingHourWeekdayIntervalArgs{
    					EndTime:   pulumi.String("string"),
    					StartTime: pulumi.String("string"),
    					Weekday:   pulumi.String("string"),
    				},
    			},
    		},
    	},
    })
    
    resource "incident_escalation_path_template" "escalationPathTemplateResource" {
      lifecycle {
        create_before_destroy = true
      }
      sequences = {
        "string" = {
          nodes = [{
            branch = {
              if = {
                priority_one_ofs     = ["string"]
                working_hours_active = "string"
              }
              then = "string"
              else = "string"
            }
            delay = {
              delay_interval_condition         = "string"
              delay_seconds                    = 0
              delay_weekday_interval_config_id = "string"
            }
            escalation_path = {
              escalation_path_id = "string"
            }
            id = "string"
            level = {
              targets = [{
                type    = "string"
                urgency = "string"
                binding = {
                  array_values = [{
                    literal   = "string"
                    reference = "string"
                  }]
                  expression_ref = "string"
                  value = {
                    literal   = "string"
                    reference = "string"
                  }
                  value_literal   = "string"
                  value_reference = "string"
                  values          = ["string"]
                }
                id               = "string"
                schedule_mode    = "string"
                selected_rota_id = "string"
              }]
              ack_mode = "string"
              retry_config = {
                attempts         = 0
                interval_seconds = 0
              }
              round_robin_config = {
                enabled              = false
                rotate_after_seconds = 0
              }
              time_to_ack_interval_condition         = "string"
              time_to_ack_seconds                    = 0
              time_to_ack_weekday_interval_config_id = "string"
            }
            loop = {
              back_to = "string"
              times   = 0
            }
            notify_channel = {
              targets = [{
                type    = "string"
                urgency = "string"
                binding = {
                  array_values = [{
                    literal   = "string"
                    reference = "string"
                  }]
                  expression_ref = "string"
                  value = {
                    literal   = "string"
                    reference = "string"
                  }
                  value_literal   = "string"
                  value_reference = "string"
                  values          = ["string"]
                }
                id               = "string"
                schedule_mode    = "string"
                selected_rota_id = "string"
              }]
              time_to_ack_interval_condition         = "string"
              time_to_ack_seconds                    = 0
              time_to_ack_weekday_interval_config_id = "string"
            }
          }]
        }
      }
      start       = "string"
      description = "string"
      expressions {
        label = "string"
        operations {
          operation_type = "string"
          branches = {
            branches = [{
              condition_groups = [{
                conditions = [{
                  operation = "string"
                  param_bindings = [{
                    array_values = [{
                      literal   = "string"
                      reference = "string"
                    }]
                    expression_ref = "string"
                    value = {
                      literal   = "string"
                      reference = "string"
                    }
                    value_literal   = "string"
                    value_reference = "string"
                    values          = ["string"]
                  }]
                  subject = "string"
                }]
              }]
              result = {
                array_values = [{
                  literal   = "string"
                  reference = "string"
                }]
                expression_ref = "string"
                value = {
                  literal   = "string"
                  reference = "string"
                }
                value_literal   = "string"
                value_reference = "string"
                values          = ["string"]
              }
            }]
            returns = {
              array = false
              type  = "string"
            }
          }
          cast = {
            returns = {
              array = false
              type  = "string"
            }
          }
          concatenate = {
            reference = "string"
          }
          filter = {
            condition_groups = [{
              conditions = [{
                operation = "string"
                param_bindings = [{
                  array_values = [{
                    literal   = "string"
                    reference = "string"
                  }]
                  expression_ref = "string"
                  value = {
                    literal   = "string"
                    reference = "string"
                  }
                  value_literal   = "string"
                  value_reference = "string"
                  values          = ["string"]
                }]
                subject = "string"
              }]
            }]
          }
          navigate = {
            reference = "string"
          }
          parse = {
            returns = {
              array = false
              type  = "string"
            }
            source = "string"
          }
        }
        reference      = "string"
        root_reference = "string"
        else_branch = {
          result = {
            array_values = [{
              literal   = "string"
              reference = "string"
            }]
            expression_ref = "string"
            value = {
              literal   = "string"
              reference = "string"
            }
            value_literal   = "string"
            value_reference = "string"
            values          = ["string"]
          }
        }
      }
      name = "string"
      params = {
        "string" = {
          label       = "string"
          type        = "string"
          array       = false
          description = "string"
          optional    = false
        }
      }
      repeat_config = {
        delay_repeat_on_activity = false
        repeat_after_seconds     = 0
      }
      unlock_in_dashboard = false
      working_hours {
        id       = "string"
        name     = "string"
        timezone = "string"
        weekday_intervals {
          end_time   = "string"
          start_time = "string"
          weekday    = "string"
        }
      }
    }
    
    var escalationPathTemplateResource = new EscalationPathTemplate("escalationPathTemplateResource", EscalationPathTemplateArgs.builder()
        .sequences(Map.of("string", EscalationPathTemplateSequencesArgs.builder()
            .nodes(EscalationPathTemplateSequencesNodeArgs.builder()
                .branch(EscalationPathTemplateSequencesNodeBranchArgs.builder()
                    .if_(EscalationPathTemplateSequencesNodeBranchIfArgs.builder()
                        .priorityOneOfs("string")
                        .workingHoursActive("string")
                        .build())
                    .then("string")
                    .else_("string")
                    .build())
                .delay(EscalationPathTemplateSequencesNodeDelayArgs.builder()
                    .delayIntervalCondition("string")
                    .delaySeconds(0)
                    .delayWeekdayIntervalConfigId("string")
                    .build())
                .escalationPath(EscalationPathTemplateSequencesNodeEscalationPathArgs.builder()
                    .escalationPathId("string")
                    .build())
                .id("string")
                .level(EscalationPathTemplateSequencesNodeLevelArgs.builder()
                    .targets(EscalationPathTemplateSequencesNodeLevelTargetArgs.builder()
                        .type("string")
                        .urgency("string")
                        .binding(EscalationPathTemplateSequencesNodeLevelTargetBindingArgs.builder()
                            .arrayValues(EscalationPathTemplateSequencesNodeLevelTargetBindingArrayValueArgs.builder()
                                .literal("string")
                                .reference("string")
                                .build())
                            .expressionRef("string")
                            .value(EscalationPathTemplateSequencesNodeLevelTargetBindingValueArgs.builder()
                                .literal("string")
                                .reference("string")
                                .build())
                            .valueLiteral("string")
                            .valueReference("string")
                            .values("string")
                            .build())
                        .id("string")
                        .scheduleMode("string")
                        .selectedRotaId("string")
                        .build())
                    .ackMode("string")
                    .retryConfig(EscalationPathTemplateSequencesNodeLevelRetryConfigArgs.builder()
                        .attempts(0)
                        .intervalSeconds(0)
                        .build())
                    .roundRobinConfig(EscalationPathTemplateSequencesNodeLevelRoundRobinConfigArgs.builder()
                        .enabled(false)
                        .rotateAfterSeconds(0)
                        .build())
                    .timeToAckIntervalCondition("string")
                    .timeToAckSeconds(0)
                    .timeToAckWeekdayIntervalConfigId("string")
                    .build())
                .loop(EscalationPathTemplateSequencesNodeLoopArgs.builder()
                    .backTo("string")
                    .times(0)
                    .build())
                .notifyChannel(EscalationPathTemplateSequencesNodeNotifyChannelArgs.builder()
                    .targets(EscalationPathTemplateSequencesNodeNotifyChannelTargetArgs.builder()
                        .type("string")
                        .urgency("string")
                        .binding(EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingArgs.builder()
                            .arrayValues(EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingArrayValueArgs.builder()
                                .literal("string")
                                .reference("string")
                                .build())
                            .expressionRef("string")
                            .value(EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingValueArgs.builder()
                                .literal("string")
                                .reference("string")
                                .build())
                            .valueLiteral("string")
                            .valueReference("string")
                            .values("string")
                            .build())
                        .id("string")
                        .scheduleMode("string")
                        .selectedRotaId("string")
                        .build())
                    .timeToAckIntervalCondition("string")
                    .timeToAckSeconds(0)
                    .timeToAckWeekdayIntervalConfigId("string")
                    .build())
                .build())
            .build()))
        .start("string")
        .description("string")
        .expressions(EscalationPathTemplateExpressionArgs.builder()
            .label("string")
            .operations(EscalationPathTemplateExpressionOperationArgs.builder()
                .operationType("string")
                .branches(EscalationPathTemplateExpressionOperationBranchesArgs.builder()
                    .branches(EscalationPathTemplateExpressionOperationBranchesBranchArgs.builder()
                        .conditionGroups(EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupArgs.builder()
                            .conditions(EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionArgs.builder()
                                .operation("string")
                                .paramBindings(EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArgs.builder()
                                    .arrayValues(EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArrayValueArgs.builder()
                                        .literal("string")
                                        .reference("string")
                                        .build())
                                    .expressionRef("string")
                                    .value(EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingValueArgs.builder()
                                        .literal("string")
                                        .reference("string")
                                        .build())
                                    .valueLiteral("string")
                                    .valueReference("string")
                                    .values("string")
                                    .build())
                                .subject("string")
                                .build())
                            .build())
                        .result(EscalationPathTemplateExpressionOperationBranchesBranchResultArgs.builder()
                            .arrayValues(EscalationPathTemplateExpressionOperationBranchesBranchResultArrayValueArgs.builder()
                                .literal("string")
                                .reference("string")
                                .build())
                            .expressionRef("string")
                            .value(EscalationPathTemplateExpressionOperationBranchesBranchResultValueArgs.builder()
                                .literal("string")
                                .reference("string")
                                .build())
                            .valueLiteral("string")
                            .valueReference("string")
                            .values("string")
                            .build())
                        .build())
                    .returns(EscalationPathTemplateExpressionOperationBranchesReturnsArgs.builder()
                        .array(false)
                        .type("string")
                        .build())
                    .build())
                .cast(EscalationPathTemplateExpressionOperationCastArgs.builder()
                    .returns(EscalationPathTemplateExpressionOperationCastReturnsArgs.builder()
                        .array(false)
                        .type("string")
                        .build())
                    .build())
                .concatenate(EscalationPathTemplateExpressionOperationConcatenateArgs.builder()
                    .reference("string")
                    .build())
                .filter(EscalationPathTemplateExpressionOperationFilterArgs.builder()
                    .conditionGroups(EscalationPathTemplateExpressionOperationFilterConditionGroupArgs.builder()
                        .conditions(EscalationPathTemplateExpressionOperationFilterConditionGroupConditionArgs.builder()
                            .operation("string")
                            .paramBindings(EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingArgs.builder()
                                .arrayValues(EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingArrayValueArgs.builder()
                                    .literal("string")
                                    .reference("string")
                                    .build())
                                .expressionRef("string")
                                .value(EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingValueArgs.builder()
                                    .literal("string")
                                    .reference("string")
                                    .build())
                                .valueLiteral("string")
                                .valueReference("string")
                                .values("string")
                                .build())
                            .subject("string")
                            .build())
                        .build())
                    .build())
                .navigate(EscalationPathTemplateExpressionOperationNavigateArgs.builder()
                    .reference("string")
                    .build())
                .parse(EscalationPathTemplateExpressionOperationParseArgs.builder()
                    .returns(EscalationPathTemplateExpressionOperationParseReturnsArgs.builder()
                        .array(false)
                        .type("string")
                        .build())
                    .source("string")
                    .build())
                .build())
            .reference("string")
            .rootReference("string")
            .elseBranch(EscalationPathTemplateExpressionElseBranchArgs.builder()
                .result(EscalationPathTemplateExpressionElseBranchResultArgs.builder()
                    .arrayValues(EscalationPathTemplateExpressionElseBranchResultArrayValueArgs.builder()
                        .literal("string")
                        .reference("string")
                        .build())
                    .expressionRef("string")
                    .value(EscalationPathTemplateExpressionElseBranchResultValueArgs.builder()
                        .literal("string")
                        .reference("string")
                        .build())
                    .valueLiteral("string")
                    .valueReference("string")
                    .values("string")
                    .build())
                .build())
            .build())
        .name("string")
        .params(Map.of("string", EscalationPathTemplateParamsArgs.builder()
            .label("string")
            .type("string")
            .array(false)
            .description("string")
            .optional(false)
            .build()))
        .repeatConfig(EscalationPathTemplateRepeatConfigArgs.builder()
            .delayRepeatOnActivity(false)
            .repeatAfterSeconds(0)
            .build())
        .unlockInDashboard(false)
        .workingHours(EscalationPathTemplateWorkingHourArgs.builder()
            .id("string")
            .name("string")
            .timezone("string")
            .weekdayIntervals(EscalationPathTemplateWorkingHourWeekdayIntervalArgs.builder()
                .endTime("string")
                .startTime("string")
                .weekday("string")
                .build())
            .build())
        .build());
    
    escalation_path_template_resource = incident.EscalationPathTemplate("escalationPathTemplateResource",
        sequences={
            "string": {
                "nodes": [{
                    "branch": {
                        "if_": {
                            "priority_one_ofs": ["string"],
                            "working_hours_active": "string",
                        },
                        "then": "string",
                        "else_": "string",
                    },
                    "delay": {
                        "delay_interval_condition": "string",
                        "delay_seconds": 0,
                        "delay_weekday_interval_config_id": "string",
                    },
                    "escalation_path": {
                        "escalation_path_id": "string",
                    },
                    "id": "string",
                    "level": {
                        "targets": [{
                            "type": "string",
                            "urgency": "string",
                            "binding": {
                                "array_values": [{
                                    "literal": "string",
                                    "reference": "string",
                                }],
                                "expression_ref": "string",
                                "value": {
                                    "literal": "string",
                                    "reference": "string",
                                },
                                "value_literal": "string",
                                "value_reference": "string",
                                "values": ["string"],
                            },
                            "id": "string",
                            "schedule_mode": "string",
                            "selected_rota_id": "string",
                        }],
                        "ack_mode": "string",
                        "retry_config": {
                            "attempts": 0,
                            "interval_seconds": 0,
                        },
                        "round_robin_config": {
                            "enabled": False,
                            "rotate_after_seconds": 0,
                        },
                        "time_to_ack_interval_condition": "string",
                        "time_to_ack_seconds": 0,
                        "time_to_ack_weekday_interval_config_id": "string",
                    },
                    "loop": {
                        "back_to": "string",
                        "times": 0,
                    },
                    "notify_channel": {
                        "targets": [{
                            "type": "string",
                            "urgency": "string",
                            "binding": {
                                "array_values": [{
                                    "literal": "string",
                                    "reference": "string",
                                }],
                                "expression_ref": "string",
                                "value": {
                                    "literal": "string",
                                    "reference": "string",
                                },
                                "value_literal": "string",
                                "value_reference": "string",
                                "values": ["string"],
                            },
                            "id": "string",
                            "schedule_mode": "string",
                            "selected_rota_id": "string",
                        }],
                        "time_to_ack_interval_condition": "string",
                        "time_to_ack_seconds": 0,
                        "time_to_ack_weekday_interval_config_id": "string",
                    },
                }],
            },
        },
        start="string",
        description="string",
        expressions=[{
            "label": "string",
            "operations": [{
                "operation_type": "string",
                "branches": {
                    "branches": [{
                        "condition_groups": [{
                            "conditions": [{
                                "operation": "string",
                                "param_bindings": [{
                                    "array_values": [{
                                        "literal": "string",
                                        "reference": "string",
                                    }],
                                    "expression_ref": "string",
                                    "value": {
                                        "literal": "string",
                                        "reference": "string",
                                    },
                                    "value_literal": "string",
                                    "value_reference": "string",
                                    "values": ["string"],
                                }],
                                "subject": "string",
                            }],
                        }],
                        "result": {
                            "array_values": [{
                                "literal": "string",
                                "reference": "string",
                            }],
                            "expression_ref": "string",
                            "value": {
                                "literal": "string",
                                "reference": "string",
                            },
                            "value_literal": "string",
                            "value_reference": "string",
                            "values": ["string"],
                        },
                    }],
                    "returns": {
                        "array": False,
                        "type": "string",
                    },
                },
                "cast": {
                    "returns": {
                        "array": False,
                        "type": "string",
                    },
                },
                "concatenate": {
                    "reference": "string",
                },
                "filter": {
                    "condition_groups": [{
                        "conditions": [{
                            "operation": "string",
                            "param_bindings": [{
                                "array_values": [{
                                    "literal": "string",
                                    "reference": "string",
                                }],
                                "expression_ref": "string",
                                "value": {
                                    "literal": "string",
                                    "reference": "string",
                                },
                                "value_literal": "string",
                                "value_reference": "string",
                                "values": ["string"],
                            }],
                            "subject": "string",
                        }],
                    }],
                },
                "navigate": {
                    "reference": "string",
                },
                "parse": {
                    "returns": {
                        "array": False,
                        "type": "string",
                    },
                    "source": "string",
                },
            }],
            "reference": "string",
            "root_reference": "string",
            "else_branch": {
                "result": {
                    "array_values": [{
                        "literal": "string",
                        "reference": "string",
                    }],
                    "expression_ref": "string",
                    "value": {
                        "literal": "string",
                        "reference": "string",
                    },
                    "value_literal": "string",
                    "value_reference": "string",
                    "values": ["string"],
                },
            },
        }],
        name="string",
        params={
            "string": {
                "label": "string",
                "type": "string",
                "array": False,
                "description": "string",
                "optional": False,
            },
        },
        repeat_config={
            "delay_repeat_on_activity": False,
            "repeat_after_seconds": 0,
        },
        unlock_in_dashboard=False,
        working_hours=[{
            "id": "string",
            "name": "string",
            "timezone": "string",
            "weekday_intervals": [{
                "end_time": "string",
                "start_time": "string",
                "weekday": "string",
            }],
        }])
    
    const escalationPathTemplateResource = new incident.EscalationPathTemplate("escalationPathTemplateResource", {
        sequences: {
            string: {
                nodes: [{
                    branch: {
                        "if": {
                            priorityOneOfs: ["string"],
                            workingHoursActive: "string",
                        },
                        then: "string",
                        "else": "string",
                    },
                    delay: {
                        delayIntervalCondition: "string",
                        delaySeconds: 0,
                        delayWeekdayIntervalConfigId: "string",
                    },
                    escalationPath: {
                        escalationPathId: "string",
                    },
                    id: "string",
                    level: {
                        targets: [{
                            type: "string",
                            urgency: "string",
                            binding: {
                                arrayValues: [{
                                    literal: "string",
                                    reference: "string",
                                }],
                                expressionRef: "string",
                                value: {
                                    literal: "string",
                                    reference: "string",
                                },
                                valueLiteral: "string",
                                valueReference: "string",
                                values: ["string"],
                            },
                            id: "string",
                            scheduleMode: "string",
                            selectedRotaId: "string",
                        }],
                        ackMode: "string",
                        retryConfig: {
                            attempts: 0,
                            intervalSeconds: 0,
                        },
                        roundRobinConfig: {
                            enabled: false,
                            rotateAfterSeconds: 0,
                        },
                        timeToAckIntervalCondition: "string",
                        timeToAckSeconds: 0,
                        timeToAckWeekdayIntervalConfigId: "string",
                    },
                    loop: {
                        backTo: "string",
                        times: 0,
                    },
                    notifyChannel: {
                        targets: [{
                            type: "string",
                            urgency: "string",
                            binding: {
                                arrayValues: [{
                                    literal: "string",
                                    reference: "string",
                                }],
                                expressionRef: "string",
                                value: {
                                    literal: "string",
                                    reference: "string",
                                },
                                valueLiteral: "string",
                                valueReference: "string",
                                values: ["string"],
                            },
                            id: "string",
                            scheduleMode: "string",
                            selectedRotaId: "string",
                        }],
                        timeToAckIntervalCondition: "string",
                        timeToAckSeconds: 0,
                        timeToAckWeekdayIntervalConfigId: "string",
                    },
                }],
            },
        },
        start: "string",
        description: "string",
        expressions: [{
            label: "string",
            operations: [{
                operationType: "string",
                branches: {
                    branches: [{
                        conditionGroups: [{
                            conditions: [{
                                operation: "string",
                                paramBindings: [{
                                    arrayValues: [{
                                        literal: "string",
                                        reference: "string",
                                    }],
                                    expressionRef: "string",
                                    value: {
                                        literal: "string",
                                        reference: "string",
                                    },
                                    valueLiteral: "string",
                                    valueReference: "string",
                                    values: ["string"],
                                }],
                                subject: "string",
                            }],
                        }],
                        result: {
                            arrayValues: [{
                                literal: "string",
                                reference: "string",
                            }],
                            expressionRef: "string",
                            value: {
                                literal: "string",
                                reference: "string",
                            },
                            valueLiteral: "string",
                            valueReference: "string",
                            values: ["string"],
                        },
                    }],
                    returns: {
                        array: false,
                        type: "string",
                    },
                },
                cast: {
                    returns: {
                        array: false,
                        type: "string",
                    },
                },
                concatenate: {
                    reference: "string",
                },
                filter: {
                    conditionGroups: [{
                        conditions: [{
                            operation: "string",
                            paramBindings: [{
                                arrayValues: [{
                                    literal: "string",
                                    reference: "string",
                                }],
                                expressionRef: "string",
                                value: {
                                    literal: "string",
                                    reference: "string",
                                },
                                valueLiteral: "string",
                                valueReference: "string",
                                values: ["string"],
                            }],
                            subject: "string",
                        }],
                    }],
                },
                navigate: {
                    reference: "string",
                },
                parse: {
                    returns: {
                        array: false,
                        type: "string",
                    },
                    source: "string",
                },
            }],
            reference: "string",
            rootReference: "string",
            elseBranch: {
                result: {
                    arrayValues: [{
                        literal: "string",
                        reference: "string",
                    }],
                    expressionRef: "string",
                    value: {
                        literal: "string",
                        reference: "string",
                    },
                    valueLiteral: "string",
                    valueReference: "string",
                    values: ["string"],
                },
            },
        }],
        name: "string",
        params: {
            string: {
                label: "string",
                type: "string",
                array: false,
                description: "string",
                optional: false,
            },
        },
        repeatConfig: {
            delayRepeatOnActivity: false,
            repeatAfterSeconds: 0,
        },
        unlockInDashboard: false,
        workingHours: [{
            id: "string",
            name: "string",
            timezone: "string",
            weekdayIntervals: [{
                endTime: "string",
                startTime: "string",
                weekday: "string",
            }],
        }],
    });
    
    type: incident:EscalationPathTemplate
    properties:
        description: string
        expressions:
            - elseBranch:
                result:
                    arrayValues:
                        - literal: string
                          reference: string
                    expressionRef: string
                    value:
                        literal: string
                        reference: string
                    valueLiteral: string
                    valueReference: string
                    values:
                        - string
              label: string
              operations:
                - branches:
                    branches:
                        - conditionGroups:
                            - conditions:
                                - operation: string
                                  paramBindings:
                                    - arrayValues:
                                        - literal: string
                                          reference: string
                                      expressionRef: string
                                      value:
                                        literal: string
                                        reference: string
                                      valueLiteral: string
                                      valueReference: string
                                      values:
                                        - string
                                  subject: string
                          result:
                            arrayValues:
                                - literal: string
                                  reference: string
                            expressionRef: string
                            value:
                                literal: string
                                reference: string
                            valueLiteral: string
                            valueReference: string
                            values:
                                - string
                    returns:
                        array: false
                        type: string
                  cast:
                    returns:
                        array: false
                        type: string
                  concatenate:
                    reference: string
                  filter:
                    conditionGroups:
                        - conditions:
                            - operation: string
                              paramBindings:
                                - arrayValues:
                                    - literal: string
                                      reference: string
                                  expressionRef: string
                                  value:
                                    literal: string
                                    reference: string
                                  valueLiteral: string
                                  valueReference: string
                                  values:
                                    - string
                              subject: string
                  navigate:
                    reference: string
                  operationType: string
                  parse:
                    returns:
                        array: false
                        type: string
                    source: string
              reference: string
              rootReference: string
        name: string
        params:
            string:
                array: false
                description: string
                label: string
                optional: false
                type: string
        repeatConfig:
            delayRepeatOnActivity: false
            repeatAfterSeconds: 0
        sequences:
            string:
                nodes:
                    - branch:
                        else: string
                        if:
                            priorityOneOfs:
                                - string
                            workingHoursActive: string
                        then: string
                      delay:
                        delayIntervalCondition: string
                        delaySeconds: 0
                        delayWeekdayIntervalConfigId: string
                      escalationPath:
                        escalationPathId: string
                      id: string
                      level:
                        ackMode: string
                        retryConfig:
                            attempts: 0
                            intervalSeconds: 0
                        roundRobinConfig:
                            enabled: false
                            rotateAfterSeconds: 0
                        targets:
                            - binding:
                                arrayValues:
                                    - literal: string
                                      reference: string
                                expressionRef: string
                                value:
                                    literal: string
                                    reference: string
                                valueLiteral: string
                                valueReference: string
                                values:
                                    - string
                              id: string
                              scheduleMode: string
                              selectedRotaId: string
                              type: string
                              urgency: string
                        timeToAckIntervalCondition: string
                        timeToAckSeconds: 0
                        timeToAckWeekdayIntervalConfigId: string
                      loop:
                        backTo: string
                        times: 0
                      notifyChannel:
                        targets:
                            - binding:
                                arrayValues:
                                    - literal: string
                                      reference: string
                                expressionRef: string
                                value:
                                    literal: string
                                    reference: string
                                valueLiteral: string
                                valueReference: string
                                values:
                                    - string
                              id: string
                              scheduleMode: string
                              selectedRotaId: string
                              type: string
                              urgency: string
                        timeToAckIntervalCondition: string
                        timeToAckSeconds: 0
                        timeToAckWeekdayIntervalConfigId: string
        start: string
        unlockInDashboard: false
        workingHours:
            - id: string
              name: string
              timezone: string
              weekdayIntervals:
                - endTime: string
                  startTime: string
                  weekday: string
    

    EscalationPathTemplate Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The EscalationPathTemplate resource accepts the following input properties:

    Sequences Dictionary<string, EscalationPathTemplateSequencesArgs>
    Named sequences of nodes, keyed by a name you choose. Each sequence either ends with a branch node or runs off the end of the escalation path. Branches reference other sequences by key. A level or notifyChannel target may set binding instead of id, to be resolved per templated path.
    Start string
    The key of the sequence this template begins with.
    Description string
    A description of what this template is for.
    Expressions List<EscalationPathTemplateExpression>
    Expressions a target binding can name through expressionRef, each starting from one of the template's params (its rootReference). Use one to page something derived from a parameter, such as a team's lead.
    Name string
    The name of this template.
    Params Dictionary<string, EscalationPathTemplateParamsArgs>
    The parameters declared by this template. Keyed by the parameter's name, which is what a templated path binds it under in paramBindings and what a target's valueReference names.
    RepeatConfig EscalationPathTemplateRepeatConfig
    Controls if an escalation will repeat after acknowledgement, when the alert is unresolved. When configured, it will repeat after the specified delay.
    UnlockInDashboard bool
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    WorkingHours List<EscalationPathTemplateWorkingHour>
    The working hours for this template.
    Sequences map[string]EscalationPathTemplateSequencesArgs
    Named sequences of nodes, keyed by a name you choose. Each sequence either ends with a branch node or runs off the end of the escalation path. Branches reference other sequences by key. A level or notifyChannel target may set binding instead of id, to be resolved per templated path.
    Start string
    The key of the sequence this template begins with.
    Description string
    A description of what this template is for.
    Expressions []EscalationPathTemplateExpressionArgs
    Expressions a target binding can name through expressionRef, each starting from one of the template's params (its rootReference). Use one to page something derived from a parameter, such as a team's lead.
    Name string
    The name of this template.
    Params map[string]EscalationPathTemplateParamsArgs
    The parameters declared by this template. Keyed by the parameter's name, which is what a templated path binds it under in paramBindings and what a target's valueReference names.
    RepeatConfig EscalationPathTemplateRepeatConfigArgs
    Controls if an escalation will repeat after acknowledgement, when the alert is unresolved. When configured, it will repeat after the specified delay.
    UnlockInDashboard bool
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    WorkingHours []EscalationPathTemplateWorkingHourArgs
    The working hours for this template.
    sequences map(object)
    Named sequences of nodes, keyed by a name you choose. Each sequence either ends with a branch node or runs off the end of the escalation path. Branches reference other sequences by key. A level or notifyChannel target may set binding instead of id, to be resolved per templated path.
    start string
    The key of the sequence this template begins with.
    description string
    A description of what this template is for.
    expressions list(object)
    Expressions a target binding can name through expressionRef, each starting from one of the template's params (its rootReference). Use one to page something derived from a parameter, such as a team's lead.
    name string
    The name of this template.
    params map(object)
    The parameters declared by this template. Keyed by the parameter's name, which is what a templated path binds it under in paramBindings and what a target's valueReference names.
    repeat_config object
    Controls if an escalation will repeat after acknowledgement, when the alert is unresolved. When configured, it will repeat after the specified delay.
    unlock_in_dashboard bool
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    working_hours list(object)
    The working hours for this template.
    sequences Map<String,EscalationPathTemplateSequencesArgs>
    Named sequences of nodes, keyed by a name you choose. Each sequence either ends with a branch node or runs off the end of the escalation path. Branches reference other sequences by key. A level or notifyChannel target may set binding instead of id, to be resolved per templated path.
    start String
    The key of the sequence this template begins with.
    description String
    A description of what this template is for.
    expressions List<EscalationPathTemplateExpression>
    Expressions a target binding can name through expressionRef, each starting from one of the template's params (its rootReference). Use one to page something derived from a parameter, such as a team's lead.
    name String
    The name of this template.
    params Map<String,EscalationPathTemplateParamsArgs>
    The parameters declared by this template. Keyed by the parameter's name, which is what a templated path binds it under in paramBindings and what a target's valueReference names.
    repeatConfig EscalationPathTemplateRepeatConfig
    Controls if an escalation will repeat after acknowledgement, when the alert is unresolved. When configured, it will repeat after the specified delay.
    unlockInDashboard Boolean
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    workingHours List<EscalationPathTemplateWorkingHour>
    The working hours for this template.
    sequences {[key: string]: EscalationPathTemplateSequencesArgs}
    Named sequences of nodes, keyed by a name you choose. Each sequence either ends with a branch node or runs off the end of the escalation path. Branches reference other sequences by key. A level or notifyChannel target may set binding instead of id, to be resolved per templated path.
    start string
    The key of the sequence this template begins with.
    description string
    A description of what this template is for.
    expressions EscalationPathTemplateExpression[]
    Expressions a target binding can name through expressionRef, each starting from one of the template's params (its rootReference). Use one to page something derived from a parameter, such as a team's lead.
    name string
    The name of this template.
    params {[key: string]: EscalationPathTemplateParamsArgs}
    The parameters declared by this template. Keyed by the parameter's name, which is what a templated path binds it under in paramBindings and what a target's valueReference names.
    repeatConfig EscalationPathTemplateRepeatConfig
    Controls if an escalation will repeat after acknowledgement, when the alert is unresolved. When configured, it will repeat after the specified delay.
    unlockInDashboard boolean
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    workingHours EscalationPathTemplateWorkingHour[]
    The working hours for this template.
    sequences Mapping[str, EscalationPathTemplateSequencesArgs]
    Named sequences of nodes, keyed by a name you choose. Each sequence either ends with a branch node or runs off the end of the escalation path. Branches reference other sequences by key. A level or notifyChannel target may set binding instead of id, to be resolved per templated path.
    start str
    The key of the sequence this template begins with.
    description str
    A description of what this template is for.
    expressions Sequence[EscalationPathTemplateExpressionArgs]
    Expressions a target binding can name through expressionRef, each starting from one of the template's params (its rootReference). Use one to page something derived from a parameter, such as a team's lead.
    name str
    The name of this template.
    params Mapping[str, EscalationPathTemplateParamsArgs]
    The parameters declared by this template. Keyed by the parameter's name, which is what a templated path binds it under in paramBindings and what a target's valueReference names.
    repeat_config EscalationPathTemplateRepeatConfigArgs
    Controls if an escalation will repeat after acknowledgement, when the alert is unresolved. When configured, it will repeat after the specified delay.
    unlock_in_dashboard bool
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    working_hours Sequence[EscalationPathTemplateWorkingHourArgs]
    The working hours for this template.
    sequences Map<Property Map>
    Named sequences of nodes, keyed by a name you choose. Each sequence either ends with a branch node or runs off the end of the escalation path. Branches reference other sequences by key. A level or notifyChannel target may set binding instead of id, to be resolved per templated path.
    start String
    The key of the sequence this template begins with.
    description String
    A description of what this template is for.
    expressions List<Property Map>
    Expressions a target binding can name through expressionRef, each starting from one of the template's params (its rootReference). Use one to page something derived from a parameter, such as a team's lead.
    name String
    The name of this template.
    params Map<Property Map>
    The parameters declared by this template. Keyed by the parameter's name, which is what a templated path binds it under in paramBindings and what a target's valueReference names.
    repeatConfig Property Map
    Controls if an escalation will repeat after acknowledgement, when the alert is unresolved. When configured, it will repeat after the specified delay.
    unlockInDashboard Boolean
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    workingHours List<Property Map>
    The working hours for this template.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the EscalationPathTemplate resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing EscalationPathTemplate Resource

    Get an existing EscalationPathTemplate resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: EscalationPathTemplateState, opts?: CustomResourceOptions): EscalationPathTemplate
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            description: Optional[str] = None,
            expressions: Optional[Sequence[EscalationPathTemplateExpressionArgs]] = None,
            name: Optional[str] = None,
            params: Optional[Mapping[str, EscalationPathTemplateParamsArgs]] = None,
            repeat_config: Optional[EscalationPathTemplateRepeatConfigArgs] = None,
            sequences: Optional[Mapping[str, EscalationPathTemplateSequencesArgs]] = None,
            start: Optional[str] = None,
            unlock_in_dashboard: Optional[bool] = None,
            working_hours: Optional[Sequence[EscalationPathTemplateWorkingHourArgs]] = None) -> EscalationPathTemplate
    func GetEscalationPathTemplate(ctx *Context, name string, id IDInput, state *EscalationPathTemplateState, opts ...ResourceOption) (*EscalationPathTemplate, error)
    public static EscalationPathTemplate Get(string name, Input<string> id, EscalationPathTemplateState? state, CustomResourceOptions? opts = null)
    public static EscalationPathTemplate get(String name, Output<String> id, EscalationPathTemplateState state, CustomResourceOptions options)
    resources:  _:    type: incident:EscalationPathTemplate    get:      id: ${id}
    import {
      to = incident_escalation_path_template.example
      id = "${id}"
    }
    
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    Description string
    A description of what this template is for.
    Expressions List<EscalationPathTemplateExpression>
    Expressions a target binding can name through expressionRef, each starting from one of the template's params (its rootReference). Use one to page something derived from a parameter, such as a team's lead.
    Name string
    The name of this template.
    Params Dictionary<string, EscalationPathTemplateParamsArgs>
    The parameters declared by this template. Keyed by the parameter's name, which is what a templated path binds it under in paramBindings and what a target's valueReference names.
    RepeatConfig EscalationPathTemplateRepeatConfig
    Controls if an escalation will repeat after acknowledgement, when the alert is unresolved. When configured, it will repeat after the specified delay.
    Sequences Dictionary<string, EscalationPathTemplateSequencesArgs>
    Named sequences of nodes, keyed by a name you choose. Each sequence either ends with a branch node or runs off the end of the escalation path. Branches reference other sequences by key. A level or notifyChannel target may set binding instead of id, to be resolved per templated path.
    Start string
    The key of the sequence this template begins with.
    UnlockInDashboard bool
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    WorkingHours List<EscalationPathTemplateWorkingHour>
    The working hours for this template.
    Description string
    A description of what this template is for.
    Expressions []EscalationPathTemplateExpressionArgs
    Expressions a target binding can name through expressionRef, each starting from one of the template's params (its rootReference). Use one to page something derived from a parameter, such as a team's lead.
    Name string
    The name of this template.
    Params map[string]EscalationPathTemplateParamsArgs
    The parameters declared by this template. Keyed by the parameter's name, which is what a templated path binds it under in paramBindings and what a target's valueReference names.
    RepeatConfig EscalationPathTemplateRepeatConfigArgs
    Controls if an escalation will repeat after acknowledgement, when the alert is unresolved. When configured, it will repeat after the specified delay.
    Sequences map[string]EscalationPathTemplateSequencesArgs
    Named sequences of nodes, keyed by a name you choose. Each sequence either ends with a branch node or runs off the end of the escalation path. Branches reference other sequences by key. A level or notifyChannel target may set binding instead of id, to be resolved per templated path.
    Start string
    The key of the sequence this template begins with.
    UnlockInDashboard bool
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    WorkingHours []EscalationPathTemplateWorkingHourArgs
    The working hours for this template.
    description string
    A description of what this template is for.
    expressions list(object)
    Expressions a target binding can name through expressionRef, each starting from one of the template's params (its rootReference). Use one to page something derived from a parameter, such as a team's lead.
    name string
    The name of this template.
    params map(object)
    The parameters declared by this template. Keyed by the parameter's name, which is what a templated path binds it under in paramBindings and what a target's valueReference names.
    repeat_config object
    Controls if an escalation will repeat after acknowledgement, when the alert is unresolved. When configured, it will repeat after the specified delay.
    sequences map(object)
    Named sequences of nodes, keyed by a name you choose. Each sequence either ends with a branch node or runs off the end of the escalation path. Branches reference other sequences by key. A level or notifyChannel target may set binding instead of id, to be resolved per templated path.
    start string
    The key of the sequence this template begins with.
    unlock_in_dashboard bool
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    working_hours list(object)
    The working hours for this template.
    description String
    A description of what this template is for.
    expressions List<EscalationPathTemplateExpression>
    Expressions a target binding can name through expressionRef, each starting from one of the template's params (its rootReference). Use one to page something derived from a parameter, such as a team's lead.
    name String
    The name of this template.
    params Map<String,EscalationPathTemplateParamsArgs>
    The parameters declared by this template. Keyed by the parameter's name, which is what a templated path binds it under in paramBindings and what a target's valueReference names.
    repeatConfig EscalationPathTemplateRepeatConfig
    Controls if an escalation will repeat after acknowledgement, when the alert is unresolved. When configured, it will repeat after the specified delay.
    sequences Map<String,EscalationPathTemplateSequencesArgs>
    Named sequences of nodes, keyed by a name you choose. Each sequence either ends with a branch node or runs off the end of the escalation path. Branches reference other sequences by key. A level or notifyChannel target may set binding instead of id, to be resolved per templated path.
    start String
    The key of the sequence this template begins with.
    unlockInDashboard Boolean
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    workingHours List<EscalationPathTemplateWorkingHour>
    The working hours for this template.
    description string
    A description of what this template is for.
    expressions EscalationPathTemplateExpression[]
    Expressions a target binding can name through expressionRef, each starting from one of the template's params (its rootReference). Use one to page something derived from a parameter, such as a team's lead.
    name string
    The name of this template.
    params {[key: string]: EscalationPathTemplateParamsArgs}
    The parameters declared by this template. Keyed by the parameter's name, which is what a templated path binds it under in paramBindings and what a target's valueReference names.
    repeatConfig EscalationPathTemplateRepeatConfig
    Controls if an escalation will repeat after acknowledgement, when the alert is unresolved. When configured, it will repeat after the specified delay.
    sequences {[key: string]: EscalationPathTemplateSequencesArgs}
    Named sequences of nodes, keyed by a name you choose. Each sequence either ends with a branch node or runs off the end of the escalation path. Branches reference other sequences by key. A level or notifyChannel target may set binding instead of id, to be resolved per templated path.
    start string
    The key of the sequence this template begins with.
    unlockInDashboard boolean
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    workingHours EscalationPathTemplateWorkingHour[]
    The working hours for this template.
    description str
    A description of what this template is for.
    expressions Sequence[EscalationPathTemplateExpressionArgs]
    Expressions a target binding can name through expressionRef, each starting from one of the template's params (its rootReference). Use one to page something derived from a parameter, such as a team's lead.
    name str
    The name of this template.
    params Mapping[str, EscalationPathTemplateParamsArgs]
    The parameters declared by this template. Keyed by the parameter's name, which is what a templated path binds it under in paramBindings and what a target's valueReference names.
    repeat_config EscalationPathTemplateRepeatConfigArgs
    Controls if an escalation will repeat after acknowledgement, when the alert is unresolved. When configured, it will repeat after the specified delay.
    sequences Mapping[str, EscalationPathTemplateSequencesArgs]
    Named sequences of nodes, keyed by a name you choose. Each sequence either ends with a branch node or runs off the end of the escalation path. Branches reference other sequences by key. A level or notifyChannel target may set binding instead of id, to be resolved per templated path.
    start str
    The key of the sequence this template begins with.
    unlock_in_dashboard bool
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    working_hours Sequence[EscalationPathTemplateWorkingHourArgs]
    The working hours for this template.
    description String
    A description of what this template is for.
    expressions List<Property Map>
    Expressions a target binding can name through expressionRef, each starting from one of the template's params (its rootReference). Use one to page something derived from a parameter, such as a team's lead.
    name String
    The name of this template.
    params Map<Property Map>
    The parameters declared by this template. Keyed by the parameter's name, which is what a templated path binds it under in paramBindings and what a target's valueReference names.
    repeatConfig Property Map
    Controls if an escalation will repeat after acknowledgement, when the alert is unresolved. When configured, it will repeat after the specified delay.
    sequences Map<Property Map>
    Named sequences of nodes, keyed by a name you choose. Each sequence either ends with a branch node or runs off the end of the escalation path. Branches reference other sequences by key. A level or notifyChannel target may set binding instead of id, to be resolved per templated path.
    start String
    The key of the sequence this template begins with.
    unlockInDashboard Boolean
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    workingHours List<Property Map>
    The working hours for this template.

    Supporting Types

    EscalationPathTemplateExpression, EscalationPathTemplateExpressionArgs

    Label string
    The human readable label of the expression
    Operations List<EscalationPathTemplateExpressionOperation>
    The operations to execute in sequence for this expression
    Reference string
    A short ID that can be used to reference the expression
    RootReference string
    The root reference for this expression (i.e. where the expression starts)
    ElseBranch EscalationPathTemplateExpressionElseBranch
    The else branch to resort to if all operations fail
    Label string
    The human readable label of the expression
    Operations []EscalationPathTemplateExpressionOperation
    The operations to execute in sequence for this expression
    Reference string
    A short ID that can be used to reference the expression
    RootReference string
    The root reference for this expression (i.e. where the expression starts)
    ElseBranch EscalationPathTemplateExpressionElseBranch
    The else branch to resort to if all operations fail
    label string
    The human readable label of the expression
    operations list(object)
    The operations to execute in sequence for this expression
    reference string
    A short ID that can be used to reference the expression
    root_reference string
    The root reference for this expression (i.e. where the expression starts)
    else_branch object
    The else branch to resort to if all operations fail
    label String
    The human readable label of the expression
    operations List<EscalationPathTemplateExpressionOperation>
    The operations to execute in sequence for this expression
    reference String
    A short ID that can be used to reference the expression
    rootReference String
    The root reference for this expression (i.e. where the expression starts)
    elseBranch EscalationPathTemplateExpressionElseBranch
    The else branch to resort to if all operations fail
    label string
    The human readable label of the expression
    operations EscalationPathTemplateExpressionOperation[]
    The operations to execute in sequence for this expression
    reference string
    A short ID that can be used to reference the expression
    rootReference string
    The root reference for this expression (i.e. where the expression starts)
    elseBranch EscalationPathTemplateExpressionElseBranch
    The else branch to resort to if all operations fail
    label str
    The human readable label of the expression
    operations Sequence[EscalationPathTemplateExpressionOperation]
    The operations to execute in sequence for this expression
    reference str
    A short ID that can be used to reference the expression
    root_reference str
    The root reference for this expression (i.e. where the expression starts)
    else_branch EscalationPathTemplateExpressionElseBranch
    The else branch to resort to if all operations fail
    label String
    The human readable label of the expression
    operations List<Property Map>
    The operations to execute in sequence for this expression
    reference String
    A short ID that can be used to reference the expression
    rootReference String
    The root reference for this expression (i.e. where the expression starts)
    elseBranch Property Map
    The else branch to resort to if all operations fail

    EscalationPathTemplateExpressionElseBranch, EscalationPathTemplateExpressionElseBranchArgs

    Result EscalationPathTemplateExpressionElseBranchResult
    The result assumed if the else branch is reached
    Result EscalationPathTemplateExpressionElseBranchResult
    The result assumed if the else branch is reached
    result object
    The result assumed if the else branch is reached
    result EscalationPathTemplateExpressionElseBranchResult
    The result assumed if the else branch is reached
    result EscalationPathTemplateExpressionElseBranchResult
    The result assumed if the else branch is reached
    result EscalationPathTemplateExpressionElseBranchResult
    The result assumed if the else branch is reached
    result Property Map
    The result assumed if the else branch is reached

    EscalationPathTemplateExpressionElseBranchResult, EscalationPathTemplateExpressionElseBranchResultArgs

    ArrayValues List<EscalationPathTemplateExpressionElseBranchResultArrayValue>
    The array of literal or reference parameter values
    ExpressionRef string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    Value EscalationPathTemplateExpressionElseBranchResultValue
    The literal or reference parameter value
    ValueLiteral string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    ValueReference string
    A reference into the scope, shorthand for value = { reference = ... }.
    Values List<string>
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    ArrayValues []EscalationPathTemplateExpressionElseBranchResultArrayValue
    The array of literal or reference parameter values
    ExpressionRef string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    Value EscalationPathTemplateExpressionElseBranchResultValue
    The literal or reference parameter value
    ValueLiteral string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    ValueReference string
    A reference into the scope, shorthand for value = { reference = ... }.
    Values []string
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    array_values list(object)
    The array of literal or reference parameter values
    expression_ref string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value object
    The literal or reference parameter value
    value_literal string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    value_reference string
    A reference into the scope, shorthand for value = { reference = ... }.
    values list(string)
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    arrayValues List<EscalationPathTemplateExpressionElseBranchResultArrayValue>
    The array of literal or reference parameter values
    expressionRef String
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value EscalationPathTemplateExpressionElseBranchResultValue
    The literal or reference parameter value
    valueLiteral String
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    valueReference String
    A reference into the scope, shorthand for value = { reference = ... }.
    values List<String>
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    arrayValues EscalationPathTemplateExpressionElseBranchResultArrayValue[]
    The array of literal or reference parameter values
    expressionRef string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value EscalationPathTemplateExpressionElseBranchResultValue
    The literal or reference parameter value
    valueLiteral string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    valueReference string
    A reference into the scope, shorthand for value = { reference = ... }.
    values string[]
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    array_values Sequence[EscalationPathTemplateExpressionElseBranchResultArrayValue]
    The array of literal or reference parameter values
    expression_ref str
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value EscalationPathTemplateExpressionElseBranchResultValue
    The literal or reference parameter value
    value_literal str
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    value_reference str
    A reference into the scope, shorthand for value = { reference = ... }.
    values Sequence[str]
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    arrayValues List<Property Map>
    The array of literal or reference parameter values
    expressionRef String
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value Property Map
    The literal or reference parameter value
    valueLiteral String
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    valueReference String
    A reference into the scope, shorthand for value = { reference = ... }.
    values List<String>
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.

    EscalationPathTemplateExpressionElseBranchResultArrayValue, EscalationPathTemplateExpressionElseBranchResultArrayValueArgs

    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal str
    If set, this is the literal value of the step parameter
    reference str
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter

    EscalationPathTemplateExpressionElseBranchResultValue, EscalationPathTemplateExpressionElseBranchResultValueArgs

    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal str
    If set, this is the literal value of the step parameter
    reference str
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter

    EscalationPathTemplateExpressionOperation, EscalationPathTemplateExpressionOperationArgs

    OperationType string
    Indicates which operation type to execute. Possible values are: navigate, filter, concatenate, count, min, max, sum, random, first, parse, branches, cast.
    Branches EscalationPathTemplateExpressionOperationBranches
    An operation type that allows for a value to be set conditionally by a series of logical branches
    Cast EscalationPathTemplateExpressionOperationCast
    An operation type that converts a value into another type. Only valid on values that can be represented as text. The returned array follows the value being cast, so it must match the cardinality of the previous operation
    Concatenate EscalationPathTemplateExpressionOperationConcatenate
    An operation type that adds the values behind another reference to the current value, keeping each value once. There is no delimiter, despite the name
    Filter EscalationPathTemplateExpressionOperationFilter
    An operation type that allows values to be filtered out by conditions
    Navigate EscalationPathTemplateExpressionOperationNavigate
    An operation type that allows attributes of a type to be accessed by reference
    Parse EscalationPathTemplateExpressionOperationParse
    An operation type that allows a value to parsed from within a JSON object
    OperationType string
    Indicates which operation type to execute. Possible values are: navigate, filter, concatenate, count, min, max, sum, random, first, parse, branches, cast.
    Branches EscalationPathTemplateExpressionOperationBranches
    An operation type that allows for a value to be set conditionally by a series of logical branches
    Cast EscalationPathTemplateExpressionOperationCast
    An operation type that converts a value into another type. Only valid on values that can be represented as text. The returned array follows the value being cast, so it must match the cardinality of the previous operation
    Concatenate EscalationPathTemplateExpressionOperationConcatenate
    An operation type that adds the values behind another reference to the current value, keeping each value once. There is no delimiter, despite the name
    Filter EscalationPathTemplateExpressionOperationFilter
    An operation type that allows values to be filtered out by conditions
    Navigate EscalationPathTemplateExpressionOperationNavigate
    An operation type that allows attributes of a type to be accessed by reference
    Parse EscalationPathTemplateExpressionOperationParse
    An operation type that allows a value to parsed from within a JSON object
    operation_type string
    Indicates which operation type to execute. Possible values are: navigate, filter, concatenate, count, min, max, sum, random, first, parse, branches, cast.
    branches object
    An operation type that allows for a value to be set conditionally by a series of logical branches
    cast object
    An operation type that converts a value into another type. Only valid on values that can be represented as text. The returned array follows the value being cast, so it must match the cardinality of the previous operation
    concatenate object
    An operation type that adds the values behind another reference to the current value, keeping each value once. There is no delimiter, despite the name
    filter object
    An operation type that allows values to be filtered out by conditions
    navigate object
    An operation type that allows attributes of a type to be accessed by reference
    parse object
    An operation type that allows a value to parsed from within a JSON object
    operationType String
    Indicates which operation type to execute. Possible values are: navigate, filter, concatenate, count, min, max, sum, random, first, parse, branches, cast.
    branches EscalationPathTemplateExpressionOperationBranches
    An operation type that allows for a value to be set conditionally by a series of logical branches
    cast EscalationPathTemplateExpressionOperationCast
    An operation type that converts a value into another type. Only valid on values that can be represented as text. The returned array follows the value being cast, so it must match the cardinality of the previous operation
    concatenate EscalationPathTemplateExpressionOperationConcatenate
    An operation type that adds the values behind another reference to the current value, keeping each value once. There is no delimiter, despite the name
    filter EscalationPathTemplateExpressionOperationFilter
    An operation type that allows values to be filtered out by conditions
    navigate EscalationPathTemplateExpressionOperationNavigate
    An operation type that allows attributes of a type to be accessed by reference
    parse EscalationPathTemplateExpressionOperationParse
    An operation type that allows a value to parsed from within a JSON object
    operationType string
    Indicates which operation type to execute. Possible values are: navigate, filter, concatenate, count, min, max, sum, random, first, parse, branches, cast.
    branches EscalationPathTemplateExpressionOperationBranches
    An operation type that allows for a value to be set conditionally by a series of logical branches
    cast EscalationPathTemplateExpressionOperationCast
    An operation type that converts a value into another type. Only valid on values that can be represented as text. The returned array follows the value being cast, so it must match the cardinality of the previous operation
    concatenate EscalationPathTemplateExpressionOperationConcatenate
    An operation type that adds the values behind another reference to the current value, keeping each value once. There is no delimiter, despite the name
    filter EscalationPathTemplateExpressionOperationFilter
    An operation type that allows values to be filtered out by conditions
    navigate EscalationPathTemplateExpressionOperationNavigate
    An operation type that allows attributes of a type to be accessed by reference
    parse EscalationPathTemplateExpressionOperationParse
    An operation type that allows a value to parsed from within a JSON object
    operation_type str
    Indicates which operation type to execute. Possible values are: navigate, filter, concatenate, count, min, max, sum, random, first, parse, branches, cast.
    branches EscalationPathTemplateExpressionOperationBranches
    An operation type that allows for a value to be set conditionally by a series of logical branches
    cast EscalationPathTemplateExpressionOperationCast
    An operation type that converts a value into another type. Only valid on values that can be represented as text. The returned array follows the value being cast, so it must match the cardinality of the previous operation
    concatenate EscalationPathTemplateExpressionOperationConcatenate
    An operation type that adds the values behind another reference to the current value, keeping each value once. There is no delimiter, despite the name
    filter EscalationPathTemplateExpressionOperationFilter
    An operation type that allows values to be filtered out by conditions
    navigate EscalationPathTemplateExpressionOperationNavigate
    An operation type that allows attributes of a type to be accessed by reference
    parse EscalationPathTemplateExpressionOperationParse
    An operation type that allows a value to parsed from within a JSON object
    operationType String
    Indicates which operation type to execute. Possible values are: navigate, filter, concatenate, count, min, max, sum, random, first, parse, branches, cast.
    branches Property Map
    An operation type that allows for a value to be set conditionally by a series of logical branches
    cast Property Map
    An operation type that converts a value into another type. Only valid on values that can be represented as text. The returned array follows the value being cast, so it must match the cardinality of the previous operation
    concatenate Property Map
    An operation type that adds the values behind another reference to the current value, keeping each value once. There is no delimiter, despite the name
    filter Property Map
    An operation type that allows values to be filtered out by conditions
    navigate Property Map
    An operation type that allows attributes of a type to be accessed by reference
    parse Property Map
    An operation type that allows a value to parsed from within a JSON object

    EscalationPathTemplateExpressionOperationBranches, EscalationPathTemplateExpressionOperationBranchesArgs

    branches list(object)
    The branches to apply for this operation
    returns object
    The return type of an operation
    branches List<Property Map>
    The branches to apply for this operation
    returns Property Map
    The return type of an operation

    EscalationPathTemplateExpressionOperationBranchesBranch, EscalationPathTemplateExpressionOperationBranchesBranchArgs

    ConditionGroups List<EscalationPathTemplateExpressionOperationBranchesBranchConditionGroup>
    Groups of prerequisite conditions. All conditions in at least one group must be satisfied
    Result EscalationPathTemplateExpressionOperationBranchesBranchResult
    The result assumed if the condition groups are satisfied
    ConditionGroups []EscalationPathTemplateExpressionOperationBranchesBranchConditionGroup
    Groups of prerequisite conditions. All conditions in at least one group must be satisfied
    Result EscalationPathTemplateExpressionOperationBranchesBranchResult
    The result assumed if the condition groups are satisfied
    condition_groups list(object)
    Groups of prerequisite conditions. All conditions in at least one group must be satisfied
    result object
    The result assumed if the condition groups are satisfied
    conditionGroups List<EscalationPathTemplateExpressionOperationBranchesBranchConditionGroup>
    Groups of prerequisite conditions. All conditions in at least one group must be satisfied
    result EscalationPathTemplateExpressionOperationBranchesBranchResult
    The result assumed if the condition groups are satisfied
    conditionGroups EscalationPathTemplateExpressionOperationBranchesBranchConditionGroup[]
    Groups of prerequisite conditions. All conditions in at least one group must be satisfied
    result EscalationPathTemplateExpressionOperationBranchesBranchResult
    The result assumed if the condition groups are satisfied
    condition_groups Sequence[EscalationPathTemplateExpressionOperationBranchesBranchConditionGroup]
    Groups of prerequisite conditions. All conditions in at least one group must be satisfied
    result EscalationPathTemplateExpressionOperationBranchesBranchResult
    The result assumed if the condition groups are satisfied
    conditionGroups List<Property Map>
    Groups of prerequisite conditions. All conditions in at least one group must be satisfied
    result Property Map
    The result assumed if the condition groups are satisfied

    EscalationPathTemplateExpressionOperationBranchesBranchConditionGroup, EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupArgs

    conditions list(object)
    The prerequisite conditions that must all be satisfied
    conditions List<Property Map>
    The prerequisite conditions that must all be satisfied

    EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupCondition, EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionArgs

    Operation string
    The logical operation to be applied
    ParamBindings List<EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBinding>
    Bindings for the operation parameters
    Subject string
    The subject of the condition, on which the operation is applied
    Operation string
    The logical operation to be applied
    ParamBindings []EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBinding
    Bindings for the operation parameters
    Subject string
    The subject of the condition, on which the operation is applied
    operation string
    The logical operation to be applied
    param_bindings list(object)
    Bindings for the operation parameters
    subject string
    The subject of the condition, on which the operation is applied
    operation String
    The logical operation to be applied
    paramBindings List<EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBinding>
    Bindings for the operation parameters
    subject String
    The subject of the condition, on which the operation is applied
    operation string
    The logical operation to be applied
    paramBindings EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBinding[]
    Bindings for the operation parameters
    subject string
    The subject of the condition, on which the operation is applied
    operation str
    The logical operation to be applied
    param_bindings Sequence[EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBinding]
    Bindings for the operation parameters
    subject str
    The subject of the condition, on which the operation is applied
    operation String
    The logical operation to be applied
    paramBindings List<Property Map>
    Bindings for the operation parameters
    subject String
    The subject of the condition, on which the operation is applied

    EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBinding, EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArgs

    ArrayValues List<EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArrayValue>
    The array of literal or reference parameter values
    ExpressionRef string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    Value EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingValue
    The literal or reference parameter value
    ValueLiteral string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    ValueReference string
    A reference into the scope, shorthand for value = { reference = ... }.
    Values List<string>
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    ArrayValues []EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArrayValue
    The array of literal or reference parameter values
    ExpressionRef string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    Value EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingValue
    The literal or reference parameter value
    ValueLiteral string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    ValueReference string
    A reference into the scope, shorthand for value = { reference = ... }.
    Values []string
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    array_values list(object)
    The array of literal or reference parameter values
    expression_ref string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value object
    The literal or reference parameter value
    value_literal string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    value_reference string
    A reference into the scope, shorthand for value = { reference = ... }.
    values list(string)
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    arrayValues List<EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArrayValue>
    The array of literal or reference parameter values
    expressionRef String
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingValue
    The literal or reference parameter value
    valueLiteral String
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    valueReference String
    A reference into the scope, shorthand for value = { reference = ... }.
    values List<String>
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    arrayValues EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArrayValue[]
    The array of literal or reference parameter values
    expressionRef string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingValue
    The literal or reference parameter value
    valueLiteral string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    valueReference string
    A reference into the scope, shorthand for value = { reference = ... }.
    values string[]
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    array_values Sequence[EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArrayValue]
    The array of literal or reference parameter values
    expression_ref str
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingValue
    The literal or reference parameter value
    value_literal str
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    value_reference str
    A reference into the scope, shorthand for value = { reference = ... }.
    values Sequence[str]
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    arrayValues List<Property Map>
    The array of literal or reference parameter values
    expressionRef String
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value Property Map
    The literal or reference parameter value
    valueLiteral String
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    valueReference String
    A reference into the scope, shorthand for value = { reference = ... }.
    values List<String>
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.

    EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArrayValue, EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArrayValueArgs

    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal str
    If set, this is the literal value of the step parameter
    reference str
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter

    EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingValue, EscalationPathTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingValueArgs

    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal str
    If set, this is the literal value of the step parameter
    reference str
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter

    EscalationPathTemplateExpressionOperationBranchesBranchResult, EscalationPathTemplateExpressionOperationBranchesBranchResultArgs

    ArrayValues List<EscalationPathTemplateExpressionOperationBranchesBranchResultArrayValue>
    The array of literal or reference parameter values
    ExpressionRef string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    Value EscalationPathTemplateExpressionOperationBranchesBranchResultValue
    The literal or reference parameter value
    ValueLiteral string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    ValueReference string
    A reference into the scope, shorthand for value = { reference = ... }.
    Values List<string>
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    ArrayValues []EscalationPathTemplateExpressionOperationBranchesBranchResultArrayValue
    The array of literal or reference parameter values
    ExpressionRef string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    Value EscalationPathTemplateExpressionOperationBranchesBranchResultValue
    The literal or reference parameter value
    ValueLiteral string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    ValueReference string
    A reference into the scope, shorthand for value = { reference = ... }.
    Values []string
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    array_values list(object)
    The array of literal or reference parameter values
    expression_ref string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value object
    The literal or reference parameter value
    value_literal string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    value_reference string
    A reference into the scope, shorthand for value = { reference = ... }.
    values list(string)
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    arrayValues List<EscalationPathTemplateExpressionOperationBranchesBranchResultArrayValue>
    The array of literal or reference parameter values
    expressionRef String
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value EscalationPathTemplateExpressionOperationBranchesBranchResultValue
    The literal or reference parameter value
    valueLiteral String
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    valueReference String
    A reference into the scope, shorthand for value = { reference = ... }.
    values List<String>
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    arrayValues EscalationPathTemplateExpressionOperationBranchesBranchResultArrayValue[]
    The array of literal or reference parameter values
    expressionRef string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value EscalationPathTemplateExpressionOperationBranchesBranchResultValue
    The literal or reference parameter value
    valueLiteral string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    valueReference string
    A reference into the scope, shorthand for value = { reference = ... }.
    values string[]
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    array_values Sequence[EscalationPathTemplateExpressionOperationBranchesBranchResultArrayValue]
    The array of literal or reference parameter values
    expression_ref str
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value EscalationPathTemplateExpressionOperationBranchesBranchResultValue
    The literal or reference parameter value
    value_literal str
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    value_reference str
    A reference into the scope, shorthand for value = { reference = ... }.
    values Sequence[str]
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    arrayValues List<Property Map>
    The array of literal or reference parameter values
    expressionRef String
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value Property Map
    The literal or reference parameter value
    valueLiteral String
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    valueReference String
    A reference into the scope, shorthand for value = { reference = ... }.
    values List<String>
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.

    EscalationPathTemplateExpressionOperationBranchesBranchResultArrayValue, EscalationPathTemplateExpressionOperationBranchesBranchResultArrayValueArgs

    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal str
    If set, this is the literal value of the step parameter
    reference str
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter

    EscalationPathTemplateExpressionOperationBranchesBranchResultValue, EscalationPathTemplateExpressionOperationBranchesBranchResultValueArgs

    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal str
    If set, this is the literal value of the step parameter
    reference str
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter

    EscalationPathTemplateExpressionOperationBranchesReturns, EscalationPathTemplateExpressionOperationBranchesReturnsArgs

    Array bool
    Whether the return value should be single or multi-value
    Type string
    Expected return type of this expression (what to try casting the result to)
    Array bool
    Whether the return value should be single or multi-value
    Type string
    Expected return type of this expression (what to try casting the result to)
    array bool
    Whether the return value should be single or multi-value
    type string
    Expected return type of this expression (what to try casting the result to)
    array Boolean
    Whether the return value should be single or multi-value
    type String
    Expected return type of this expression (what to try casting the result to)
    array boolean
    Whether the return value should be single or multi-value
    type string
    Expected return type of this expression (what to try casting the result to)
    array bool
    Whether the return value should be single or multi-value
    type str
    Expected return type of this expression (what to try casting the result to)
    array Boolean
    Whether the return value should be single or multi-value
    type String
    Expected return type of this expression (what to try casting the result to)

    EscalationPathTemplateExpressionOperationCast, EscalationPathTemplateExpressionOperationCastArgs

    returns object
    The return type of an operation
    returns Property Map
    The return type of an operation

    EscalationPathTemplateExpressionOperationCastReturns, EscalationPathTemplateExpressionOperationCastReturnsArgs

    Array bool
    Whether the return value should be single or multi-value
    Type string
    Expected return type of this expression (what to try casting the result to)
    Array bool
    Whether the return value should be single or multi-value
    Type string
    Expected return type of this expression (what to try casting the result to)
    array bool
    Whether the return value should be single or multi-value
    type string
    Expected return type of this expression (what to try casting the result to)
    array Boolean
    Whether the return value should be single or multi-value
    type String
    Expected return type of this expression (what to try casting the result to)
    array boolean
    Whether the return value should be single or multi-value
    type string
    Expected return type of this expression (what to try casting the result to)
    array bool
    Whether the return value should be single or multi-value
    type str
    Expected return type of this expression (what to try casting the result to)
    array Boolean
    Whether the return value should be single or multi-value
    type String
    Expected return type of this expression (what to try casting the result to)

    EscalationPathTemplateExpressionOperationConcatenate, EscalationPathTemplateExpressionOperationConcatenateArgs

    Reference string
    The reference within the scope to concatenate with
    Reference string
    The reference within the scope to concatenate with
    reference string
    The reference within the scope to concatenate with
    reference String
    The reference within the scope to concatenate with
    reference string
    The reference within the scope to concatenate with
    reference str
    The reference within the scope to concatenate with
    reference String
    The reference within the scope to concatenate with

    EscalationPathTemplateExpressionOperationFilter, EscalationPathTemplateExpressionOperationFilterArgs

    ConditionGroups List<EscalationPathTemplateExpressionOperationFilterConditionGroup>
    Groups of prerequisite conditions. All conditions in at least one group must be satisfied
    ConditionGroups []EscalationPathTemplateExpressionOperationFilterConditionGroup
    Groups of prerequisite conditions. All conditions in at least one group must be satisfied
    condition_groups list(object)
    Groups of prerequisite conditions. All conditions in at least one group must be satisfied
    conditionGroups List<EscalationPathTemplateExpressionOperationFilterConditionGroup>
    Groups of prerequisite conditions. All conditions in at least one group must be satisfied
    conditionGroups EscalationPathTemplateExpressionOperationFilterConditionGroup[]
    Groups of prerequisite conditions. All conditions in at least one group must be satisfied
    condition_groups Sequence[EscalationPathTemplateExpressionOperationFilterConditionGroup]
    Groups of prerequisite conditions. All conditions in at least one group must be satisfied
    conditionGroups List<Property Map>
    Groups of prerequisite conditions. All conditions in at least one group must be satisfied

    EscalationPathTemplateExpressionOperationFilterConditionGroup, EscalationPathTemplateExpressionOperationFilterConditionGroupArgs

    Conditions []EscalationPathTemplateExpressionOperationFilterConditionGroupCondition
    The prerequisite conditions that must all be satisfied
    conditions list(object)
    The prerequisite conditions that must all be satisfied
    conditions EscalationPathTemplateExpressionOperationFilterConditionGroupCondition[]
    The prerequisite conditions that must all be satisfied
    conditions List<Property Map>
    The prerequisite conditions that must all be satisfied

    EscalationPathTemplateExpressionOperationFilterConditionGroupCondition, EscalationPathTemplateExpressionOperationFilterConditionGroupConditionArgs

    Operation string
    The logical operation to be applied
    ParamBindings List<EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBinding>
    Bindings for the operation parameters
    Subject string
    The subject of the condition, on which the operation is applied
    Operation string
    The logical operation to be applied
    ParamBindings []EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBinding
    Bindings for the operation parameters
    Subject string
    The subject of the condition, on which the operation is applied
    operation string
    The logical operation to be applied
    param_bindings list(object)
    Bindings for the operation parameters
    subject string
    The subject of the condition, on which the operation is applied
    operation String
    The logical operation to be applied
    paramBindings List<EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBinding>
    Bindings for the operation parameters
    subject String
    The subject of the condition, on which the operation is applied
    operation string
    The logical operation to be applied
    paramBindings EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBinding[]
    Bindings for the operation parameters
    subject string
    The subject of the condition, on which the operation is applied
    operation str
    The logical operation to be applied
    param_bindings Sequence[EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBinding]
    Bindings for the operation parameters
    subject str
    The subject of the condition, on which the operation is applied
    operation String
    The logical operation to be applied
    paramBindings List<Property Map>
    Bindings for the operation parameters
    subject String
    The subject of the condition, on which the operation is applied

    EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBinding, EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingArgs

    ArrayValues List<EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingArrayValue>
    The array of literal or reference parameter values
    ExpressionRef string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    Value EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingValue
    The literal or reference parameter value
    ValueLiteral string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    ValueReference string
    A reference into the scope, shorthand for value = { reference = ... }.
    Values List<string>
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    ArrayValues []EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingArrayValue
    The array of literal or reference parameter values
    ExpressionRef string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    Value EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingValue
    The literal or reference parameter value
    ValueLiteral string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    ValueReference string
    A reference into the scope, shorthand for value = { reference = ... }.
    Values []string
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    array_values list(object)
    The array of literal or reference parameter values
    expression_ref string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value object
    The literal or reference parameter value
    value_literal string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    value_reference string
    A reference into the scope, shorthand for value = { reference = ... }.
    values list(string)
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    arrayValues List<EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingArrayValue>
    The array of literal or reference parameter values
    expressionRef String
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingValue
    The literal or reference parameter value
    valueLiteral String
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    valueReference String
    A reference into the scope, shorthand for value = { reference = ... }.
    values List<String>
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    arrayValues EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingArrayValue[]
    The array of literal or reference parameter values
    expressionRef string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingValue
    The literal or reference parameter value
    valueLiteral string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    valueReference string
    A reference into the scope, shorthand for value = { reference = ... }.
    values string[]
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    array_values Sequence[EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingArrayValue]
    The array of literal or reference parameter values
    expression_ref str
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingValue
    The literal or reference parameter value
    value_literal str
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    value_reference str
    A reference into the scope, shorthand for value = { reference = ... }.
    values Sequence[str]
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    arrayValues List<Property Map>
    The array of literal or reference parameter values
    expressionRef String
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value Property Map
    The literal or reference parameter value
    valueLiteral String
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    valueReference String
    A reference into the scope, shorthand for value = { reference = ... }.
    values List<String>
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.

    EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingArrayValue, EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingArrayValueArgs

    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal str
    If set, this is the literal value of the step parameter
    reference str
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter

    EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingValue, EscalationPathTemplateExpressionOperationFilterConditionGroupConditionParamBindingValueArgs

    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal str
    If set, this is the literal value of the step parameter
    reference str
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter

    EscalationPathTemplateExpressionOperationNavigate, EscalationPathTemplateExpressionOperationNavigateArgs

    Reference string
    Reference string
    reference string
    reference String
    reference string
    reference String

    EscalationPathTemplateExpressionOperationParse, EscalationPathTemplateExpressionOperationParseArgs

    Returns EscalationPathTemplateExpressionOperationParseReturns
    The return type of an operation
    Source string
    The ES5 Javascript expression to execute
    Returns EscalationPathTemplateExpressionOperationParseReturns
    The return type of an operation
    Source string
    The ES5 Javascript expression to execute
    returns object
    The return type of an operation
    source string
    The ES5 Javascript expression to execute
    returns EscalationPathTemplateExpressionOperationParseReturns
    The return type of an operation
    source String
    The ES5 Javascript expression to execute
    returns EscalationPathTemplateExpressionOperationParseReturns
    The return type of an operation
    source string
    The ES5 Javascript expression to execute
    returns EscalationPathTemplateExpressionOperationParseReturns
    The return type of an operation
    source str
    The ES5 Javascript expression to execute
    returns Property Map
    The return type of an operation
    source String
    The ES5 Javascript expression to execute

    EscalationPathTemplateExpressionOperationParseReturns, EscalationPathTemplateExpressionOperationParseReturnsArgs

    Array bool
    Whether the return value should be single or multi-value
    Type string
    Expected return type of this expression (what to try casting the result to)
    Array bool
    Whether the return value should be single or multi-value
    Type string
    Expected return type of this expression (what to try casting the result to)
    array bool
    Whether the return value should be single or multi-value
    type string
    Expected return type of this expression (what to try casting the result to)
    array Boolean
    Whether the return value should be single or multi-value
    type String
    Expected return type of this expression (what to try casting the result to)
    array boolean
    Whether the return value should be single or multi-value
    type string
    Expected return type of this expression (what to try casting the result to)
    array bool
    Whether the return value should be single or multi-value
    type str
    Expected return type of this expression (what to try casting the result to)
    array Boolean
    Whether the return value should be single or multi-value
    type String
    Expected return type of this expression (what to try casting the result to)

    EscalationPathTemplateParams, EscalationPathTemplateParamsArgs

    Label string
    Human readable label for this parameter
    Type string
    The type of the parameter A schedule is CatalogEntry["Schedule"], a user CatalogEntry["User"], and a catalog type is CatalogEntry["<type id>"].
    Array bool
    Whether this parameter is an array
    Description string
    A string describing the param
    Optional bool
    Whether this parameter is optional
    Label string
    Human readable label for this parameter
    Type string
    The type of the parameter A schedule is CatalogEntry["Schedule"], a user CatalogEntry["User"], and a catalog type is CatalogEntry["<type id>"].
    Array bool
    Whether this parameter is an array
    Description string
    A string describing the param
    Optional bool
    Whether this parameter is optional
    label string
    Human readable label for this parameter
    type string
    The type of the parameter A schedule is CatalogEntry["Schedule"], a user CatalogEntry["User"], and a catalog type is CatalogEntry["<type id>"].
    array bool
    Whether this parameter is an array
    description string
    A string describing the param
    optional bool
    Whether this parameter is optional
    label String
    Human readable label for this parameter
    type String
    The type of the parameter A schedule is CatalogEntry["Schedule"], a user CatalogEntry["User"], and a catalog type is CatalogEntry["<type id>"].
    array Boolean
    Whether this parameter is an array
    description String
    A string describing the param
    optional Boolean
    Whether this parameter is optional
    label string
    Human readable label for this parameter
    type string
    The type of the parameter A schedule is CatalogEntry["Schedule"], a user CatalogEntry["User"], and a catalog type is CatalogEntry["<type id>"].
    array boolean
    Whether this parameter is an array
    description string
    A string describing the param
    optional boolean
    Whether this parameter is optional
    label str
    Human readable label for this parameter
    type str
    The type of the parameter A schedule is CatalogEntry["Schedule"], a user CatalogEntry["User"], and a catalog type is CatalogEntry["<type id>"].
    array bool
    Whether this parameter is an array
    description str
    A string describing the param
    optional bool
    Whether this parameter is optional
    label String
    Human readable label for this parameter
    type String
    The type of the parameter A schedule is CatalogEntry["Schedule"], a user CatalogEntry["User"], and a catalog type is CatalogEntry["<type id>"].
    array Boolean
    Whether this parameter is an array
    description String
    A string describing the param
    optional Boolean
    Whether this parameter is optional

    EscalationPathTemplateRepeatConfig, EscalationPathTemplateRepeatConfigArgs

    DelayRepeatOnActivity bool
    When true, incident activity resets the repeat timer.
    RepeatAfterSeconds int
    Number of seconds we'll wait before repeating an escalation.
    DelayRepeatOnActivity bool
    When true, incident activity resets the repeat timer.
    RepeatAfterSeconds int
    Number of seconds we'll wait before repeating an escalation.
    delay_repeat_on_activity bool
    When true, incident activity resets the repeat timer.
    repeat_after_seconds number
    Number of seconds we'll wait before repeating an escalation.
    delayRepeatOnActivity Boolean
    When true, incident activity resets the repeat timer.
    repeatAfterSeconds Integer
    Number of seconds we'll wait before repeating an escalation.
    delayRepeatOnActivity boolean
    When true, incident activity resets the repeat timer.
    repeatAfterSeconds number
    Number of seconds we'll wait before repeating an escalation.
    delay_repeat_on_activity bool
    When true, incident activity resets the repeat timer.
    repeat_after_seconds int
    Number of seconds we'll wait before repeating an escalation.
    delayRepeatOnActivity Boolean
    When true, incident activity resets the repeat timer.
    repeatAfterSeconds Number
    Number of seconds we'll wait before repeating an escalation.

    EscalationPathTemplateSequences, EscalationPathTemplateSequencesArgs

    Nodes List<EscalationPathTemplateSequencesNode>
    The nodes in this sequence, in the order they run.
    Nodes []EscalationPathTemplateSequencesNode
    The nodes in this sequence, in the order they run.
    nodes list(object)
    The nodes in this sequence, in the order they run.
    nodes List<EscalationPathTemplateSequencesNode>
    The nodes in this sequence, in the order they run.
    nodes EscalationPathTemplateSequencesNode[]
    The nodes in this sequence, in the order they run.
    nodes Sequence[EscalationPathTemplateSequencesNode]
    The nodes in this sequence, in the order they run.
    nodes List<Property Map>
    The nodes in this sequence, in the order they run.

    EscalationPathTemplateSequencesNode, EscalationPathTemplateSequencesNodeArgs

    Branch EscalationPathTemplateSequencesNodeBranch
    Send the escalation down one of two sequences, depending on what if tests. A branch must be the last node in its sequence.
    Delay EscalationPathTemplateSequencesNodeDelay
    EscalationPath EscalationPathTemplateSequencesNodeEscalationPath
    Reassign the escalation to another escalation path, continuing from that path's first node.
    Id string
    An id for this node, unique within the escalation path, so a loop can name it. Leave it unset unless something loops back here: we derive one from the node's position, which keeps it stable across applies.
    Level EscalationPathTemplateSequencesNodeLevel
    Loop EscalationPathTemplateSequencesNodeLoop
    Go back to an earlier node and run from there again. A loop must be the last node in its sequence, or be followed by a single escalationPath node to reassign to once it has run out of repeats.
    NotifyChannel EscalationPathTemplateSequencesNodeNotifyChannel
    Branch EscalationPathTemplateSequencesNodeBranch
    Send the escalation down one of two sequences, depending on what if tests. A branch must be the last node in its sequence.
    Delay EscalationPathTemplateSequencesNodeDelay
    EscalationPath EscalationPathTemplateSequencesNodeEscalationPath
    Reassign the escalation to another escalation path, continuing from that path's first node.
    Id string
    An id for this node, unique within the escalation path, so a loop can name it. Leave it unset unless something loops back here: we derive one from the node's position, which keeps it stable across applies.
    Level EscalationPathTemplateSequencesNodeLevel
    Loop EscalationPathTemplateSequencesNodeLoop
    Go back to an earlier node and run from there again. A loop must be the last node in its sequence, or be followed by a single escalationPath node to reassign to once it has run out of repeats.
    NotifyChannel EscalationPathTemplateSequencesNodeNotifyChannel
    branch object
    Send the escalation down one of two sequences, depending on what if tests. A branch must be the last node in its sequence.
    delay object
    escalation_path object
    Reassign the escalation to another escalation path, continuing from that path's first node.
    id string
    An id for this node, unique within the escalation path, so a loop can name it. Leave it unset unless something loops back here: we derive one from the node's position, which keeps it stable across applies.
    level object
    loop object
    Go back to an earlier node and run from there again. A loop must be the last node in its sequence, or be followed by a single escalationPath node to reassign to once it has run out of repeats.
    notify_channel object
    branch EscalationPathTemplateSequencesNodeBranch
    Send the escalation down one of two sequences, depending on what if tests. A branch must be the last node in its sequence.
    delay EscalationPathTemplateSequencesNodeDelay
    escalationPath EscalationPathTemplateSequencesNodeEscalationPath
    Reassign the escalation to another escalation path, continuing from that path's first node.
    id String
    An id for this node, unique within the escalation path, so a loop can name it. Leave it unset unless something loops back here: we derive one from the node's position, which keeps it stable across applies.
    level EscalationPathTemplateSequencesNodeLevel
    loop EscalationPathTemplateSequencesNodeLoop
    Go back to an earlier node and run from there again. A loop must be the last node in its sequence, or be followed by a single escalationPath node to reassign to once it has run out of repeats.
    notifyChannel EscalationPathTemplateSequencesNodeNotifyChannel
    branch EscalationPathTemplateSequencesNodeBranch
    Send the escalation down one of two sequences, depending on what if tests. A branch must be the last node in its sequence.
    delay EscalationPathTemplateSequencesNodeDelay
    escalationPath EscalationPathTemplateSequencesNodeEscalationPath
    Reassign the escalation to another escalation path, continuing from that path's first node.
    id string
    An id for this node, unique within the escalation path, so a loop can name it. Leave it unset unless something loops back here: we derive one from the node's position, which keeps it stable across applies.
    level EscalationPathTemplateSequencesNodeLevel
    loop EscalationPathTemplateSequencesNodeLoop
    Go back to an earlier node and run from there again. A loop must be the last node in its sequence, or be followed by a single escalationPath node to reassign to once it has run out of repeats.
    notifyChannel EscalationPathTemplateSequencesNodeNotifyChannel
    branch EscalationPathTemplateSequencesNodeBranch
    Send the escalation down one of two sequences, depending on what if tests. A branch must be the last node in its sequence.
    delay EscalationPathTemplateSequencesNodeDelay
    escalation_path EscalationPathTemplateSequencesNodeEscalationPath
    Reassign the escalation to another escalation path, continuing from that path's first node.
    id str
    An id for this node, unique within the escalation path, so a loop can name it. Leave it unset unless something loops back here: we derive one from the node's position, which keeps it stable across applies.
    level EscalationPathTemplateSequencesNodeLevel
    loop EscalationPathTemplateSequencesNodeLoop
    Go back to an earlier node and run from there again. A loop must be the last node in its sequence, or be followed by a single escalationPath node to reassign to once it has run out of repeats.
    notify_channel EscalationPathTemplateSequencesNodeNotifyChannel
    branch Property Map
    Send the escalation down one of two sequences, depending on what if tests. A branch must be the last node in its sequence.
    delay Property Map
    escalationPath Property Map
    Reassign the escalation to another escalation path, continuing from that path's first node.
    id String
    An id for this node, unique within the escalation path, so a loop can name it. Leave it unset unless something loops back here: we derive one from the node's position, which keeps it stable across applies.
    level Property Map
    loop Property Map
    Go back to an earlier node and run from there again. A loop must be the last node in its sequence, or be followed by a single escalationPath node to reassign to once it has run out of repeats.
    notifyChannel Property Map

    EscalationPathTemplateSequencesNodeBranch, EscalationPathTemplateSequencesNodeBranchArgs

    If EscalationPathTemplateSequencesNodeBranchIf
    What the branch tests. Set exactly one of these: a branch tests one thing, so combining them means nesting a second branch inside the first.
    Then string
    The key of the sequence to continue down when the condition is met.
    Else string
    The key of the sequence to continue down when the condition is not met. Leave unset to end the escalation path instead.
    If EscalationPathTemplateSequencesNodeBranchIf
    What the branch tests. Set exactly one of these: a branch tests one thing, so combining them means nesting a second branch inside the first.
    Then string
    The key of the sequence to continue down when the condition is met.
    Else string
    The key of the sequence to continue down when the condition is not met. Leave unset to end the escalation path instead.
    if object
    What the branch tests. Set exactly one of these: a branch tests one thing, so combining them means nesting a second branch inside the first.
    then string
    The key of the sequence to continue down when the condition is met.
    else string
    The key of the sequence to continue down when the condition is not met. Leave unset to end the escalation path instead.
    if_ EscalationPathTemplateSequencesNodeBranchIf
    What the branch tests. Set exactly one of these: a branch tests one thing, so combining them means nesting a second branch inside the first.
    then String
    The key of the sequence to continue down when the condition is met.
    else_ String
    The key of the sequence to continue down when the condition is not met. Leave unset to end the escalation path instead.
    if EscalationPathTemplateSequencesNodeBranchIf
    What the branch tests. Set exactly one of these: a branch tests one thing, so combining them means nesting a second branch inside the first.
    then string
    The key of the sequence to continue down when the condition is met.
    else string
    The key of the sequence to continue down when the condition is not met. Leave unset to end the escalation path instead.
    if_ EscalationPathTemplateSequencesNodeBranchIf
    What the branch tests. Set exactly one of these: a branch tests one thing, so combining them means nesting a second branch inside the first.
    then str
    The key of the sequence to continue down when the condition is met.
    else_ str
    The key of the sequence to continue down when the condition is not met. Leave unset to end the escalation path instead.
    if Property Map
    What the branch tests. Set exactly one of these: a branch tests one thing, so combining them means nesting a second branch inside the first.
    then String
    The key of the sequence to continue down when the condition is met.
    else String
    The key of the sequence to continue down when the condition is not met. Leave unset to end the escalation path instead.

    EscalationPathTemplateSequencesNodeBranchIf, EscalationPathTemplateSequencesNodeBranchIfArgs

    PriorityOneOfs List<string>
    Alert priority ids, met when the escalation came in at one of them.
    WorkingHoursActive string
    The id of one of this escalation path's workingHours, met while those hours are active.
    PriorityOneOfs []string
    Alert priority ids, met when the escalation came in at one of them.
    WorkingHoursActive string
    The id of one of this escalation path's workingHours, met while those hours are active.
    priority_one_ofs list(string)
    Alert priority ids, met when the escalation came in at one of them.
    working_hours_active string
    The id of one of this escalation path's workingHours, met while those hours are active.
    priorityOneOfs List<String>
    Alert priority ids, met when the escalation came in at one of them.
    workingHoursActive String
    The id of one of this escalation path's workingHours, met while those hours are active.
    priorityOneOfs string[]
    Alert priority ids, met when the escalation came in at one of them.
    workingHoursActive string
    The id of one of this escalation path's workingHours, met while those hours are active.
    priority_one_ofs Sequence[str]
    Alert priority ids, met when the escalation came in at one of them.
    working_hours_active str
    The id of one of this escalation path's workingHours, met while those hours are active.
    priorityOneOfs List<String>
    Alert priority ids, met when the escalation came in at one of them.
    workingHoursActive String
    The id of one of this escalation path's workingHours, met while those hours are active.

    EscalationPathTemplateSequencesNodeDelay, EscalationPathTemplateSequencesNodeDelayArgs

    DelayIntervalCondition string
    If the delay is relative to a time window, this defines whether we advance when the window is active or inactive. Possible values are: active, inactive.
    DelaySeconds int
    How long to delay before advancing to the next node in the path, in seconds
    DelayWeekdayIntervalConfigId string
    If the delay is relative to a time window, this identifies which window it is relative to
    DelayIntervalCondition string
    If the delay is relative to a time window, this defines whether we advance when the window is active or inactive. Possible values are: active, inactive.
    DelaySeconds int
    How long to delay before advancing to the next node in the path, in seconds
    DelayWeekdayIntervalConfigId string
    If the delay is relative to a time window, this identifies which window it is relative to
    delay_interval_condition string
    If the delay is relative to a time window, this defines whether we advance when the window is active or inactive. Possible values are: active, inactive.
    delay_seconds number
    How long to delay before advancing to the next node in the path, in seconds
    delay_weekday_interval_config_id string
    If the delay is relative to a time window, this identifies which window it is relative to
    delayIntervalCondition String
    If the delay is relative to a time window, this defines whether we advance when the window is active or inactive. Possible values are: active, inactive.
    delaySeconds Integer
    How long to delay before advancing to the next node in the path, in seconds
    delayWeekdayIntervalConfigId String
    If the delay is relative to a time window, this identifies which window it is relative to
    delayIntervalCondition string
    If the delay is relative to a time window, this defines whether we advance when the window is active or inactive. Possible values are: active, inactive.
    delaySeconds number
    How long to delay before advancing to the next node in the path, in seconds
    delayWeekdayIntervalConfigId string
    If the delay is relative to a time window, this identifies which window it is relative to
    delay_interval_condition str
    If the delay is relative to a time window, this defines whether we advance when the window is active or inactive. Possible values are: active, inactive.
    delay_seconds int
    How long to delay before advancing to the next node in the path, in seconds
    delay_weekday_interval_config_id str
    If the delay is relative to a time window, this identifies which window it is relative to
    delayIntervalCondition String
    If the delay is relative to a time window, this defines whether we advance when the window is active or inactive. Possible values are: active, inactive.
    delaySeconds Number
    How long to delay before advancing to the next node in the path, in seconds
    delayWeekdayIntervalConfigId String
    If the delay is relative to a time window, this identifies which window it is relative to

    EscalationPathTemplateSequencesNodeEscalationPath, EscalationPathTemplateSequencesNodeEscalationPathArgs

    EscalationPathId string
    The ID of the escalation path to reassign to
    EscalationPathId string
    The ID of the escalation path to reassign to
    escalation_path_id string
    The ID of the escalation path to reassign to
    escalationPathId String
    The ID of the escalation path to reassign to
    escalationPathId string
    The ID of the escalation path to reassign to
    escalation_path_id str
    The ID of the escalation path to reassign to
    escalationPathId String
    The ID of the escalation path to reassign to

    EscalationPathTemplateSequencesNodeLevel, EscalationPathTemplateSequencesNodeLevelArgs

    Targets List<EscalationPathTemplateSequencesNodeLevelTarget>
    The targets (users or schedules), each concrete or a parameter binding.
    AckMode string
    Controls the behaviour of acknowledgements for this level, with 'first' cancelling all other escalations on the same level when someone acks. Possible values are: all, first.
    RetryConfig EscalationPathTemplateSequencesNodeLevelRetryConfig
    RoundRobinConfig EscalationPathTemplateSequencesNodeLevelRoundRobinConfig
    TimeToAckIntervalCondition string
    If the time to ack is relative to a time window, this defines whether we move when the window is active or inactive. Possible values are: active, inactive.
    TimeToAckSeconds int
    How long should we wait for this level to acknowledge before proceeding to the next node in the path?
    TimeToAckWeekdayIntervalConfigId string
    If the time to ack is relative to a time window, this identifies which window it is relative to
    Targets []EscalationPathTemplateSequencesNodeLevelTarget
    The targets (users or schedules), each concrete or a parameter binding.
    AckMode string
    Controls the behaviour of acknowledgements for this level, with 'first' cancelling all other escalations on the same level when someone acks. Possible values are: all, first.
    RetryConfig EscalationPathTemplateSequencesNodeLevelRetryConfig
    RoundRobinConfig EscalationPathTemplateSequencesNodeLevelRoundRobinConfig
    TimeToAckIntervalCondition string
    If the time to ack is relative to a time window, this defines whether we move when the window is active or inactive. Possible values are: active, inactive.
    TimeToAckSeconds int
    How long should we wait for this level to acknowledge before proceeding to the next node in the path?
    TimeToAckWeekdayIntervalConfigId string
    If the time to ack is relative to a time window, this identifies which window it is relative to
    targets list(object)
    The targets (users or schedules), each concrete or a parameter binding.
    ack_mode string
    Controls the behaviour of acknowledgements for this level, with 'first' cancelling all other escalations on the same level when someone acks. Possible values are: all, first.
    retry_config object
    round_robin_config object
    time_to_ack_interval_condition string
    If the time to ack is relative to a time window, this defines whether we move when the window is active or inactive. Possible values are: active, inactive.
    time_to_ack_seconds number
    How long should we wait for this level to acknowledge before proceeding to the next node in the path?
    time_to_ack_weekday_interval_config_id string
    If the time to ack is relative to a time window, this identifies which window it is relative to
    targets List<EscalationPathTemplateSequencesNodeLevelTarget>
    The targets (users or schedules), each concrete or a parameter binding.
    ackMode String
    Controls the behaviour of acknowledgements for this level, with 'first' cancelling all other escalations on the same level when someone acks. Possible values are: all, first.
    retryConfig EscalationPathTemplateSequencesNodeLevelRetryConfig
    roundRobinConfig EscalationPathTemplateSequencesNodeLevelRoundRobinConfig
    timeToAckIntervalCondition String
    If the time to ack is relative to a time window, this defines whether we move when the window is active or inactive. Possible values are: active, inactive.
    timeToAckSeconds Integer
    How long should we wait for this level to acknowledge before proceeding to the next node in the path?
    timeToAckWeekdayIntervalConfigId String
    If the time to ack is relative to a time window, this identifies which window it is relative to
    targets EscalationPathTemplateSequencesNodeLevelTarget[]
    The targets (users or schedules), each concrete or a parameter binding.
    ackMode string
    Controls the behaviour of acknowledgements for this level, with 'first' cancelling all other escalations on the same level when someone acks. Possible values are: all, first.
    retryConfig EscalationPathTemplateSequencesNodeLevelRetryConfig
    roundRobinConfig EscalationPathTemplateSequencesNodeLevelRoundRobinConfig
    timeToAckIntervalCondition string
    If the time to ack is relative to a time window, this defines whether we move when the window is active or inactive. Possible values are: active, inactive.
    timeToAckSeconds number
    How long should we wait for this level to acknowledge before proceeding to the next node in the path?
    timeToAckWeekdayIntervalConfigId string
    If the time to ack is relative to a time window, this identifies which window it is relative to
    targets Sequence[EscalationPathTemplateSequencesNodeLevelTarget]
    The targets (users or schedules), each concrete or a parameter binding.
    ack_mode str
    Controls the behaviour of acknowledgements for this level, with 'first' cancelling all other escalations on the same level when someone acks. Possible values are: all, first.
    retry_config EscalationPathTemplateSequencesNodeLevelRetryConfig
    round_robin_config EscalationPathTemplateSequencesNodeLevelRoundRobinConfig
    time_to_ack_interval_condition str
    If the time to ack is relative to a time window, this defines whether we move when the window is active or inactive. Possible values are: active, inactive.
    time_to_ack_seconds int
    How long should we wait for this level to acknowledge before proceeding to the next node in the path?
    time_to_ack_weekday_interval_config_id str
    If the time to ack is relative to a time window, this identifies which window it is relative to
    targets List<Property Map>
    The targets (users or schedules), each concrete or a parameter binding.
    ackMode String
    Controls the behaviour of acknowledgements for this level, with 'first' cancelling all other escalations on the same level when someone acks. Possible values are: all, first.
    retryConfig Property Map
    roundRobinConfig Property Map
    timeToAckIntervalCondition String
    If the time to ack is relative to a time window, this defines whether we move when the window is active or inactive. Possible values are: active, inactive.
    timeToAckSeconds Number
    How long should we wait for this level to acknowledge before proceeding to the next node in the path?
    timeToAckWeekdayIntervalConfigId String
    If the time to ack is relative to a time window, this identifies which window it is relative to

    EscalationPathTemplateSequencesNodeLevelRetryConfig, EscalationPathTemplateSequencesNodeLevelRetryConfigArgs

    Attempts int
    The total number of times we page this level, counting the initial page. For example, 3 means three notifications in total. Must be between 2 and 10.
    IntervalSeconds int
    How long we wait between attempts at this level, in seconds. Must be a whole number of minutes (divisible by 60).
    Attempts int
    The total number of times we page this level, counting the initial page. For example, 3 means three notifications in total. Must be between 2 and 10.
    IntervalSeconds int
    How long we wait between attempts at this level, in seconds. Must be a whole number of minutes (divisible by 60).
    attempts number
    The total number of times we page this level, counting the initial page. For example, 3 means three notifications in total. Must be between 2 and 10.
    interval_seconds number
    How long we wait between attempts at this level, in seconds. Must be a whole number of minutes (divisible by 60).
    attempts Integer
    The total number of times we page this level, counting the initial page. For example, 3 means three notifications in total. Must be between 2 and 10.
    intervalSeconds Integer
    How long we wait between attempts at this level, in seconds. Must be a whole number of minutes (divisible by 60).
    attempts number
    The total number of times we page this level, counting the initial page. For example, 3 means three notifications in total. Must be between 2 and 10.
    intervalSeconds number
    How long we wait between attempts at this level, in seconds. Must be a whole number of minutes (divisible by 60).
    attempts int
    The total number of times we page this level, counting the initial page. For example, 3 means three notifications in total. Must be between 2 and 10.
    interval_seconds int
    How long we wait between attempts at this level, in seconds. Must be a whole number of minutes (divisible by 60).
    attempts Number
    The total number of times we page this level, counting the initial page. For example, 3 means three notifications in total. Must be between 2 and 10.
    intervalSeconds Number
    How long we wait between attempts at this level, in seconds. Must be a whole number of minutes (divisible by 60).

    EscalationPathTemplateSequencesNodeLevelRoundRobinConfig, EscalationPathTemplateSequencesNodeLevelRoundRobinConfigArgs

    Enabled bool
    Whether round robin is enabled for this level
    RotateAfterSeconds int
    How long should we wait before rotating to the next target in a round robin, if not set will stick with a single target per level.
    Enabled bool
    Whether round robin is enabled for this level
    RotateAfterSeconds int
    How long should we wait before rotating to the next target in a round robin, if not set will stick with a single target per level.
    enabled bool
    Whether round robin is enabled for this level
    rotate_after_seconds number
    How long should we wait before rotating to the next target in a round robin, if not set will stick with a single target per level.
    enabled Boolean
    Whether round robin is enabled for this level
    rotateAfterSeconds Integer
    How long should we wait before rotating to the next target in a round robin, if not set will stick with a single target per level.
    enabled boolean
    Whether round robin is enabled for this level
    rotateAfterSeconds number
    How long should we wait before rotating to the next target in a round robin, if not set will stick with a single target per level.
    enabled bool
    Whether round robin is enabled for this level
    rotate_after_seconds int
    How long should we wait before rotating to the next target in a round robin, if not set will stick with a single target per level.
    enabled Boolean
    Whether round robin is enabled for this level
    rotateAfterSeconds Number
    How long should we wait before rotating to the next target in a round robin, if not set will stick with a single target per level.

    EscalationPathTemplateSequencesNodeLevelTarget, EscalationPathTemplateSequencesNodeLevelTargetArgs

    Type string
    Controls what type of entity this target identifies, such as EscalationPolicy or User. Possible values are: schedule, user, slackChannel, msteamsChannel.
    Urgency string
    The urgency of this escalation path target. Possible values are: high, low.
    Binding EscalationPathTemplateSequencesNodeLevelTargetBinding
    Who this target resolves to, decided per templated path. valueReference names one of the template's params, and expressionRef one of its expressions. Set exactly one of id and binding.
    Id string
    Uniquely identifies a concrete target. Omitted when binding is set. Set exactly one of id and binding.
    ScheduleMode string
    Only set for schedule targets, this specifies which users to fetch from the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    SelectedRotaId string
    For a schedule target with a rota-scoped scheduleMode, the rota to page. A bound target can leave this unset and bind to an expression that navigates the schedule's rotations and filters them by name instead.
    Type string
    Controls what type of entity this target identifies, such as EscalationPolicy or User. Possible values are: schedule, user, slackChannel, msteamsChannel.
    Urgency string
    The urgency of this escalation path target. Possible values are: high, low.
    Binding EscalationPathTemplateSequencesNodeLevelTargetBinding
    Who this target resolves to, decided per templated path. valueReference names one of the template's params, and expressionRef one of its expressions. Set exactly one of id and binding.
    Id string
    Uniquely identifies a concrete target. Omitted when binding is set. Set exactly one of id and binding.
    ScheduleMode string
    Only set for schedule targets, this specifies which users to fetch from the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    SelectedRotaId string
    For a schedule target with a rota-scoped scheduleMode, the rota to page. A bound target can leave this unset and bind to an expression that navigates the schedule's rotations and filters them by name instead.
    type string
    Controls what type of entity this target identifies, such as EscalationPolicy or User. Possible values are: schedule, user, slackChannel, msteamsChannel.
    urgency string
    The urgency of this escalation path target. Possible values are: high, low.
    binding object
    Who this target resolves to, decided per templated path. valueReference names one of the template's params, and expressionRef one of its expressions. Set exactly one of id and binding.
    id string
    Uniquely identifies a concrete target. Omitted when binding is set. Set exactly one of id and binding.
    schedule_mode string
    Only set for schedule targets, this specifies which users to fetch from the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    selected_rota_id string
    For a schedule target with a rota-scoped scheduleMode, the rota to page. A bound target can leave this unset and bind to an expression that navigates the schedule's rotations and filters them by name instead.
    type String
    Controls what type of entity this target identifies, such as EscalationPolicy or User. Possible values are: schedule, user, slackChannel, msteamsChannel.
    urgency String
    The urgency of this escalation path target. Possible values are: high, low.
    binding EscalationPathTemplateSequencesNodeLevelTargetBinding
    Who this target resolves to, decided per templated path. valueReference names one of the template's params, and expressionRef one of its expressions. Set exactly one of id and binding.
    id String
    Uniquely identifies a concrete target. Omitted when binding is set. Set exactly one of id and binding.
    scheduleMode String
    Only set for schedule targets, this specifies which users to fetch from the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    selectedRotaId String
    For a schedule target with a rota-scoped scheduleMode, the rota to page. A bound target can leave this unset and bind to an expression that navigates the schedule's rotations and filters them by name instead.
    type string
    Controls what type of entity this target identifies, such as EscalationPolicy or User. Possible values are: schedule, user, slackChannel, msteamsChannel.
    urgency string
    The urgency of this escalation path target. Possible values are: high, low.
    binding EscalationPathTemplateSequencesNodeLevelTargetBinding
    Who this target resolves to, decided per templated path. valueReference names one of the template's params, and expressionRef one of its expressions. Set exactly one of id and binding.
    id string
    Uniquely identifies a concrete target. Omitted when binding is set. Set exactly one of id and binding.
    scheduleMode string
    Only set for schedule targets, this specifies which users to fetch from the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    selectedRotaId string
    For a schedule target with a rota-scoped scheduleMode, the rota to page. A bound target can leave this unset and bind to an expression that navigates the schedule's rotations and filters them by name instead.
    type str
    Controls what type of entity this target identifies, such as EscalationPolicy or User. Possible values are: schedule, user, slackChannel, msteamsChannel.
    urgency str
    The urgency of this escalation path target. Possible values are: high, low.
    binding EscalationPathTemplateSequencesNodeLevelTargetBinding
    Who this target resolves to, decided per templated path. valueReference names one of the template's params, and expressionRef one of its expressions. Set exactly one of id and binding.
    id str
    Uniquely identifies a concrete target. Omitted when binding is set. Set exactly one of id and binding.
    schedule_mode str
    Only set for schedule targets, this specifies which users to fetch from the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    selected_rota_id str
    For a schedule target with a rota-scoped scheduleMode, the rota to page. A bound target can leave this unset and bind to an expression that navigates the schedule's rotations and filters them by name instead.
    type String
    Controls what type of entity this target identifies, such as EscalationPolicy or User. Possible values are: schedule, user, slackChannel, msteamsChannel.
    urgency String
    The urgency of this escalation path target. Possible values are: high, low.
    binding Property Map
    Who this target resolves to, decided per templated path. valueReference names one of the template's params, and expressionRef one of its expressions. Set exactly one of id and binding.
    id String
    Uniquely identifies a concrete target. Omitted when binding is set. Set exactly one of id and binding.
    scheduleMode String
    Only set for schedule targets, this specifies which users to fetch from the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    selectedRotaId String
    For a schedule target with a rota-scoped scheduleMode, the rota to page. A bound target can leave this unset and bind to an expression that navigates the schedule's rotations and filters them by name instead.

    EscalationPathTemplateSequencesNodeLevelTargetBinding, EscalationPathTemplateSequencesNodeLevelTargetBindingArgs

    ArrayValues List<EscalationPathTemplateSequencesNodeLevelTargetBindingArrayValue>
    The array of literal or reference parameter values
    ExpressionRef string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    Value EscalationPathTemplateSequencesNodeLevelTargetBindingValue
    The literal or reference parameter value
    ValueLiteral string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    ValueReference string
    A reference into the scope, shorthand for value = { reference = ... }.
    Values List<string>
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    ArrayValues []EscalationPathTemplateSequencesNodeLevelTargetBindingArrayValue
    The array of literal or reference parameter values
    ExpressionRef string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    Value EscalationPathTemplateSequencesNodeLevelTargetBindingValue
    The literal or reference parameter value
    ValueLiteral string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    ValueReference string
    A reference into the scope, shorthand for value = { reference = ... }.
    Values []string
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    array_values list(object)
    The array of literal or reference parameter values
    expression_ref string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value object
    The literal or reference parameter value
    value_literal string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    value_reference string
    A reference into the scope, shorthand for value = { reference = ... }.
    values list(string)
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    arrayValues List<EscalationPathTemplateSequencesNodeLevelTargetBindingArrayValue>
    The array of literal or reference parameter values
    expressionRef String
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value EscalationPathTemplateSequencesNodeLevelTargetBindingValue
    The literal or reference parameter value
    valueLiteral String
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    valueReference String
    A reference into the scope, shorthand for value = { reference = ... }.
    values List<String>
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    arrayValues EscalationPathTemplateSequencesNodeLevelTargetBindingArrayValue[]
    The array of literal or reference parameter values
    expressionRef string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value EscalationPathTemplateSequencesNodeLevelTargetBindingValue
    The literal or reference parameter value
    valueLiteral string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    valueReference string
    A reference into the scope, shorthand for value = { reference = ... }.
    values string[]
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    array_values Sequence[EscalationPathTemplateSequencesNodeLevelTargetBindingArrayValue]
    The array of literal or reference parameter values
    expression_ref str
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value EscalationPathTemplateSequencesNodeLevelTargetBindingValue
    The literal or reference parameter value
    value_literal str
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    value_reference str
    A reference into the scope, shorthand for value = { reference = ... }.
    values Sequence[str]
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    arrayValues List<Property Map>
    The array of literal or reference parameter values
    expressionRef String
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value Property Map
    The literal or reference parameter value
    valueLiteral String
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    valueReference String
    A reference into the scope, shorthand for value = { reference = ... }.
    values List<String>
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.

    EscalationPathTemplateSequencesNodeLevelTargetBindingArrayValue, EscalationPathTemplateSequencesNodeLevelTargetBindingArrayValueArgs

    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal str
    If set, this is the literal value of the step parameter
    reference str
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter

    EscalationPathTemplateSequencesNodeLevelTargetBindingValue, EscalationPathTemplateSequencesNodeLevelTargetBindingValueArgs

    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal str
    If set, this is the literal value of the step parameter
    reference str
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter

    EscalationPathTemplateSequencesNodeLoop, EscalationPathTemplateSequencesNodeLoopArgs

    BackTo string
    The id of the node to repeat from.
    Times int
    How many times to repeat these nodes
    BackTo string
    The id of the node to repeat from.
    Times int
    How many times to repeat these nodes
    back_to string
    The id of the node to repeat from.
    times number
    How many times to repeat these nodes
    backTo String
    The id of the node to repeat from.
    times Integer
    How many times to repeat these nodes
    backTo string
    The id of the node to repeat from.
    times number
    How many times to repeat these nodes
    back_to str
    The id of the node to repeat from.
    times int
    How many times to repeat these nodes
    backTo String
    The id of the node to repeat from.
    times Number
    How many times to repeat these nodes

    EscalationPathTemplateSequencesNodeNotifyChannel, EscalationPathTemplateSequencesNodeNotifyChannelArgs

    Targets List<EscalationPathTemplateSequencesNodeNotifyChannelTarget>
    The channels to notify, each concrete or a parameter binding.
    TimeToAckIntervalCondition string
    If the time to ack is relative to a time window, this defines whether we move when the window is active or inactive. Possible values are: active, inactive.
    TimeToAckSeconds int
    How long should we wait for this level to acknowledge before moving on to the next node in the path?
    TimeToAckWeekdayIntervalConfigId string
    If the time to ack is relative to a time window, this identifies which window it is relative to
    Targets []EscalationPathTemplateSequencesNodeNotifyChannelTarget
    The channels to notify, each concrete or a parameter binding.
    TimeToAckIntervalCondition string
    If the time to ack is relative to a time window, this defines whether we move when the window is active or inactive. Possible values are: active, inactive.
    TimeToAckSeconds int
    How long should we wait for this level to acknowledge before moving on to the next node in the path?
    TimeToAckWeekdayIntervalConfigId string
    If the time to ack is relative to a time window, this identifies which window it is relative to
    targets list(object)
    The channels to notify, each concrete or a parameter binding.
    time_to_ack_interval_condition string
    If the time to ack is relative to a time window, this defines whether we move when the window is active or inactive. Possible values are: active, inactive.
    time_to_ack_seconds number
    How long should we wait for this level to acknowledge before moving on to the next node in the path?
    time_to_ack_weekday_interval_config_id string
    If the time to ack is relative to a time window, this identifies which window it is relative to
    targets List<EscalationPathTemplateSequencesNodeNotifyChannelTarget>
    The channels to notify, each concrete or a parameter binding.
    timeToAckIntervalCondition String
    If the time to ack is relative to a time window, this defines whether we move when the window is active or inactive. Possible values are: active, inactive.
    timeToAckSeconds Integer
    How long should we wait for this level to acknowledge before moving on to the next node in the path?
    timeToAckWeekdayIntervalConfigId String
    If the time to ack is relative to a time window, this identifies which window it is relative to
    targets EscalationPathTemplateSequencesNodeNotifyChannelTarget[]
    The channels to notify, each concrete or a parameter binding.
    timeToAckIntervalCondition string
    If the time to ack is relative to a time window, this defines whether we move when the window is active or inactive. Possible values are: active, inactive.
    timeToAckSeconds number
    How long should we wait for this level to acknowledge before moving on to the next node in the path?
    timeToAckWeekdayIntervalConfigId string
    If the time to ack is relative to a time window, this identifies which window it is relative to
    targets Sequence[EscalationPathTemplateSequencesNodeNotifyChannelTarget]
    The channels to notify, each concrete or a parameter binding.
    time_to_ack_interval_condition str
    If the time to ack is relative to a time window, this defines whether we move when the window is active or inactive. Possible values are: active, inactive.
    time_to_ack_seconds int
    How long should we wait for this level to acknowledge before moving on to the next node in the path?
    time_to_ack_weekday_interval_config_id str
    If the time to ack is relative to a time window, this identifies which window it is relative to
    targets List<Property Map>
    The channels to notify, each concrete or a parameter binding.
    timeToAckIntervalCondition String
    If the time to ack is relative to a time window, this defines whether we move when the window is active or inactive. Possible values are: active, inactive.
    timeToAckSeconds Number
    How long should we wait for this level to acknowledge before moving on to the next node in the path?
    timeToAckWeekdayIntervalConfigId String
    If the time to ack is relative to a time window, this identifies which window it is relative to

    EscalationPathTemplateSequencesNodeNotifyChannelTarget, EscalationPathTemplateSequencesNodeNotifyChannelTargetArgs

    Type string
    Controls what type of entity this target identifies, such as EscalationPolicy or User. Possible values are: schedule, user, slackChannel, msteamsChannel.
    Urgency string
    The urgency of this escalation path target. Possible values are: high, low.
    Binding EscalationPathTemplateSequencesNodeNotifyChannelTargetBinding
    Who this target resolves to, decided per templated path. valueReference names one of the template's params, and expressionRef one of its expressions. Set exactly one of id and binding.
    Id string
    Uniquely identifies a concrete target. Omitted when binding is set. Set exactly one of id and binding.
    ScheduleMode string
    Only set for schedule targets, this specifies which users to fetch from the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    SelectedRotaId string
    For a schedule target with a rota-scoped scheduleMode, the rota to page. A bound target can leave this unset and bind to an expression that navigates the schedule's rotations and filters them by name instead.
    Type string
    Controls what type of entity this target identifies, such as EscalationPolicy or User. Possible values are: schedule, user, slackChannel, msteamsChannel.
    Urgency string
    The urgency of this escalation path target. Possible values are: high, low.
    Binding EscalationPathTemplateSequencesNodeNotifyChannelTargetBinding
    Who this target resolves to, decided per templated path. valueReference names one of the template's params, and expressionRef one of its expressions. Set exactly one of id and binding.
    Id string
    Uniquely identifies a concrete target. Omitted when binding is set. Set exactly one of id and binding.
    ScheduleMode string
    Only set for schedule targets, this specifies which users to fetch from the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    SelectedRotaId string
    For a schedule target with a rota-scoped scheduleMode, the rota to page. A bound target can leave this unset and bind to an expression that navigates the schedule's rotations and filters them by name instead.
    type string
    Controls what type of entity this target identifies, such as EscalationPolicy or User. Possible values are: schedule, user, slackChannel, msteamsChannel.
    urgency string
    The urgency of this escalation path target. Possible values are: high, low.
    binding object
    Who this target resolves to, decided per templated path. valueReference names one of the template's params, and expressionRef one of its expressions. Set exactly one of id and binding.
    id string
    Uniquely identifies a concrete target. Omitted when binding is set. Set exactly one of id and binding.
    schedule_mode string
    Only set for schedule targets, this specifies which users to fetch from the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    selected_rota_id string
    For a schedule target with a rota-scoped scheduleMode, the rota to page. A bound target can leave this unset and bind to an expression that navigates the schedule's rotations and filters them by name instead.
    type String
    Controls what type of entity this target identifies, such as EscalationPolicy or User. Possible values are: schedule, user, slackChannel, msteamsChannel.
    urgency String
    The urgency of this escalation path target. Possible values are: high, low.
    binding EscalationPathTemplateSequencesNodeNotifyChannelTargetBinding
    Who this target resolves to, decided per templated path. valueReference names one of the template's params, and expressionRef one of its expressions. Set exactly one of id and binding.
    id String
    Uniquely identifies a concrete target. Omitted when binding is set. Set exactly one of id and binding.
    scheduleMode String
    Only set for schedule targets, this specifies which users to fetch from the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    selectedRotaId String
    For a schedule target with a rota-scoped scheduleMode, the rota to page. A bound target can leave this unset and bind to an expression that navigates the schedule's rotations and filters them by name instead.
    type string
    Controls what type of entity this target identifies, such as EscalationPolicy or User. Possible values are: schedule, user, slackChannel, msteamsChannel.
    urgency string
    The urgency of this escalation path target. Possible values are: high, low.
    binding EscalationPathTemplateSequencesNodeNotifyChannelTargetBinding
    Who this target resolves to, decided per templated path. valueReference names one of the template's params, and expressionRef one of its expressions. Set exactly one of id and binding.
    id string
    Uniquely identifies a concrete target. Omitted when binding is set. Set exactly one of id and binding.
    scheduleMode string
    Only set for schedule targets, this specifies which users to fetch from the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    selectedRotaId string
    For a schedule target with a rota-scoped scheduleMode, the rota to page. A bound target can leave this unset and bind to an expression that navigates the schedule's rotations and filters them by name instead.
    type str
    Controls what type of entity this target identifies, such as EscalationPolicy or User. Possible values are: schedule, user, slackChannel, msteamsChannel.
    urgency str
    The urgency of this escalation path target. Possible values are: high, low.
    binding EscalationPathTemplateSequencesNodeNotifyChannelTargetBinding
    Who this target resolves to, decided per templated path. valueReference names one of the template's params, and expressionRef one of its expressions. Set exactly one of id and binding.
    id str
    Uniquely identifies a concrete target. Omitted when binding is set. Set exactly one of id and binding.
    schedule_mode str
    Only set for schedule targets, this specifies which users to fetch from the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    selected_rota_id str
    For a schedule target with a rota-scoped scheduleMode, the rota to page. A bound target can leave this unset and bind to an expression that navigates the schedule's rotations and filters them by name instead.
    type String
    Controls what type of entity this target identifies, such as EscalationPolicy or User. Possible values are: schedule, user, slackChannel, msteamsChannel.
    urgency String
    The urgency of this escalation path target. Possible values are: high, low.
    binding Property Map
    Who this target resolves to, decided per templated path. valueReference names one of the template's params, and expressionRef one of its expressions. Set exactly one of id and binding.
    id String
    Uniquely identifies a concrete target. Omitted when binding is set. Set exactly one of id and binding.
    scheduleMode String
    Only set for schedule targets, this specifies which users to fetch from the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    selectedRotaId String
    For a schedule target with a rota-scoped scheduleMode, the rota to page. A bound target can leave this unset and bind to an expression that navigates the schedule's rotations and filters them by name instead.

    EscalationPathTemplateSequencesNodeNotifyChannelTargetBinding, EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingArgs

    ArrayValues List<EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingArrayValue>
    The array of literal or reference parameter values
    ExpressionRef string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    Value EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingValue
    The literal or reference parameter value
    ValueLiteral string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    ValueReference string
    A reference into the scope, shorthand for value = { reference = ... }.
    Values List<string>
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    ArrayValues []EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingArrayValue
    The array of literal or reference parameter values
    ExpressionRef string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    Value EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingValue
    The literal or reference parameter value
    ValueLiteral string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    ValueReference string
    A reference into the scope, shorthand for value = { reference = ... }.
    Values []string
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    array_values list(object)
    The array of literal or reference parameter values
    expression_ref string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value object
    The literal or reference parameter value
    value_literal string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    value_reference string
    A reference into the scope, shorthand for value = { reference = ... }.
    values list(string)
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    arrayValues List<EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingArrayValue>
    The array of literal or reference parameter values
    expressionRef String
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingValue
    The literal or reference parameter value
    valueLiteral String
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    valueReference String
    A reference into the scope, shorthand for value = { reference = ... }.
    values List<String>
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    arrayValues EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingArrayValue[]
    The array of literal or reference parameter values
    expressionRef string
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingValue
    The literal or reference parameter value
    valueLiteral string
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    valueReference string
    A reference into the scope, shorthand for value = { reference = ... }.
    values string[]
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    array_values Sequence[EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingArrayValue]
    The array of literal or reference parameter values
    expression_ref str
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingValue
    The literal or reference parameter value
    value_literal str
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    value_reference str
    A reference into the scope, shorthand for value = { reference = ... }.
    values Sequence[str]
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.
    arrayValues List<Property Map>
    The array of literal or reference parameter values
    expressionRef String
    The name of an expression on this resource, whose result becomes the value. Shorthand for referencing expressions["name"].
    value Property Map
    The literal or reference parameter value
    valueLiteral String
    A fixed value, shorthand for value = { literal = ... }. A catalog entry ID is a literal, not a reference.
    valueReference String
    A reference into the scope, shorthand for value = { reference = ... }.
    values List<String>
    Several fixed values, shorthand for an arrayValue of literals. For a mix of literals and references, use arrayValue.

    EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingArrayValue, EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingArrayValueArgs

    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal str
    If set, this is the literal value of the step parameter
    reference str
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter

    EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingValue, EscalationPathTemplateSequencesNodeNotifyChannelTargetBindingValueArgs

    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    Literal string
    If set, this is the literal value of the step parameter
    Reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal string
    If set, this is the literal value of the step parameter
    reference string
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal str
    If set, this is the literal value of the step parameter
    reference str
    If set, this is the reference into the trigger scope that is the value of this parameter
    literal String
    If set, this is the literal value of the step parameter
    reference String
    If set, this is the reference into the trigger scope that is the value of this parameter

    EscalationPathTemplateWorkingHour, EscalationPathTemplateWorkingHourArgs

    Id string
    The unique identifier for this set of working intervals
    Name string
    A human readable label for this set of working intervals
    Timezone string
    How to interpret all the intervals
    WeekdayIntervals List<EscalationPathTemplateWorkingHourWeekdayInterval>
    Id string
    The unique identifier for this set of working intervals
    Name string
    A human readable label for this set of working intervals
    Timezone string
    How to interpret all the intervals
    WeekdayIntervals []EscalationPathTemplateWorkingHourWeekdayInterval
    id string
    The unique identifier for this set of working intervals
    name string
    A human readable label for this set of working intervals
    timezone string
    How to interpret all the intervals
    weekday_intervals list(object)
    id String
    The unique identifier for this set of working intervals
    name String
    A human readable label for this set of working intervals
    timezone String
    How to interpret all the intervals
    weekdayIntervals List<EscalationPathTemplateWorkingHourWeekdayInterval>
    id string
    The unique identifier for this set of working intervals
    name string
    A human readable label for this set of working intervals
    timezone string
    How to interpret all the intervals
    weekdayIntervals EscalationPathTemplateWorkingHourWeekdayInterval[]
    id str
    The unique identifier for this set of working intervals
    name str
    A human readable label for this set of working intervals
    timezone str
    How to interpret all the intervals
    weekday_intervals Sequence[EscalationPathTemplateWorkingHourWeekdayInterval]
    id String
    The unique identifier for this set of working intervals
    name String
    A human readable label for this set of working intervals
    timezone String
    How to interpret all the intervals
    weekdayIntervals List<Property Map>

    EscalationPathTemplateWorkingHourWeekdayInterval, EscalationPathTemplateWorkingHourWeekdayIntervalArgs

    EndTime string
    End time of the interval, in 24hr format
    StartTime string
    Start time of the interval, in 24hr format
    Weekday string
    Weekdays for use within a schedule or escalation path. Possible values are: monday, tuesday, wednesday, thursday, friday, saturday, sunday.
    EndTime string
    End time of the interval, in 24hr format
    StartTime string
    Start time of the interval, in 24hr format
    Weekday string
    Weekdays for use within a schedule or escalation path. Possible values are: monday, tuesday, wednesday, thursday, friday, saturday, sunday.
    end_time string
    End time of the interval, in 24hr format
    start_time string
    Start time of the interval, in 24hr format
    weekday string
    Weekdays for use within a schedule or escalation path. Possible values are: monday, tuesday, wednesday, thursday, friday, saturday, sunday.
    endTime String
    End time of the interval, in 24hr format
    startTime String
    Start time of the interval, in 24hr format
    weekday String
    Weekdays for use within a schedule or escalation path. Possible values are: monday, tuesday, wednesday, thursday, friday, saturday, sunday.
    endTime string
    End time of the interval, in 24hr format
    startTime string
    Start time of the interval, in 24hr format
    weekday string
    Weekdays for use within a schedule or escalation path. Possible values are: monday, tuesday, wednesday, thursday, friday, saturday, sunday.
    end_time str
    End time of the interval, in 24hr format
    start_time str
    Start time of the interval, in 24hr format
    weekday str
    Weekdays for use within a schedule or escalation path. Possible values are: monday, tuesday, wednesday, thursday, friday, saturday, sunday.
    endTime String
    End time of the interval, in 24hr format
    startTime String
    Start time of the interval, in 24hr format
    weekday String
    Weekdays for use within a schedule or escalation path. Possible values are: monday, tuesday, wednesday, thursday, friday, saturday, sunday.

    Import

    Import is supported using an import block or the pulumi import command:

    The pulumi import command can be used, for example:

    !/bin/bash

    Import an escalation path template using its ID Replace the ID with a real ID from your incident.io organization

    $ pulumi import incident:index/escalationPathTemplate:EscalationPathTemplate team_oncall 01ABC123DEF456GHI789JKL
    

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    incident incident-io/pulumi-incident
    License
    MIT
    Notes
    This Pulumi package is based on the incident Terraform Provider.
    incident logo incident.io
    Viewing docs for incident.io v0.4.1
    published on Wednesday, Oct 21, 2026 by incident-io

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial