Sign in Dashboard Get started
  1. Registry
  2. Packages
  3. incident.io
  4. API Docs
  5. EscalationPath
Viewing docs for incident.io v0.3.1
published on Thursday, Oct 8, 2026 by incident-io
Schema (JSON)
incident-io/pulumi-incident

incident.EscalationPath

incident logo incident.io
Viewing docs for incident.io v0.3.1
published on Thursday, Oct 8, 2026 by incident-io
Schema (JSON)
incident-io/pulumi-incident

    Create and manage escalation paths, written as a flat map of named node sequences.

    Each sequence runs its nodes in order and either ends with a branch, which names the sequences to continue down, or falls off the end of the escalation path.

    We’d generally recommend building escalation paths in our web dashboard and using the ‘Export’ flow to generate your Terraform.

    Upgrading from v6

    Before v7 this resource nested a branch’s nodes inside it, as if_else.then_path and if_else.else_path. Terraform schemas can’t recurse indefinitely, so it stopped at five levels of branching, and a path that branched more than that couldn’t be written at all.

    It now names its sequences instead. A branch says which sequence to continue down rather than holding its nodes, so every sequence sits at the same depth in the config and there’s no nesting limit. It also swaps repeat for loop, which names the node to go back to, and replaces the raw engine conditions on a branch with a branch.if block holding one attribute per thing an escalation can be tested on.

    Your escalation path’s state carries over: the path it holds is dropped and the rest is read back from the API. Rewrite the path as sequences in your configuration, and note that this resource names the sequences itself when it reads them back - the one the path starts with is main, and the sequences a branch leads to are mainThen and mainElse, after the sequence the branch sits in. A configuration that calls them something else plans a change, so run pulumi preview before you apply.

    Write out each level’s ackMode while you are there. This resource defaults it to first where v6 defaulted it to all, and a default applies wherever the configuration is silent - so a level that never set ackMode plans a change from all to first, and applying it changes how the level pages: with first, the first person to acknowledge cancels everyone else’s escalation on that level. Set ackMode = "all" on every level whose behaviour you mean to keep.

    If you were already using incident.EscalationPathBeta, none of this applies: that name still works in v7, and renaming it to this one is a moved block whenever you want to make it.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
import * as incident from "@incident-io/pulumi";

// Look up a user to page. Escalation path targets can also be schedules or
// Slack/Teams channels; see the `type` attribute on each target.
const onCall = incident.getUser({
    email: "on-call@example.com",
});
// A last resort path, which the path below hands over to out of hours.
const fallback = new incident.EscalationPath("fallback", {
    name: "Fallback",
    path: [{
        type: "level",
        level: {
            targets: [{
                type: "user",
                id: onCall.then(onCall => onCall.id),
                urgency: "high",
            }],
            timeToAckSeconds: 300,
        },
    }],
});
// The same escalation path as the incident_escalation_path example, written as a
// flat map of sequences: if in working hours, page with high urgency; otherwise
// page with low urgency.
const urgentSupport = new incident.EscalationPath("urgent_support", {
    name: "Urgent support",
    start: "main",
    sequences: {
        main: {
            nodes: [{
                id: "start",
                branch: {
                    "if": {
                        workingHoursActive: "UK",
                    },
                    then: "in_hours",
                    "else": "out_of_hours",
                },
            }],
        },
        in_hours: {
            nodes: [
                {
                    level: {
                        targets: [{
                            type: "user",
                            id: onCall.then(onCall => onCall.id),
                            urgency: "high",
                        }],
                        timeToAckSeconds: 300,
                    },
                },
                {
                    delay: {
                        delaySeconds: 120,
                    },
                },
                {
                    loop: {
                        backTo: "start",
                        times: 3,
                    },
                },
            ],
        },
        out_of_hours: {
            nodes: [
                {
                    level: {
                        targets: [{
                            type: "user",
                            id: onCall.then(onCall => onCall.id),
                            urgency: "low",
                        }],
                        timeToAckSeconds: 300,
                    },
                },
                {
                    escalationPath: {
                        escalationPathId: fallback.id,
                    },
                },
            ],
        },
    },
    workingHours: [{
        id: "UK",
        name: "UK",
        timezone: "Europe/London",
        weekdayIntervals: [{
            weekday: "monday",
            startTime: "09:00",
            endTime: "17:00",
        }],
    }],
});

    import pulumi
import pulumi_incident as incident

# Look up a user to page. Escalation path targets can also be schedules or
# Slack/Teams channels; see the `type` attribute on each target.
on_call = incident.get_user(email="on-call@example.com")
# A last resort path, which the path below hands over to out of hours.
fallback = incident.EscalationPath("fallback",
    name="Fallback",
    path=[{
        "type": "level",
        "level": {
            "targets": [{
                "type": "user",
                "id": on_call.id,
                "urgency": "high",
            }],
            "timeToAckSeconds": 300,
        },
    }])
# The same escalation path as the incident_escalation_path example, written as a
# flat map of sequences: if in working hours, page with high urgency; otherwise
# page with low urgency.
urgent_support = incident.EscalationPath("urgent_support",
    name="Urgent support",
    start="main",
    sequences={
        "main": {
            "nodes": [{
                "id": "start",
                "branch": {
                    "if_": {
                        "working_hours_active": "UK",
                    },
                    "then": "in_hours",
                    "else_": "out_of_hours",
                },
            }],
        },
        "in_hours": {
            "nodes": [
                {
                    "level": {
                        "targets": [{
                            "type": "user",
                            "id": on_call.id,
                            "urgency": "high",
                        }],
                        "time_to_ack_seconds": 300,
                    },
                },
                {
                    "delay": {
                        "delay_seconds": 120,
                    },
                },
                {
                    "loop": {
                        "back_to": "start",
                        "times": 3,
                    },
                },
            ],
        },
        "out_of_hours": {
            "nodes": [
                {
                    "level": {
                        "targets": [{
                            "type": "user",
                            "id": on_call.id,
                            "urgency": "low",
                        }],
                        "time_to_ack_seconds": 300,
                    },
                },
                {
                    "escalation_path": {
                        "escalation_path_id": fallback.id,
                    },
                },
            ],
        },
    },
    working_hours=[{
        "id": "UK",
        "name": "UK",
        "timezone": "Europe/London",
        "weekday_intervals": [{
            "weekday": "monday",
            "start_time": "09:00",
            "end_time": "17:00",
        }],
    }])

    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 {
		// Look up a user to page. Escalation path targets can also be schedules or
		// Slack/Teams channels; see the `type` attribute on each target.
		onCall, err := incident.GetUser(ctx, &incident.GetUserArgs{
			Email: pulumi.StringRef("on-call@example.com"),
		}, nil)
		if err != nil {
			return err
		}
		// A last resort path, which the path below hands over to out of hours.
		fallback, err := incident.NewEscalationPath(ctx, "fallback", &incident.EscalationPathArgs{
			Name: pulumi.String("Fallback"),
			Path: []map[string]interface{}{
				map[string]interface{}{
					"type": "level",
					"level": map[string]interface{}{
						"targets": []map[string]interface{}{
							map[string]interface{}{
								"type":    "user",
								"id":      onCall.Id,
								"urgency": "high",
							},
						},
						"timeToAckSeconds": 300,
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// The same escalation path as the incident_escalation_path example, written as a
		// flat map of sequences: if in working hours, page with high urgency; otherwise
		// page with low urgency.
		_, err = incident.NewEscalationPath(ctx, "urgent_support", &incident.EscalationPathArgs{
			Name:  pulumi.String("Urgent support"),
			Start: pulumi.String("main"),
			Sequences: incident.EscalationPathSequencesMap{
				"main": &incident.EscalationPathSequencesArgs{
					Nodes: incident.EscalationPathSequencesNodeArray{
						&incident.EscalationPathSequencesNodeArgs{
							Id: pulumi.String("start"),
							Branch: &incident.EscalationPathSequencesNodeBranchArgs{
								If: &incident.EscalationPathSequencesNodeBranchIfArgs{
									WorkingHoursActive: pulumi.String("UK"),
								},
								Then: pulumi.String("in_hours"),
								Else: pulumi.String("out_of_hours"),
							},
						},
					},
				},
				"in_hours": &incident.EscalationPathSequencesArgs{
					Nodes: incident.EscalationPathSequencesNodeArray{
						&incident.EscalationPathSequencesNodeArgs{
							Level: &incident.EscalationPathSequencesNodeLevelArgs{
								Targets: incident.EscalationPathSequencesNodeLevelTargetArray{
									&incident.EscalationPathSequencesNodeLevelTargetArgs{
										Type:    pulumi.String("user"),
										Id:      pulumi.String(onCall.Id),
										Urgency: pulumi.String("high"),
									},
								},
								TimeToAckSeconds: pulumi.Int(300),
							},
						},
						&incident.EscalationPathSequencesNodeArgs{
							Delay: &incident.EscalationPathSequencesNodeDelayArgs{
								DelaySeconds: pulumi.Int(120),
							},
						},
						&incident.EscalationPathSequencesNodeArgs{
							Loop: &incident.EscalationPathSequencesNodeLoopArgs{
								BackTo: pulumi.String("start"),
								Times:  pulumi.Int(3),
							},
						},
					},
				},
				"out_of_hours": &incident.EscalationPathSequencesArgs{
					Nodes: incident.EscalationPathSequencesNodeArray{
						&incident.EscalationPathSequencesNodeArgs{
							Level: &incident.EscalationPathSequencesNodeLevelArgs{
								Targets: incident.EscalationPathSequencesNodeLevelTargetArray{
									&incident.EscalationPathSequencesNodeLevelTargetArgs{
										Type:    pulumi.String("user"),
										Id:      pulumi.String(onCall.Id),
										Urgency: pulumi.String("low"),
									},
								},
								TimeToAckSeconds: pulumi.Int(300),
							},
						},
						&incident.EscalationPathSequencesNodeArgs{
							EscalationPath: &incident.EscalationPathSequencesNodeEscalationPathArgs{
								EscalationPathId: fallback.ID().ToIDOutput().ToStringOutput(),
							},
						},
					},
				},
			},
			WorkingHours: incident.EscalationPathWorkingHourArray{
				&incident.EscalationPathWorkingHourArgs{
					Id:       pulumi.String("UK"),
					Name:     pulumi.String("UK"),
					Timezone: pulumi.String("Europe/London"),
					WeekdayIntervals: incident.EscalationPathWorkingHourWeekdayIntervalArray{
						&incident.EscalationPathWorkingHourWeekdayIntervalArgs{
							Weekday:   pulumi.String("monday"),
							StartTime: pulumi.String("09:00"),
							EndTime:   pulumi.String("17:00"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Incident = Pulumi.Incident;

return await Deployment.RunAsync(() => 
{
    // Look up a user to page. Escalation path targets can also be schedules or
    // Slack/Teams channels; see the `type` attribute on each target.
    var onCall = Incident.GetUser.Invoke(new()
    {
        Email = "on-call@example.com",
    });

    // A last resort path, which the path below hands over to out of hours.
    var fallback = new Incident.EscalationPath("fallback", new()
    {
        Name = "Fallback",
        Path = new[]
        {
            
            {
                { "type", "level" },
                { "level", 
                {
                    { "targets", new[]
                    {
                        
                        {
                            { "type", "user" },
                            { "id", onCall.Apply(getUserResult => getUserResult.Id) },
                            { "urgency", "high" },
                        },
                    } },
                    { "timeToAckSeconds", 300 },
                } },
            },
        },
    });

    // The same escalation path as the incident_escalation_path example, written as a
    // flat map of sequences: if in working hours, page with high urgency; otherwise
    // page with low urgency.
    var urgentSupport = new Incident.EscalationPath("urgent_support", new()
    {
        Name = "Urgent support",
        Start = "main",
        Sequences = 
        {
            { "main", new Incident.Inputs.EscalationPathSequencesArgs
            {
                Nodes = new[]
                {
                    new Incident.Inputs.EscalationPathSequencesNodeArgs
                    {
                        Id = "start",
                        Branch = new Incident.Inputs.EscalationPathSequencesNodeBranchArgs
                        {
                            If = new Incident.Inputs.EscalationPathSequencesNodeBranchIfArgs
                            {
                                WorkingHoursActive = "UK",
                            },
                            Then = "in_hours",
                            Else = "out_of_hours",
                        },
                    },
                },
            } },
            { "in_hours", new Incident.Inputs.EscalationPathSequencesArgs
            {
                Nodes = new[]
                {
                    new Incident.Inputs.EscalationPathSequencesNodeArgs
                    {
                        Level = new Incident.Inputs.EscalationPathSequencesNodeLevelArgs
                        {
                            Targets = new[]
                            {
                                new Incident.Inputs.EscalationPathSequencesNodeLevelTargetArgs
                                {
                                    Type = "user",
                                    Id = onCall.Apply(getUserResult => getUserResult.Id),
                                    Urgency = "high",
                                },
                            },
                            TimeToAckSeconds = 300,
                        },
                    },
                    new Incident.Inputs.EscalationPathSequencesNodeArgs
                    {
                        Delay = new Incident.Inputs.EscalationPathSequencesNodeDelayArgs
                        {
                            DelaySeconds = 120,
                        },
                    },
                    new Incident.Inputs.EscalationPathSequencesNodeArgs
                    {
                        Loop = new Incident.Inputs.EscalationPathSequencesNodeLoopArgs
                        {
                            BackTo = "start",
                            Times = 3,
                        },
                    },
                },
            } },
            { "out_of_hours", new Incident.Inputs.EscalationPathSequencesArgs
            {
                Nodes = new[]
                {
                    new Incident.Inputs.EscalationPathSequencesNodeArgs
                    {
                        Level = new Incident.Inputs.EscalationPathSequencesNodeLevelArgs
                        {
                            Targets = new[]
                            {
                                new Incident.Inputs.EscalationPathSequencesNodeLevelTargetArgs
                                {
                                    Type = "user",
                                    Id = onCall.Apply(getUserResult => getUserResult.Id),
                                    Urgency = "low",
                                },
                            },
                            TimeToAckSeconds = 300,
                        },
                    },
                    new Incident.Inputs.EscalationPathSequencesNodeArgs
                    {
                        EscalationPath = new Incident.Inputs.EscalationPathSequencesNodeEscalationPathArgs
                        {
                            EscalationPathId = fallback.Id,
                        },
                    },
                },
            } },
        },
        WorkingHours = new[]
        {
            new Incident.Inputs.EscalationPathWorkingHourArgs
            {
                Id = "UK",
                Name = "UK",
                Timezone = "Europe/London",
                WeekdayIntervals = new[]
                {
                    new Incident.Inputs.EscalationPathWorkingHourWeekdayIntervalArgs
                    {
                        Weekday = "monday",
                        StartTime = "09:00",
                        EndTime = "17:00",
                    },
                },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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.EscalationPathSequencesArgs;
import com.pulumi.incident.inputs.EscalationPathSequencesNodeArgs;
import com.pulumi.incident.inputs.EscalationPathSequencesNodeBranchArgs;
import com.pulumi.incident.inputs.EscalationPathSequencesNodeBranchIfArgs;
import com.pulumi.incident.inputs.EscalationPathSequencesNodeLevelArgs;
import com.pulumi.incident.inputs.EscalationPathSequencesNodeLevelTargetArgs;
import com.pulumi.incident.inputs.EscalationPathSequencesNodeDelayArgs;
import com.pulumi.incident.inputs.EscalationPathSequencesNodeLoopArgs;
import com.pulumi.incident.inputs.EscalationPathSequencesNodeEscalationPathArgs;
import com.pulumi.incident.inputs.EscalationPathWorkingHourArgs;
import com.pulumi.incident.inputs.EscalationPathWorkingHourWeekdayIntervalArgs;
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) {
        // Look up a user to page. Escalation path targets can also be schedules or
        // Slack/Teams channels; see the `type` attribute on each target.
        final var onCall = IncidentFunctions.getUser(GetUserArgs.builder()
            .email("on-call@example.com")
            .build());

        // A last resort path, which the path below hands over to out of hours.
        var fallback = new EscalationPath("fallback", EscalationPathArgs.builder()
            .name("Fallback")
            .path(Arrays.asList(Map.ofEntries(
                Map.entry("type", "level"),
                Map.entry("level", Map.ofEntries(
                    Map.entry("targets", Arrays.asList(Map.ofEntries(
                        Map.entry("type", "user"),
                        Map.entry("id", onCall.id()),
                        Map.entry("urgency", "high")
                    ))),
                    Map.entry("timeToAckSeconds", 300)
                ))
            )))
            .build());

        // The same escalation path as the incident_escalation_path example, written as a
        // flat map of sequences: if in working hours, page with high urgency; otherwise
        // page with low urgency.
        var urgentSupport = new EscalationPath("urgentSupport", EscalationPathArgs.builder()
            .name("Urgent support")
            .start("main")
            .sequences(Map.ofEntries(
                Map.entry("main", EscalationPathSequencesArgs.builder()
                    .nodes(EscalationPathSequencesNodeArgs.builder()
                        .id("start")
                        .branch(EscalationPathSequencesNodeBranchArgs.builder()
                            .if_(EscalationPathSequencesNodeBranchIfArgs.builder()
                                .workingHoursActive("UK")
                                .build())
                            .then("in_hours")
                            .else_("out_of_hours")
                            .build())
                        .build())
                    .build()),
                Map.entry("in_hours", EscalationPathSequencesArgs.builder()
                    .nodes(                    
                        EscalationPathSequencesNodeArgs.builder()
                            .level(EscalationPathSequencesNodeLevelArgs.builder()
                                .targets(EscalationPathSequencesNodeLevelTargetArgs.builder()
                                    .type("user")
                                    .id(onCall.id())
                                    .urgency("high")
                                    .build())
                                .timeToAckSeconds(300)
                                .build())
                            .build(),
                        EscalationPathSequencesNodeArgs.builder()
                            .delay(EscalationPathSequencesNodeDelayArgs.builder()
                                .delaySeconds(120)
                                .build())
                            .build(),
                        EscalationPathSequencesNodeArgs.builder()
                            .loop(EscalationPathSequencesNodeLoopArgs.builder()
                                .backTo("start")
                                .times(3)
                                .build())
                            .build())
                    .build()),
                Map.entry("out_of_hours", EscalationPathSequencesArgs.builder()
                    .nodes(                    
                        EscalationPathSequencesNodeArgs.builder()
                            .level(EscalationPathSequencesNodeLevelArgs.builder()
                                .targets(EscalationPathSequencesNodeLevelTargetArgs.builder()
                                    .type("user")
                                    .id(onCall.id())
                                    .urgency("low")
                                    .build())
                                .timeToAckSeconds(300)
                                .build())
                            .build(),
                        EscalationPathSequencesNodeArgs.builder()
                            .escalationPath(EscalationPathSequencesNodeEscalationPathArgs.builder()
                                .escalationPathId(fallback.id())
                                .build())
                            .build())
                    .build())
            ))
            .workingHours(EscalationPathWorkingHourArgs.builder()
                .id("UK")
                .name("UK")
                .timezone("Europe/London")
                .weekdayIntervals(EscalationPathWorkingHourWeekdayIntervalArgs.builder()
                    .weekday("monday")
                    .startTime("09:00")
                    .endTime("17:00")
                    .build())
                .build())
            .build());

    }
}

    resources:
  # A last resort path, which the path below hands over to out of hours.
  fallback:
    type: incident:EscalationPath
    properties:
      name: Fallback
      path:
        - type: level
          level:
            targets:
              - type: user
                id: ${onCall.id}
                urgency: high
            timeToAckSeconds: 300
  # The same escalation path as the incident_escalation_path example, written as a
  # flat map of sequences: if in working hours, page with high urgency; otherwise
  # page with low urgency.
  urgentSupport:
    type: incident:EscalationPath
    name: urgent_support
    properties:
      name: Urgent support
      start: main
      sequences:
        main:
          nodes:
            - id: start
              branch:
                if:
                  workingHoursActive: UK
                then: in_hours
                else: out_of_hours
        in_hours:
          nodes:
            - level:
                targets:
                  - type: user
                    id: ${onCall.id}
                    urgency: high
                timeToAckSeconds: 300
            - delay:
                delaySeconds: 120
            - loop:
                backTo: start
                times: 3
        out_of_hours:
          nodes:
            - level:
                targets:
                  - type: user
                    id: ${onCall.id}
                    urgency: low
                timeToAckSeconds: 300
            - escalationPath:
                escalationPathId: ${fallback.id}
      workingHours:
        - id: UK
          name: UK
          timezone: Europe/London
          weekdayIntervals:
            - weekday: monday
              startTime: 09:00
              endTime: 17:00
variables:
  # Look up a user to page. Escalation path targets can also be schedules or
  # Slack/Teams channels; see the `type` attribute on each target.
  onCall:
    fn::invoke:
      function: incident:getUser
      arguments:
        email: on-call@example.com

    pulumi {
  required_providers {
    incident = {
      source = "pulumi/incident"
    }
  }
}

data "incident_getuser" "onCall" {
  email = "on-call@example.com"
}

# A last resort path, which the path below hands over to out of hours.
resource "incident_escalationpath" "fallback" {
  name = "Fallback"
  path = [{
    "type" = "level"
    "level" = {
      "targets" = [{
        "type"    = "user"
        "id"      = data.incident_getuser.onCall.id
        "urgency" = "high"
      }]
      "timeToAckSeconds" = 300
    }
  }]
}
# The same escalation path as the incident_escalation_path example, written as a
# flat map of sequences: if in working hours, page with high urgency; otherwise
# page with low urgency.
resource "incident_escalationpath" "urgent_support" {
  name  = "Urgent support"
  start = "main"
  sequences = {
    "main" = {
      nodes = [{
        "id" = "start"
        "branch" = {
          "if" = {
            "workingHoursActive" = "UK"
          }
          "then" = "in_hours"
          "else" = "out_of_hours"
        }
      }]
    }
    "in_hours" = {
      nodes = [{
        "level" = {
          "targets" = [{
            "type"    = "user"
            "id"      = data.incident_getuser.onCall.id
            "urgency" = "high"
          }]
          "timeToAckSeconds" = 300
        }
        }, {
        "delay" = {
          "delaySeconds" = 120
        }
        }, {
        "loop" = {
          "backTo" = "start"
          "times"  = 3
        }
      }]
    }
    "out_of_hours" = {
      nodes = [{
        "level" = {
          "targets" = [{
            "type"    = "user"
            "id"      = data.incident_getuser.onCall.id
            "urgency" = "low"
          }]
          "timeToAckSeconds" = 300
        }
        }, {
        "escalationPath" = {
          "escalationPathId" = incident_escalationpath.fallback.id
        }
      }]
    }
  }
  working_hours {
    id       = "UK"
    name     = "UK"
    timezone = "Europe/London"
    weekday_intervals {
      weekday    = "monday"
      start_time = "09:00"
      end_time   = "17:00"
    }
  }
}
# Look up a user to page. Escalation path targets can also be schedules or
# Slack/Teams channels; see the `type` attribute on each target.

    Create EscalationPath Resource

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

    Constructor syntax

    new EscalationPath(name: string, args?: EscalationPathArgs, opts?: CustomResourceOptions);
    @overload
def EscalationPath(resource_name: str,
                   args: Optional[EscalationPathArgs] = None,
                   opts: Optional[ResourceOptions] = None)

@overload
def EscalationPath(resource_name: str,
                   opts: Optional[ResourceOptions] = None,
                   kind: Optional[str] = None,
                   name: Optional[str] = None,
                   param_bindings: Optional[Mapping[str, EscalationPathParamBindingsArgs]] = None,
                   repeat_config: Optional[EscalationPathRepeatConfigArgs] = None,
                   sequences: Optional[Mapping[str, EscalationPathSequencesArgs]] = None,
                   start: Optional[str] = None,
                   team_ids: Optional[Sequence[str]] = None,
                   template_id: Optional[str] = None,
                   unlock_in_dashboard: Optional[bool] = None,
                   working_hours: Optional[Sequence[EscalationPathWorkingHourArgs]] = None)
    func NewEscalationPath(ctx *Context, name string, args *EscalationPathArgs, opts ...ResourceOption) (*EscalationPath, error)
    public EscalationPath(string name, EscalationPathArgs? args = null, CustomResourceOptions? opts = null)
    public EscalationPath(String name, EscalationPathArgs args)
public EscalationPath(String name, EscalationPathArgs args, CustomResourceOptions options)

    type: incident:EscalationPath
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.


    resource "incident_escalation_path" "name" {
    # resource properties
}

    Parameters

    name string
    The unique name of the resource.
    args EscalationPathArgs
    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 EscalationPathArgs
    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 EscalationPathArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args EscalationPathArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args EscalationPathArgs
    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 escalationPathResource = new Incident.EscalationPath("escalationPathResource", new()
{
    Kind = "string",
    Name = "string",
    ParamBindings = 
    {
        { "string", new Incident.Inputs.EscalationPathParamBindingsArgs
        {
            ArrayValues = new[]
            {
                new Incident.Inputs.EscalationPathParamBindingsArrayValueArgs
                {
                    Literal = "string",
                    Reference = "string",
                },
            },
            ExpressionRef = "string",
            Value = new Incident.Inputs.EscalationPathParamBindingsValueArgs
            {
                Literal = "string",
                Reference = "string",
            },
            ValueLiteral = "string",
            ValueReference = "string",
            Values = new[]
            {
                "string",
            },
        } },
    },
    RepeatConfig = new Incident.Inputs.EscalationPathRepeatConfigArgs
    {
        DelayRepeatOnActivity = false,
        RepeatAfterSeconds = 0,
    },
    Sequences = 
    {
        { "string", new Incident.Inputs.EscalationPathSequencesArgs
        {
            Nodes = new[]
            {
                new Incident.Inputs.EscalationPathSequencesNodeArgs
                {
                    Branch = new Incident.Inputs.EscalationPathSequencesNodeBranchArgs
                    {
                        If = new Incident.Inputs.EscalationPathSequencesNodeBranchIfArgs
                        {
                            PriorityOneOfs = new[]
                            {
                                "string",
                            },
                            WorkingHoursActive = "string",
                        },
                        Then = "string",
                        Else = "string",
                    },
                    Delay = new Incident.Inputs.EscalationPathSequencesNodeDelayArgs
                    {
                        DelayIntervalCondition = "string",
                        DelaySeconds = 0,
                        DelayWeekdayIntervalConfigId = "string",
                    },
                    EscalationPath = new Incident.Inputs.EscalationPathSequencesNodeEscalationPathArgs
                    {
                        EscalationPathId = "string",
                    },
                    Id = "string",
                    Level = new Incident.Inputs.EscalationPathSequencesNodeLevelArgs
                    {
                        Targets = new[]
                        {
                            new Incident.Inputs.EscalationPathSequencesNodeLevelTargetArgs
                            {
                                Id = "string",
                                Type = "string",
                                Urgency = "string",
                                ScheduleMode = "string",
                                SelectedRotaId = "string",
                            },
                        },
                        AckMode = "string",
                        RetryConfig = new Incident.Inputs.EscalationPathSequencesNodeLevelRetryConfigArgs
                        {
                            Attempts = 0,
                            IntervalSeconds = 0,
                        },
                        RoundRobinConfig = new Incident.Inputs.EscalationPathSequencesNodeLevelRoundRobinConfigArgs
                        {
                            Enabled = false,
                            RotateAfterSeconds = 0,
                        },
                        TimeToAckIntervalCondition = "string",
                        TimeToAckSeconds = 0,
                        TimeToAckWeekdayIntervalConfigId = "string",
                    },
                    Loop = new Incident.Inputs.EscalationPathSequencesNodeLoopArgs
                    {
                        BackTo = "string",
                        Times = 0,
                    },
                    NotifyChannel = new Incident.Inputs.EscalationPathSequencesNodeNotifyChannelArgs
                    {
                        Targets = new[]
                        {
                            new Incident.Inputs.EscalationPathSequencesNodeNotifyChannelTargetArgs
                            {
                                Id = "string",
                                Type = "string",
                                Urgency = "string",
                                ScheduleMode = "string",
                                SelectedRotaId = "string",
                            },
                        },
                        TimeToAckIntervalCondition = "string",
                        TimeToAckSeconds = 0,
                        TimeToAckWeekdayIntervalConfigId = "string",
                    },
                },
            },
        } },
    },
    Start = "string",
    TeamIds = new[]
    {
        "string",
    },
    TemplateId = "string",
    UnlockInDashboard = false,
    WorkingHours = new[]
    {
        new Incident.Inputs.EscalationPathWorkingHourArgs
        {
            Id = "string",
            Name = "string",
            Timezone = "string",
            WeekdayIntervals = new[]
            {
                new Incident.Inputs.EscalationPathWorkingHourWeekdayIntervalArgs
                {
                    EndTime = "string",
                    StartTime = "string",
                    Weekday = "string",
                },
            },
        },
    },
});

    example, err := incident.NewEscalationPath(ctx, "escalationPathResource", &incident.EscalationPathArgs{
	Kind: pulumi.String("string"),
	Name: pulumi.String("string"),
	ParamBindings: incident.EscalationPathParamBindingsMap{
		"string": &incident.EscalationPathParamBindingsArgs{
			ArrayValues: incident.EscalationPathParamBindingsArrayValueArray{
				&incident.EscalationPathParamBindingsArrayValueArgs{
					Literal:   pulumi.String("string"),
					Reference: pulumi.String("string"),
				},
			},
			ExpressionRef: pulumi.String("string"),
			Value: &incident.EscalationPathParamBindingsValueArgs{
				Literal:   pulumi.String("string"),
				Reference: pulumi.String("string"),
			},
			ValueLiteral:   pulumi.String("string"),
			ValueReference: pulumi.String("string"),
			Values: pulumi.StringArray{
				pulumi.String("string"),
			},
		},
	},
	RepeatConfig: &incident.EscalationPathRepeatConfigArgs{
		DelayRepeatOnActivity: pulumi.Bool(false),
		RepeatAfterSeconds:    pulumi.Int(0),
	},
	Sequences: incident.EscalationPathSequencesMap{
		"string": &incident.EscalationPathSequencesArgs{
			Nodes: incident.EscalationPathSequencesNodeArray{
				&incident.EscalationPathSequencesNodeArgs{
					Branch: &incident.EscalationPathSequencesNodeBranchArgs{
						If: &incident.EscalationPathSequencesNodeBranchIfArgs{
							PriorityOneOfs: pulumi.StringArray{
								pulumi.String("string"),
							},
							WorkingHoursActive: pulumi.String("string"),
						},
						Then: pulumi.String("string"),
						Else: pulumi.String("string"),
					},
					Delay: &incident.EscalationPathSequencesNodeDelayArgs{
						DelayIntervalCondition:       pulumi.String("string"),
						DelaySeconds:                 pulumi.Int(0),
						DelayWeekdayIntervalConfigId: pulumi.String("string"),
					},
					EscalationPath: &incident.EscalationPathSequencesNodeEscalationPathArgs{
						EscalationPathId: pulumi.String("string"),
					},
					Id: pulumi.String("string"),
					Level: &incident.EscalationPathSequencesNodeLevelArgs{
						Targets: incident.EscalationPathSequencesNodeLevelTargetArray{
							&incident.EscalationPathSequencesNodeLevelTargetArgs{
								Id:             pulumi.String("string"),
								Type:           pulumi.String("string"),
								Urgency:        pulumi.String("string"),
								ScheduleMode:   pulumi.String("string"),
								SelectedRotaId: pulumi.String("string"),
							},
						},
						AckMode: pulumi.String("string"),
						RetryConfig: &incident.EscalationPathSequencesNodeLevelRetryConfigArgs{
							Attempts:        pulumi.Int(0),
							IntervalSeconds: pulumi.Int(0),
						},
						RoundRobinConfig: &incident.EscalationPathSequencesNodeLevelRoundRobinConfigArgs{
							Enabled:            pulumi.Bool(false),
							RotateAfterSeconds: pulumi.Int(0),
						},
						TimeToAckIntervalCondition:       pulumi.String("string"),
						TimeToAckSeconds:                 pulumi.Int(0),
						TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
					},
					Loop: &incident.EscalationPathSequencesNodeLoopArgs{
						BackTo: pulumi.String("string"),
						Times:  pulumi.Int(0),
					},
					NotifyChannel: &incident.EscalationPathSequencesNodeNotifyChannelArgs{
						Targets: incident.EscalationPathSequencesNodeNotifyChannelTargetArray{
							&incident.EscalationPathSequencesNodeNotifyChannelTargetArgs{
								Id:             pulumi.String("string"),
								Type:           pulumi.String("string"),
								Urgency:        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"),
	TeamIds: pulumi.StringArray{
		pulumi.String("string"),
	},
	TemplateId:        pulumi.String("string"),
	UnlockInDashboard: pulumi.Bool(false),
	WorkingHours: incident.EscalationPathWorkingHourArray{
		&incident.EscalationPathWorkingHourArgs{
			Id:       pulumi.String("string"),
			Name:     pulumi.String("string"),
			Timezone: pulumi.String("string"),
			WeekdayIntervals: incident.EscalationPathWorkingHourWeekdayIntervalArray{
				&incident.EscalationPathWorkingHourWeekdayIntervalArgs{
					EndTime:   pulumi.String("string"),
					StartTime: pulumi.String("string"),
					Weekday:   pulumi.String("string"),
				},
			},
		},
	},
})

    resource "incident_escalation_path" "escalationPathResource" {
  lifecycle {
    create_before_destroy = true
  }
  kind = "string"
  name = "string"
  param_bindings = {
    "string" = {
      array_values = [{
        literal   = "string"
        reference = "string"
      }]
      expression_ref = "string"
      value = {
        literal   = "string"
        reference = "string"
      }
      value_literal   = "string"
      value_reference = "string"
      values          = ["string"]
    }
  }
  repeat_config = {
    delay_repeat_on_activity = false
    repeat_after_seconds     = 0
  }
  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 = [{
            id               = "string"
            type             = "string"
            urgency          = "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 = [{
            id               = "string"
            type             = "string"
            urgency          = "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"
  team_ids            = ["string"]
  template_id         = "string"
  unlock_in_dashboard = false
  working_hours {
    id       = "string"
    name     = "string"
    timezone = "string"
    weekday_intervals {
      end_time   = "string"
      start_time = "string"
      weekday    = "string"
    }
  }
}

    var escalationPathResource = new EscalationPath("escalationPathResource", EscalationPathArgs.builder()
    .kind("string")
    .name("string")
    .paramBindings(Map.of("string", EscalationPathParamBindingsArgs.builder()
        .arrayValues(EscalationPathParamBindingsArrayValueArgs.builder()
            .literal("string")
            .reference("string")
            .build())
        .expressionRef("string")
        .value(EscalationPathParamBindingsValueArgs.builder()
            .literal("string")
            .reference("string")
            .build())
        .valueLiteral("string")
        .valueReference("string")
        .values("string")
        .build()))
    .repeatConfig(EscalationPathRepeatConfigArgs.builder()
        .delayRepeatOnActivity(false)
        .repeatAfterSeconds(0)
        .build())
    .sequences(Map.of("string", EscalationPathSequencesArgs.builder()
        .nodes(EscalationPathSequencesNodeArgs.builder()
            .branch(EscalationPathSequencesNodeBranchArgs.builder()
                .if_(EscalationPathSequencesNodeBranchIfArgs.builder()
                    .priorityOneOfs("string")
                    .workingHoursActive("string")
                    .build())
                .then("string")
                .else_("string")
                .build())
            .delay(EscalationPathSequencesNodeDelayArgs.builder()
                .delayIntervalCondition("string")
                .delaySeconds(0)
                .delayWeekdayIntervalConfigId("string")
                .build())
            .escalationPath(EscalationPathSequencesNodeEscalationPathArgs.builder()
                .escalationPathId("string")
                .build())
            .id("string")
            .level(EscalationPathSequencesNodeLevelArgs.builder()
                .targets(EscalationPathSequencesNodeLevelTargetArgs.builder()
                    .id("string")
                    .type("string")
                    .urgency("string")
                    .scheduleMode("string")
                    .selectedRotaId("string")
                    .build())
                .ackMode("string")
                .retryConfig(EscalationPathSequencesNodeLevelRetryConfigArgs.builder()
                    .attempts(0)
                    .intervalSeconds(0)
                    .build())
                .roundRobinConfig(EscalationPathSequencesNodeLevelRoundRobinConfigArgs.builder()
                    .enabled(false)
                    .rotateAfterSeconds(0)
                    .build())
                .timeToAckIntervalCondition("string")
                .timeToAckSeconds(0)
                .timeToAckWeekdayIntervalConfigId("string")
                .build())
            .loop(EscalationPathSequencesNodeLoopArgs.builder()
                .backTo("string")
                .times(0)
                .build())
            .notifyChannel(EscalationPathSequencesNodeNotifyChannelArgs.builder()
                .targets(EscalationPathSequencesNodeNotifyChannelTargetArgs.builder()
                    .id("string")
                    .type("string")
                    .urgency("string")
                    .scheduleMode("string")
                    .selectedRotaId("string")
                    .build())
                .timeToAckIntervalCondition("string")
                .timeToAckSeconds(0)
                .timeToAckWeekdayIntervalConfigId("string")
                .build())
            .build())
        .build()))
    .start("string")
    .teamIds("string")
    .templateId("string")
    .unlockInDashboard(false)
    .workingHours(EscalationPathWorkingHourArgs.builder()
        .id("string")
        .name("string")
        .timezone("string")
        .weekdayIntervals(EscalationPathWorkingHourWeekdayIntervalArgs.builder()
            .endTime("string")
            .startTime("string")
            .weekday("string")
            .build())
        .build())
    .build());

    escalation_path_resource = incident.EscalationPath("escalationPathResource",
    kind="string",
    name="string",
    param_bindings={
        "string": {
            "array_values": [{
                "literal": "string",
                "reference": "string",
            }],
            "expression_ref": "string",
            "value": {
                "literal": "string",
                "reference": "string",
            },
            "value_literal": "string",
            "value_reference": "string",
            "values": ["string"],
        },
    },
    repeat_config={
        "delay_repeat_on_activity": False,
        "repeat_after_seconds": 0,
    },
    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": [{
                        "id": "string",
                        "type": "string",
                        "urgency": "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": [{
                        "id": "string",
                        "type": "string",
                        "urgency": "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",
    team_ids=["string"],
    template_id="string",
    unlock_in_dashboard=False,
    working_hours=[{
        "id": "string",
        "name": "string",
        "timezone": "string",
        "weekday_intervals": [{
            "end_time": "string",
            "start_time": "string",
            "weekday": "string",
        }],
    }])

    const escalationPathResource = new incident.EscalationPath("escalationPathResource", {
    kind: "string",
    name: "string",
    paramBindings: {
        string: {
            arrayValues: [{
                literal: "string",
                reference: "string",
            }],
            expressionRef: "string",
            value: {
                literal: "string",
                reference: "string",
            },
            valueLiteral: "string",
            valueReference: "string",
            values: ["string"],
        },
    },
    repeatConfig: {
        delayRepeatOnActivity: false,
        repeatAfterSeconds: 0,
    },
    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: [{
                        id: "string",
                        type: "string",
                        urgency: "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: [{
                        id: "string",
                        type: "string",
                        urgency: "string",
                        scheduleMode: "string",
                        selectedRotaId: "string",
                    }],
                    timeToAckIntervalCondition: "string",
                    timeToAckSeconds: 0,
                    timeToAckWeekdayIntervalConfigId: "string",
                },
            }],
        },
    },
    start: "string",
    teamIds: ["string"],
    templateId: "string",
    unlockInDashboard: false,
    workingHours: [{
        id: "string",
        name: "string",
        timezone: "string",
        weekdayIntervals: [{
            endTime: "string",
            startTime: "string",
            weekday: "string",
        }],
    }],
});

    type: incident:EscalationPath
properties:
    kind: string
    name: string
    paramBindings:
        string:
            arrayValues:
                - literal: string
                  reference: string
            expressionRef: string
            value:
                literal: string
                reference: string
            valueLiteral: string
            valueReference: string
            values:
                - 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:
                        - id: string
                          scheduleMode: string
                          selectedRotaId: string
                          type: string
                          urgency: string
                    timeToAckIntervalCondition: string
                    timeToAckSeconds: 0
                    timeToAckWeekdayIntervalConfigId: string
                  loop:
                    backTo: string
                    times: 0
                  notifyChannel:
                    targets:
                        - id: string
                          scheduleMode: string
                          selectedRotaId: string
                          type: string
                          urgency: string
                    timeToAckIntervalCondition: string
                    timeToAckSeconds: 0
                    timeToAckWeekdayIntervalConfigId: string
    start: string
    teamIds:
        - string
    templateId: string
    unlockInDashboard: false
    workingHours:
        - id: string
          name: string
          timezone: string
          weekdayIntervals:
            - endTime: string
              startTime: string
              weekday: string

    EscalationPath 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 EscalationPath resource accepts the following input properties:

    Kind string
    Whether this path carries its own nodes, or is built from an escalation path template. Possible values are: standalone, templated. Leave it out for a standalone path. A path is one kind for life, so changing this replaces it.
    Name string
    The name of this escalation path, for the user's reference.
    ParamBindings Dictionary<string, EscalationPathParamBindingsArgs>
    For a templated path, a value for each of the template's params, keyed by the param's name. Bindings are values, not references: a schedule param takes valueLiteral = <schedule id>.
    RepeatConfig EscalationPathRepeatConfig
    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, EscalationPathSequencesArgs>
    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. Required unless kind is templated.
    Start string
    The key of the sequence this escalation path begins with. Required unless kind is templated.
    TeamIds List<string>
    IDs of the teams that own this escalation path. This will automatically sync escalation paths with the right teams in Catalog. If you have an escalation paths attribute on your Teams, this attribute is required.
    TemplateId string
    The incident.EscalationPathTemplate to build this path from, required when kind is templated. A templated path takes its nodes, working hours and repeat config from the template, so set paramBindings in place of start and sequences. Switching to a different template is an in-place update.
    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<EscalationPathWorkingHour>
    The working hours for this escalation path. Absent for a templated path, which takes them from its template.
    Kind string
    Whether this path carries its own nodes, or is built from an escalation path template. Possible values are: standalone, templated. Leave it out for a standalone path. A path is one kind for life, so changing this replaces it.
    Name string
    The name of this escalation path, for the user's reference.
    ParamBindings map[string]EscalationPathParamBindingsArgs
    For a templated path, a value for each of the template's params, keyed by the param's name. Bindings are values, not references: a schedule param takes valueLiteral = <schedule id>.
    RepeatConfig EscalationPathRepeatConfigArgs
    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]EscalationPathSequencesArgs
    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. Required unless kind is templated.
    Start string
    The key of the sequence this escalation path begins with. Required unless kind is templated.
    TeamIds []string
    IDs of the teams that own this escalation path. This will automatically sync escalation paths with the right teams in Catalog. If you have an escalation paths attribute on your Teams, this attribute is required.
    TemplateId string
    The incident.EscalationPathTemplate to build this path from, required when kind is templated. A templated path takes its nodes, working hours and repeat config from the template, so set paramBindings in place of start and sequences. Switching to a different template is an in-place update.
    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 []EscalationPathWorkingHourArgs
    The working hours for this escalation path. Absent for a templated path, which takes them from its template.
    kind string
    Whether this path carries its own nodes, or is built from an escalation path template. Possible values are: standalone, templated. Leave it out for a standalone path. A path is one kind for life, so changing this replaces it.
    name string
    The name of this escalation path, for the user's reference.
    param_bindings map(object)
    For a templated path, a value for each of the template's params, keyed by the param's name. Bindings are values, not references: a schedule param takes valueLiteral = <schedule id>.
    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. Required unless kind is templated.
    start string
    The key of the sequence this escalation path begins with. Required unless kind is templated.
    team_ids list(string)
    IDs of the teams that own this escalation path. This will automatically sync escalation paths with the right teams in Catalog. If you have an escalation paths attribute on your Teams, this attribute is required.
    template_id string
    The incident.EscalationPathTemplate to build this path from, required when kind is templated. A templated path takes its nodes, working hours and repeat config from the template, so set paramBindings in place of start and sequences. Switching to a different template is an in-place update.
    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 escalation path. Absent for a templated path, which takes them from its template.
    kind String
    Whether this path carries its own nodes, or is built from an escalation path template. Possible values are: standalone, templated. Leave it out for a standalone path. A path is one kind for life, so changing this replaces it.
    name String
    The name of this escalation path, for the user's reference.
    paramBindings Map<String,EscalationPathParamBindingsArgs>
    For a templated path, a value for each of the template's params, keyed by the param's name. Bindings are values, not references: a schedule param takes valueLiteral = <schedule id>.
    repeatConfig EscalationPathRepeatConfig
    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,EscalationPathSequencesArgs>
    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. Required unless kind is templated.
    start String
    The key of the sequence this escalation path begins with. Required unless kind is templated.
    teamIds List<String>
    IDs of the teams that own this escalation path. This will automatically sync escalation paths with the right teams in Catalog. If you have an escalation paths attribute on your Teams, this attribute is required.
    templateId String
    The incident.EscalationPathTemplate to build this path from, required when kind is templated. A templated path takes its nodes, working hours and repeat config from the template, so set paramBindings in place of start and sequences. Switching to a different template is an in-place update.
    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<EscalationPathWorkingHour>
    The working hours for this escalation path. Absent for a templated path, which takes them from its template.
    kind string
    Whether this path carries its own nodes, or is built from an escalation path template. Possible values are: standalone, templated. Leave it out for a standalone path. A path is one kind for life, so changing this replaces it.
    name string
    The name of this escalation path, for the user's reference.
    paramBindings {[key: string]: EscalationPathParamBindingsArgs}
    For a templated path, a value for each of the template's params, keyed by the param's name. Bindings are values, not references: a schedule param takes valueLiteral = <schedule id>.
    repeatConfig EscalationPathRepeatConfig
    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]: EscalationPathSequencesArgs}
    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. Required unless kind is templated.
    start string
    The key of the sequence this escalation path begins with. Required unless kind is templated.
    teamIds string[]
    IDs of the teams that own this escalation path. This will automatically sync escalation paths with the right teams in Catalog. If you have an escalation paths attribute on your Teams, this attribute is required.
    templateId string
    The incident.EscalationPathTemplate to build this path from, required when kind is templated. A templated path takes its nodes, working hours and repeat config from the template, so set paramBindings in place of start and sequences. Switching to a different template is an in-place update.
    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 EscalationPathWorkingHour[]
    The working hours for this escalation path. Absent for a templated path, which takes them from its template.
    kind str
    Whether this path carries its own nodes, or is built from an escalation path template. Possible values are: standalone, templated. Leave it out for a standalone path. A path is one kind for life, so changing this replaces it.
    name str
    The name of this escalation path, for the user's reference.
    param_bindings Mapping[str, EscalationPathParamBindingsArgs]
    For a templated path, a value for each of the template's params, keyed by the param's name. Bindings are values, not references: a schedule param takes valueLiteral = <schedule id>.
    repeat_config EscalationPathRepeatConfigArgs
    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, EscalationPathSequencesArgs]
    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. Required unless kind is templated.
    start str
    The key of the sequence this escalation path begins with. Required unless kind is templated.
    team_ids Sequence[str]
    IDs of the teams that own this escalation path. This will automatically sync escalation paths with the right teams in Catalog. If you have an escalation paths attribute on your Teams, this attribute is required.
    template_id str
    The incident.EscalationPathTemplate to build this path from, required when kind is templated. A templated path takes its nodes, working hours and repeat config from the template, so set paramBindings in place of start and sequences. Switching to a different template is an in-place update.
    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[EscalationPathWorkingHourArgs]
    The working hours for this escalation path. Absent for a templated path, which takes them from its template.
    kind String
    Whether this path carries its own nodes, or is built from an escalation path template. Possible values are: standalone, templated. Leave it out for a standalone path. A path is one kind for life, so changing this replaces it.
    name String
    The name of this escalation path, for the user's reference.
    paramBindings Map<Property Map>
    For a templated path, a value for each of the template's params, keyed by the param's name. Bindings are values, not references: a schedule param takes valueLiteral = <schedule id>.
    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. Required unless kind is templated.
    start String
    The key of the sequence this escalation path begins with. Required unless kind is templated.
    teamIds List<String>
    IDs of the teams that own this escalation path. This will automatically sync escalation paths with the right teams in Catalog. If you have an escalation paths attribute on your Teams, this attribute is required.
    templateId String
    The incident.EscalationPathTemplate to build this path from, required when kind is templated. A templated path takes its nodes, working hours and repeat config from the template, so set paramBindings in place of start and sequences. Switching to a different template is an in-place update.
    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 escalation path. Absent for a templated path, which takes them from its template.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the EscalationPath 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 EscalationPath Resource

    Get an existing EscalationPath 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?: EscalationPathState, opts?: CustomResourceOptions): EscalationPath
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        kind: Optional[str] = None,
        name: Optional[str] = None,
        param_bindings: Optional[Mapping[str, EscalationPathParamBindingsArgs]] = None,
        repeat_config: Optional[EscalationPathRepeatConfigArgs] = None,
        sequences: Optional[Mapping[str, EscalationPathSequencesArgs]] = None,
        start: Optional[str] = None,
        team_ids: Optional[Sequence[str]] = None,
        template_id: Optional[str] = None,
        unlock_in_dashboard: Optional[bool] = None,
        working_hours: Optional[Sequence[EscalationPathWorkingHourArgs]] = None) -> EscalationPath
    func GetEscalationPath(ctx *Context, name string, id IDInput, state *EscalationPathState, opts ...ResourceOption) (*EscalationPath, error)
    public static EscalationPath Get(string name, Input<string> id, EscalationPathState? state, CustomResourceOptions? opts = null)
    public static EscalationPath get(String name, Output<String> id, EscalationPathState state, CustomResourceOptions options)
    resources:  _:    type: incident:EscalationPath    get:      id: ${id}
    import {
  to = incident_escalation_path.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:
    Kind string
    Whether this path carries its own nodes, or is built from an escalation path template. Possible values are: standalone, templated. Leave it out for a standalone path. A path is one kind for life, so changing this replaces it.
    Name string
    The name of this escalation path, for the user's reference.
    ParamBindings Dictionary<string, EscalationPathParamBindingsArgs>
    For a templated path, a value for each of the template's params, keyed by the param's name. Bindings are values, not references: a schedule param takes valueLiteral = <schedule id>.
    RepeatConfig EscalationPathRepeatConfig
    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, EscalationPathSequencesArgs>
    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. Required unless kind is templated.
    Start string
    The key of the sequence this escalation path begins with. Required unless kind is templated.
    TeamIds List<string>
    IDs of the teams that own this escalation path. This will automatically sync escalation paths with the right teams in Catalog. If you have an escalation paths attribute on your Teams, this attribute is required.
    TemplateId string
    The incident.EscalationPathTemplate to build this path from, required when kind is templated. A templated path takes its nodes, working hours and repeat config from the template, so set paramBindings in place of start and sequences. Switching to a different template is an in-place update.
    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<EscalationPathWorkingHour>
    The working hours for this escalation path. Absent for a templated path, which takes them from its template.
    Kind string
    Whether this path carries its own nodes, or is built from an escalation path template. Possible values are: standalone, templated. Leave it out for a standalone path. A path is one kind for life, so changing this replaces it.
    Name string
    The name of this escalation path, for the user's reference.
    ParamBindings map[string]EscalationPathParamBindingsArgs
    For a templated path, a value for each of the template's params, keyed by the param's name. Bindings are values, not references: a schedule param takes valueLiteral = <schedule id>.
    RepeatConfig EscalationPathRepeatConfigArgs
    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]EscalationPathSequencesArgs
    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. Required unless kind is templated.
    Start string
    The key of the sequence this escalation path begins with. Required unless kind is templated.
    TeamIds []string
    IDs of the teams that own this escalation path. This will automatically sync escalation paths with the right teams in Catalog. If you have an escalation paths attribute on your Teams, this attribute is required.
    TemplateId string
    The incident.EscalationPathTemplate to build this path from, required when kind is templated. A templated path takes its nodes, working hours and repeat config from the template, so set paramBindings in place of start and sequences. Switching to a different template is an in-place update.
    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 []EscalationPathWorkingHourArgs
    The working hours for this escalation path. Absent for a templated path, which takes them from its template.
    kind string
    Whether this path carries its own nodes, or is built from an escalation path template. Possible values are: standalone, templated. Leave it out for a standalone path. A path is one kind for life, so changing this replaces it.
    name string
    The name of this escalation path, for the user's reference.
    param_bindings map(object)
    For a templated path, a value for each of the template's params, keyed by the param's name. Bindings are values, not references: a schedule param takes valueLiteral = <schedule id>.
    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. Required unless kind is templated.
    start string
    The key of the sequence this escalation path begins with. Required unless kind is templated.
    team_ids list(string)
    IDs of the teams that own this escalation path. This will automatically sync escalation paths with the right teams in Catalog. If you have an escalation paths attribute on your Teams, this attribute is required.
    template_id string
    The incident.EscalationPathTemplate to build this path from, required when kind is templated. A templated path takes its nodes, working hours and repeat config from the template, so set paramBindings in place of start and sequences. Switching to a different template is an in-place update.
    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 escalation path. Absent for a templated path, which takes them from its template.
    kind String
    Whether this path carries its own nodes, or is built from an escalation path template. Possible values are: standalone, templated. Leave it out for a standalone path. A path is one kind for life, so changing this replaces it.
    name String
    The name of this escalation path, for the user's reference.
    paramBindings Map<String,EscalationPathParamBindingsArgs>
    For a templated path, a value for each of the template's params, keyed by the param's name. Bindings are values, not references: a schedule param takes valueLiteral = <schedule id>.
    repeatConfig EscalationPathRepeatConfig
    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,EscalationPathSequencesArgs>
    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. Required unless kind is templated.
    start String
    The key of the sequence this escalation path begins with. Required unless kind is templated.
    teamIds List<String>
    IDs of the teams that own this escalation path. This will automatically sync escalation paths with the right teams in Catalog. If you have an escalation paths attribute on your Teams, this attribute is required.
    templateId String
    The incident.EscalationPathTemplate to build this path from, required when kind is templated. A templated path takes its nodes, working hours and repeat config from the template, so set paramBindings in place of start and sequences. Switching to a different template is an in-place update.
    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<EscalationPathWorkingHour>
    The working hours for this escalation path. Absent for a templated path, which takes them from its template.
    kind string
    Whether this path carries its own nodes, or is built from an escalation path template. Possible values are: standalone, templated. Leave it out for a standalone path. A path is one kind for life, so changing this replaces it.
    name string
    The name of this escalation path, for the user's reference.
    paramBindings {[key: string]: EscalationPathParamBindingsArgs}
    For a templated path, a value for each of the template's params, keyed by the param's name. Bindings are values, not references: a schedule param takes valueLiteral = <schedule id>.
    repeatConfig EscalationPathRepeatConfig
    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]: EscalationPathSequencesArgs}
    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. Required unless kind is templated.
    start string
    The key of the sequence this escalation path begins with. Required unless kind is templated.
    teamIds string[]
    IDs of the teams that own this escalation path. This will automatically sync escalation paths with the right teams in Catalog. If you have an escalation paths attribute on your Teams, this attribute is required.
    templateId string
    The incident.EscalationPathTemplate to build this path from, required when kind is templated. A templated path takes its nodes, working hours and repeat config from the template, so set paramBindings in place of start and sequences. Switching to a different template is an in-place update.
    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 EscalationPathWorkingHour[]
    The working hours for this escalation path. Absent for a templated path, which takes them from its template.
    kind str
    Whether this path carries its own nodes, or is built from an escalation path template. Possible values are: standalone, templated. Leave it out for a standalone path. A path is one kind for life, so changing this replaces it.
    name str
    The name of this escalation path, for the user's reference.
    param_bindings Mapping[str, EscalationPathParamBindingsArgs]
    For a templated path, a value for each of the template's params, keyed by the param's name. Bindings are values, not references: a schedule param takes valueLiteral = <schedule id>.
    repeat_config EscalationPathRepeatConfigArgs
    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, EscalationPathSequencesArgs]
    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. Required unless kind is templated.
    start str
    The key of the sequence this escalation path begins with. Required unless kind is templated.
    team_ids Sequence[str]
    IDs of the teams that own this escalation path. This will automatically sync escalation paths with the right teams in Catalog. If you have an escalation paths attribute on your Teams, this attribute is required.
    template_id str
    The incident.EscalationPathTemplate to build this path from, required when kind is templated. A templated path takes its nodes, working hours and repeat config from the template, so set paramBindings in place of start and sequences. Switching to a different template is an in-place update.
    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[EscalationPathWorkingHourArgs]
    The working hours for this escalation path. Absent for a templated path, which takes them from its template.
    kind String
    Whether this path carries its own nodes, or is built from an escalation path template. Possible values are: standalone, templated. Leave it out for a standalone path. A path is one kind for life, so changing this replaces it.
    name String
    The name of this escalation path, for the user's reference.
    paramBindings Map<Property Map>
    For a templated path, a value for each of the template's params, keyed by the param's name. Bindings are values, not references: a schedule param takes valueLiteral = <schedule id>.
    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. Required unless kind is templated.
    start String
    The key of the sequence this escalation path begins with. Required unless kind is templated.
    teamIds List<String>
    IDs of the teams that own this escalation path. This will automatically sync escalation paths with the right teams in Catalog. If you have an escalation paths attribute on your Teams, this attribute is required.
    templateId String
    The incident.EscalationPathTemplate to build this path from, required when kind is templated. A templated path takes its nodes, working hours and repeat config from the template, so set paramBindings in place of start and sequences. Switching to a different template is an in-place update.
    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 escalation path. Absent for a templated path, which takes them from its template.

    Supporting Types

    EscalationPathParamBindings, EscalationPathParamBindingsArgs

    ArrayValues List<EscalationPathParamBindingsArrayValue>
    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 EscalationPathParamBindingsValue
    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 []EscalationPathParamBindingsArrayValue
    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 EscalationPathParamBindingsValue
    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<EscalationPathParamBindingsArrayValue>
    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 EscalationPathParamBindingsValue
    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 EscalationPathParamBindingsArrayValue[]
    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 EscalationPathParamBindingsValue
    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[EscalationPathParamBindingsArrayValue]
    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 EscalationPathParamBindingsValue
    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.

    EscalationPathParamBindingsArrayValue, EscalationPathParamBindingsArrayValueArgs

    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

    EscalationPathParamBindingsValue, EscalationPathParamBindingsValueArgs

    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

    EscalationPathRepeatConfig, EscalationPathRepeatConfigArgs

    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.

    EscalationPathSequences, EscalationPathSequencesArgs

    Nodes List<EscalationPathSequencesNode>
    The nodes in this sequence, in the order they run.
    Nodes []EscalationPathSequencesNode
    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<EscalationPathSequencesNode>
    The nodes in this sequence, in the order they run.
    nodes EscalationPathSequencesNode[]
    The nodes in this sequence, in the order they run.
    nodes Sequence[EscalationPathSequencesNode]
    The nodes in this sequence, in the order they run.
    nodes List<Property Map>
    The nodes in this sequence, in the order they run.

    EscalationPathSequencesNode, EscalationPathSequencesNodeArgs

    Branch EscalationPathSequencesNodeBranch
    Send the escalation down one of two sequences, depending on what if tests. A branch must be the last node in its sequence.
    Delay EscalationPathSequencesNodeDelay
    EscalationPath EscalationPathSequencesNodeEscalationPath
    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 EscalationPathSequencesNodeLevel
    Loop EscalationPathSequencesNodeLoop
    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 EscalationPathSequencesNodeNotifyChannel
    Branch EscalationPathSequencesNodeBranch
    Send the escalation down one of two sequences, depending on what if tests. A branch must be the last node in its sequence.
    Delay EscalationPathSequencesNodeDelay
    EscalationPath EscalationPathSequencesNodeEscalationPath
    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 EscalationPathSequencesNodeLevel
    Loop EscalationPathSequencesNodeLoop
    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 EscalationPathSequencesNodeNotifyChannel
    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 EscalationPathSequencesNodeBranch
    Send the escalation down one of two sequences, depending on what if tests. A branch must be the last node in its sequence.
    delay EscalationPathSequencesNodeDelay
    escalationPath EscalationPathSequencesNodeEscalationPath
    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 EscalationPathSequencesNodeLevel
    loop EscalationPathSequencesNodeLoop
    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 EscalationPathSequencesNodeNotifyChannel
    branch EscalationPathSequencesNodeBranch
    Send the escalation down one of two sequences, depending on what if tests. A branch must be the last node in its sequence.
    delay EscalationPathSequencesNodeDelay
    escalationPath EscalationPathSequencesNodeEscalationPath
    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 EscalationPathSequencesNodeLevel
    loop EscalationPathSequencesNodeLoop
    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 EscalationPathSequencesNodeNotifyChannel
    branch EscalationPathSequencesNodeBranch
    Send the escalation down one of two sequences, depending on what if tests. A branch must be the last node in its sequence.
    delay EscalationPathSequencesNodeDelay
    escalation_path EscalationPathSequencesNodeEscalationPath
    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 EscalationPathSequencesNodeLevel
    loop EscalationPathSequencesNodeLoop
    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 EscalationPathSequencesNodeNotifyChannel
    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

    EscalationPathSequencesNodeBranch, EscalationPathSequencesNodeBranchArgs

    If EscalationPathSequencesNodeBranchIf
    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 EscalationPathSequencesNodeBranchIf
    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_ EscalationPathSequencesNodeBranchIf
    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 EscalationPathSequencesNodeBranchIf
    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_ EscalationPathSequencesNodeBranchIf
    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.

    EscalationPathSequencesNodeBranchIf, EscalationPathSequencesNodeBranchIfArgs

    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.

    EscalationPathSequencesNodeDelay, EscalationPathSequencesNodeDelayArgs

    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

    EscalationPathSequencesNodeEscalationPath, EscalationPathSequencesNodeEscalationPathArgs

    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

    EscalationPathSequencesNodeLevel, EscalationPathSequencesNodeLevelArgs

    Targets List<EscalationPathSequencesNodeLevelTarget>
    The targets (users or schedules) for this level
    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 EscalationPathSequencesNodeLevelRetryConfig
    RoundRobinConfig EscalationPathSequencesNodeLevelRoundRobinConfig
    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 []EscalationPathSequencesNodeLevelTarget
    The targets (users or schedules) for this level
    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 EscalationPathSequencesNodeLevelRetryConfig
    RoundRobinConfig EscalationPathSequencesNodeLevelRoundRobinConfig
    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) for this level
    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<EscalationPathSequencesNodeLevelTarget>
    The targets (users or schedules) for this level
    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 EscalationPathSequencesNodeLevelRetryConfig
    roundRobinConfig EscalationPathSequencesNodeLevelRoundRobinConfig
    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 EscalationPathSequencesNodeLevelTarget[]
    The targets (users or schedules) for this level
    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 EscalationPathSequencesNodeLevelRetryConfig
    roundRobinConfig EscalationPathSequencesNodeLevelRoundRobinConfig
    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[EscalationPathSequencesNodeLevelTarget]
    The targets (users or schedules) for this level
    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 EscalationPathSequencesNodeLevelRetryConfig
    round_robin_config EscalationPathSequencesNodeLevelRoundRobinConfig
    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) for this level
    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

    EscalationPathSequencesNodeLevelRetryConfig, EscalationPathSequencesNodeLevelRetryConfigArgs

    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).

    EscalationPathSequencesNodeLevelRoundRobinConfig, EscalationPathSequencesNodeLevelRoundRobinConfigArgs

    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.

    EscalationPathSequencesNodeLevelTarget, EscalationPathSequencesNodeLevelTargetArgs

    Id string
    Uniquely identifies an entity of this type
    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.
    ScheduleMode string
    Only set for schedule targets, this specifies which users to fetch from the schedule. Use currentlyoncall to notify whoever is on call right now across the schedule, allusers to notify every user attached to the schedule, or allusersforrota / currentlyoncallforrota / nextoncallforrota to scope to a specific rota (in which case selectedrotaid is required). nextoncall notifies whoever is next on call across the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    SelectedRotaId string
    For schedule targets, identifies which rota on the schedule the schedulemode applies to. Required when schedulemode is allusersforrota, currentlyoncallforrota, or nextoncallforrota; must be omitted for other schedulemode values.
    Id string
    Uniquely identifies an entity of this type
    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.
    ScheduleMode string
    Only set for schedule targets, this specifies which users to fetch from the schedule. Use currentlyoncall to notify whoever is on call right now across the schedule, allusers to notify every user attached to the schedule, or allusersforrota / currentlyoncallforrota / nextoncallforrota to scope to a specific rota (in which case selectedrotaid is required). nextoncall notifies whoever is next on call across the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    SelectedRotaId string
    For schedule targets, identifies which rota on the schedule the schedulemode applies to. Required when schedulemode is allusersforrota, currentlyoncallforrota, or nextoncallforrota; must be omitted for other schedulemode values.
    id string
    Uniquely identifies an entity of this type
    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.
    schedule_mode string
    Only set for schedule targets, this specifies which users to fetch from the schedule. Use currentlyoncall to notify whoever is on call right now across the schedule, allusers to notify every user attached to the schedule, or allusersforrota / currentlyoncallforrota / nextoncallforrota to scope to a specific rota (in which case selectedrotaid is required). nextoncall notifies whoever is next on call across the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    selected_rota_id string
    For schedule targets, identifies which rota on the schedule the schedulemode applies to. Required when schedulemode is allusersforrota, currentlyoncallforrota, or nextoncallforrota; must be omitted for other schedulemode values.
    id String
    Uniquely identifies an entity of this type
    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.
    scheduleMode String
    Only set for schedule targets, this specifies which users to fetch from the schedule. Use currentlyoncall to notify whoever is on call right now across the schedule, allusers to notify every user attached to the schedule, or allusersforrota / currentlyoncallforrota / nextoncallforrota to scope to a specific rota (in which case selectedrotaid is required). nextoncall notifies whoever is next on call across the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    selectedRotaId String
    For schedule targets, identifies which rota on the schedule the schedulemode applies to. Required when schedulemode is allusersforrota, currentlyoncallforrota, or nextoncallforrota; must be omitted for other schedulemode values.
    id string
    Uniquely identifies an entity of this type
    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.
    scheduleMode string
    Only set for schedule targets, this specifies which users to fetch from the schedule. Use currentlyoncall to notify whoever is on call right now across the schedule, allusers to notify every user attached to the schedule, or allusersforrota / currentlyoncallforrota / nextoncallforrota to scope to a specific rota (in which case selectedrotaid is required). nextoncall notifies whoever is next on call across the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    selectedRotaId string
    For schedule targets, identifies which rota on the schedule the schedulemode applies to. Required when schedulemode is allusersforrota, currentlyoncallforrota, or nextoncallforrota; must be omitted for other schedulemode values.
    id str
    Uniquely identifies an entity of this type
    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.
    schedule_mode str
    Only set for schedule targets, this specifies which users to fetch from the schedule. Use currentlyoncall to notify whoever is on call right now across the schedule, allusers to notify every user attached to the schedule, or allusersforrota / currentlyoncallforrota / nextoncallforrota to scope to a specific rota (in which case selectedrotaid is required). nextoncall notifies whoever is next on call across the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    selected_rota_id str
    For schedule targets, identifies which rota on the schedule the schedulemode applies to. Required when schedulemode is allusersforrota, currentlyoncallforrota, or nextoncallforrota; must be omitted for other schedulemode values.
    id String
    Uniquely identifies an entity of this type
    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.
    scheduleMode String
    Only set for schedule targets, this specifies which users to fetch from the schedule. Use currentlyoncall to notify whoever is on call right now across the schedule, allusers to notify every user attached to the schedule, or allusersforrota / currentlyoncallforrota / nextoncallforrota to scope to a specific rota (in which case selectedrotaid is required). nextoncall notifies whoever is next on call across the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    selectedRotaId String
    For schedule targets, identifies which rota on the schedule the schedulemode applies to. Required when schedulemode is allusersforrota, currentlyoncallforrota, or nextoncallforrota; must be omitted for other schedulemode values.

    EscalationPathSequencesNodeLoop, EscalationPathSequencesNodeLoopArgs

    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

    EscalationPathSequencesNodeNotifyChannel, EscalationPathSequencesNodeNotifyChannelArgs

    Targets List<EscalationPathSequencesNodeNotifyChannelTarget>
    The targets (Slack channels) for this level
    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 []EscalationPathSequencesNodeNotifyChannelTarget
    The targets (Slack channels) for this level
    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 targets (Slack channels) for this level
    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<EscalationPathSequencesNodeNotifyChannelTarget>
    The targets (Slack channels) for this level
    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 EscalationPathSequencesNodeNotifyChannelTarget[]
    The targets (Slack channels) for this level
    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[EscalationPathSequencesNodeNotifyChannelTarget]
    The targets (Slack channels) for this level
    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 targets (Slack channels) for this level
    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

    EscalationPathSequencesNodeNotifyChannelTarget, EscalationPathSequencesNodeNotifyChannelTargetArgs

    Id string
    Uniquely identifies an entity of this type
    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.
    ScheduleMode string
    Only set for schedule targets, this specifies which users to fetch from the schedule. Use currentlyoncall to notify whoever is on call right now across the schedule, allusers to notify every user attached to the schedule, or allusersforrota / currentlyoncallforrota / nextoncallforrota to scope to a specific rota (in which case selectedrotaid is required). nextoncall notifies whoever is next on call across the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    SelectedRotaId string
    For schedule targets, identifies which rota on the schedule the schedulemode applies to. Required when schedulemode is allusersforrota, currentlyoncallforrota, or nextoncallforrota; must be omitted for other schedulemode values.
    Id string
    Uniquely identifies an entity of this type
    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.
    ScheduleMode string
    Only set for schedule targets, this specifies which users to fetch from the schedule. Use currentlyoncall to notify whoever is on call right now across the schedule, allusers to notify every user attached to the schedule, or allusersforrota / currentlyoncallforrota / nextoncallforrota to scope to a specific rota (in which case selectedrotaid is required). nextoncall notifies whoever is next on call across the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    SelectedRotaId string
    For schedule targets, identifies which rota on the schedule the schedulemode applies to. Required when schedulemode is allusersforrota, currentlyoncallforrota, or nextoncallforrota; must be omitted for other schedulemode values.
    id string
    Uniquely identifies an entity of this type
    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.
    schedule_mode string
    Only set for schedule targets, this specifies which users to fetch from the schedule. Use currentlyoncall to notify whoever is on call right now across the schedule, allusers to notify every user attached to the schedule, or allusersforrota / currentlyoncallforrota / nextoncallforrota to scope to a specific rota (in which case selectedrotaid is required). nextoncall notifies whoever is next on call across the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    selected_rota_id string
    For schedule targets, identifies which rota on the schedule the schedulemode applies to. Required when schedulemode is allusersforrota, currentlyoncallforrota, or nextoncallforrota; must be omitted for other schedulemode values.
    id String
    Uniquely identifies an entity of this type
    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.
    scheduleMode String
    Only set for schedule targets, this specifies which users to fetch from the schedule. Use currentlyoncall to notify whoever is on call right now across the schedule, allusers to notify every user attached to the schedule, or allusersforrota / currentlyoncallforrota / nextoncallforrota to scope to a specific rota (in which case selectedrotaid is required). nextoncall notifies whoever is next on call across the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    selectedRotaId String
    For schedule targets, identifies which rota on the schedule the schedulemode applies to. Required when schedulemode is allusersforrota, currentlyoncallforrota, or nextoncallforrota; must be omitted for other schedulemode values.
    id string
    Uniquely identifies an entity of this type
    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.
    scheduleMode string
    Only set for schedule targets, this specifies which users to fetch from the schedule. Use currentlyoncall to notify whoever is on call right now across the schedule, allusers to notify every user attached to the schedule, or allusersforrota / currentlyoncallforrota / nextoncallforrota to scope to a specific rota (in which case selectedrotaid is required). nextoncall notifies whoever is next on call across the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    selectedRotaId string
    For schedule targets, identifies which rota on the schedule the schedulemode applies to. Required when schedulemode is allusersforrota, currentlyoncallforrota, or nextoncallforrota; must be omitted for other schedulemode values.
    id str
    Uniquely identifies an entity of this type
    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.
    schedule_mode str
    Only set for schedule targets, this specifies which users to fetch from the schedule. Use currentlyoncall to notify whoever is on call right now across the schedule, allusers to notify every user attached to the schedule, or allusersforrota / currentlyoncallforrota / nextoncallforrota to scope to a specific rota (in which case selectedrotaid is required). nextoncall notifies whoever is next on call across the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    selected_rota_id str
    For schedule targets, identifies which rota on the schedule the schedulemode applies to. Required when schedulemode is allusersforrota, currentlyoncallforrota, or nextoncallforrota; must be omitted for other schedulemode values.
    id String
    Uniquely identifies an entity of this type
    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.
    scheduleMode String
    Only set for schedule targets, this specifies which users to fetch from the schedule. Use currentlyoncall to notify whoever is on call right now across the schedule, allusers to notify every user attached to the schedule, or allusersforrota / currentlyoncallforrota / nextoncallforrota to scope to a specific rota (in which case selectedrotaid is required). nextoncall notifies whoever is next on call across the schedule. Possible values are: currentlyOnCall, allUsersForRota, allUsers, currentlyOnCallForRota, nextOnCallForRota, nextOnCall.
    selectedRotaId String
    For schedule targets, identifies which rota on the schedule the schedulemode applies to. Required when schedulemode is allusersforrota, currentlyoncallforrota, or nextoncallforrota; must be omitted for other schedulemode values.

    EscalationPathWorkingHour, EscalationPathWorkingHourArgs

    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<EscalationPathWorkingHourWeekdayInterval>
    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 []EscalationPathWorkingHourWeekdayInterval
    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<EscalationPathWorkingHourWeekdayInterval>
    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 EscalationPathWorkingHourWeekdayInterval[]
    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[EscalationPathWorkingHourWeekdayInterval]
    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>

    EscalationPathWorkingHourWeekdayInterval, EscalationPathWorkingHourWeekdayIntervalArgs

    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.

    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.3.1
    published on Thursday, Oct 8, 2026 by incident-io
    Schema (JSON)
    incident-io/pulumi-incident

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial