1. Packages
  2. Packages
  3. Incident Provider
  4. API Docs
  5. EscalationPath
Viewing docs for incident 5.35.2
published on Wednesday, May 6, 2026 by incident-io
Viewing docs for incident 5.35.2
published on Wednesday, May 6, 2026 by incident-io

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
    import * as incident from "@pulumi/incident";
    
    // This is the primary schedule that receives pages in working hours.
    const primaryOnCall = new incident.Schedule("primary_on_call", {
        name: "Primary",
        timezone: "Europe/London",
        rotations: [{
            id: "primary",
            name: "Primary",
            versions: [{
                handoverStartAt: "2024-05-01T12:00:00Z",
                users: [],
                layers: [{
                    id: "primary",
                    name: "Primary",
                }],
                handovers: [{
                    intervalType: "daily",
                    interval: 1,
                }],
            }],
        }],
    });
    // If in working hours, send high-urgency alerts. Otherwise use low-urgency.
    const urgentSupport = new incident.EscalationPath("urgent_support", {
        name: "Urgent support",
        paths: [{
            id: "start",
            type: "if_else",
            ifElse: {
                conditions: [{
                    operation: "is_active",
                    paramBindings: [],
                    subject: "escalation.working_hours[\"UK\"]",
                }],
                thenPaths: [
                    {
                        type: "level",
                        level: {
                            targets: [{
                                type: "schedule",
                                id: primaryOnCall.id,
                                urgency: "high",
                            }],
                            timeToAckSeconds: 300,
                        },
                    },
                    {
                        type: "delay",
                        delay: {
                            delaySeconds: 120,
                        },
                    },
                    {
                        type: "repeat",
                        repeat: {
                            repeatTimes: 3,
                            toNode: "start",
                        },
                    },
                ],
                elsePaths: [{
                    type: "level",
                    level: {
                        targets: [{
                            type: "schedule",
                            id: primaryOnCall.id,
                            urgency: "low",
                        }],
                        timeToAckSeconds: 300,
                    },
                }],
            },
        }],
        workingHours: [{
            id: "UK",
            name: "UK",
            timezone: "Europe/London",
            weekdayIntervals: [{
                weekday: "monday",
                startTime: "09:00",
                endTime: "17:00",
            }],
        }],
        teamIds: [
            "01FCNDV6P870EA6S7TK1DSYD00",
            "01FCNDV6P870EA6S7TK1DSYD01",
        ],
    });
    
    import pulumi
    import pulumi_incident as incident
    
    # This is the primary schedule that receives pages in working hours.
    primary_on_call = incident.Schedule("primary_on_call",
        name="Primary",
        timezone="Europe/London",
        rotations=[{
            "id": "primary",
            "name": "Primary",
            "versions": [{
                "handover_start_at": "2024-05-01T12:00:00Z",
                "users": [],
                "layers": [{
                    "id": "primary",
                    "name": "Primary",
                }],
                "handovers": [{
                    "interval_type": "daily",
                    "interval": 1,
                }],
            }],
        }])
    # If in working hours, send high-urgency alerts. Otherwise use low-urgency.
    urgent_support = incident.EscalationPath("urgent_support",
        name="Urgent support",
        paths=[{
            "id": "start",
            "type": "if_else",
            "if_else": {
                "conditions": [{
                    "operation": "is_active",
                    "param_bindings": [],
                    "subject": "escalation.working_hours[\"UK\"]",
                }],
                "then_paths": [
                    {
                        "type": "level",
                        "level": {
                            "targets": [{
                                "type": "schedule",
                                "id": primary_on_call.id,
                                "urgency": "high",
                            }],
                            "time_to_ack_seconds": 300,
                        },
                    },
                    {
                        "type": "delay",
                        "delay": {
                            "delay_seconds": 120,
                        },
                    },
                    {
                        "type": "repeat",
                        "repeat": {
                            "repeat_times": 3,
                            "to_node": "start",
                        },
                    },
                ],
                "else_paths": [{
                    "type": "level",
                    "level": {
                        "targets": [{
                            "type": "schedule",
                            "id": primary_on_call.id,
                            "urgency": "low",
                        }],
                        "time_to_ack_seconds": 300,
                    },
                }],
            },
        }],
        working_hours=[{
            "id": "UK",
            "name": "UK",
            "timezone": "Europe/London",
            "weekday_intervals": [{
                "weekday": "monday",
                "start_time": "09:00",
                "end_time": "17:00",
            }],
        }],
        team_ids=[
            "01FCNDV6P870EA6S7TK1DSYD00",
            "01FCNDV6P870EA6S7TK1DSYD01",
        ])
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-terraform-provider/sdks/go/incident/v5/incident"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		// This is the primary schedule that receives pages in working hours.
    		primaryOnCall, err := incident.NewSchedule(ctx, "primary_on_call", &incident.ScheduleArgs{
    			Name:     pulumi.String("Primary"),
    			Timezone: pulumi.String("Europe/London"),
    			Rotations: incident.ScheduleRotationArray{
    				&incident.ScheduleRotationArgs{
    					Id:   pulumi.String("primary"),
    					Name: pulumi.String("Primary"),
    					Versions: incident.ScheduleRotationVersionArray{
    						&incident.ScheduleRotationVersionArgs{
    							HandoverStartAt: pulumi.String("2024-05-01T12:00:00Z"),
    							Users:           pulumi.StringArray{},
    							Layers: incident.ScheduleRotationVersionLayerArray{
    								&incident.ScheduleRotationVersionLayerArgs{
    									Id:   pulumi.String("primary"),
    									Name: pulumi.String("Primary"),
    								},
    							},
    							Handovers: incident.ScheduleRotationVersionHandoverArray{
    								&incident.ScheduleRotationVersionHandoverArgs{
    									IntervalType: pulumi.String("daily"),
    									Interval:     pulumi.Float64(1),
    								},
    							},
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		// If in working hours, send high-urgency alerts. Otherwise use low-urgency.
    		_, err = incident.NewEscalationPath(ctx, "urgent_support", &incident.EscalationPathArgs{
    			Name: pulumi.String("Urgent support"),
    			Paths: incident.EscalationPathPathArray{
    				&incident.EscalationPathPathArgs{
    					Id:   pulumi.String("start"),
    					Type: pulumi.String("if_else"),
    					IfElse: &incident.EscalationPathPathIfElseArgs{
    						Conditions: incident.EscalationPathPathIfElseConditionArray{
    							&incident.EscalationPathPathIfElseConditionArgs{
    								Operation:     pulumi.String("is_active"),
    								ParamBindings: incident.EscalationPathPathIfElseConditionParamBindingArray{},
    								Subject:       pulumi.String("escalation.working_hours[\"UK\"]"),
    							},
    						},
    						ThenPaths: incident.EscalationPathPathIfElseThenPathArray{
    							&incident.EscalationPathPathIfElseThenPathArgs{
    								Type: pulumi.String("level"),
    								Level: &incident.EscalationPathPathIfElseThenPathLevelArgs{
    									Targets: incident.EscalationPathPathIfElseThenPathLevelTargetArray{
    										&incident.EscalationPathPathIfElseThenPathLevelTargetArgs{
    											Type:    pulumi.String("schedule"),
    											Id:      primaryOnCall.ID(),
    											Urgency: pulumi.String("high"),
    										},
    									},
    									TimeToAckSeconds: pulumi.Float64(300),
    								},
    							},
    							&incident.EscalationPathPathIfElseThenPathArgs{
    								Type: pulumi.String("delay"),
    								Delay: &incident.EscalationPathPathIfElseThenPathDelayArgs{
    									DelaySeconds: pulumi.Float64(120),
    								},
    							},
    							&incident.EscalationPathPathIfElseThenPathArgs{
    								Type: pulumi.String("repeat"),
    								Repeat: &incident.EscalationPathPathIfElseThenPathRepeatArgs{
    									RepeatTimes: pulumi.Float64(3),
    									ToNode:      pulumi.String("start"),
    								},
    							},
    						},
    						ElsePaths: incident.EscalationPathPathIfElseElsePathArray{
    							&incident.EscalationPathPathIfElseElsePathArgs{
    								Type: pulumi.String("level"),
    								Level: &incident.EscalationPathPathIfElseElsePathLevelArgs{
    									Targets: incident.EscalationPathPathIfElseElsePathLevelTargetArray{
    										&incident.EscalationPathPathIfElseElsePathLevelTargetArgs{
    											Type:    pulumi.String("schedule"),
    											Id:      primaryOnCall.ID(),
    											Urgency: pulumi.String("low"),
    										},
    									},
    									TimeToAckSeconds: pulumi.Float64(300),
    								},
    							},
    						},
    					},
    				},
    			},
    			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"),
    						},
    					},
    				},
    			},
    			TeamIds: pulumi.StringArray{
    				pulumi.String("01FCNDV6P870EA6S7TK1DSYD00"),
    				pulumi.String("01FCNDV6P870EA6S7TK1DSYD01"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Incident = Pulumi.Incident;
    
    return await Deployment.RunAsync(() => 
    {
        // This is the primary schedule that receives pages in working hours.
        var primaryOnCall = new Incident.Schedule("primary_on_call", new()
        {
            Name = "Primary",
            Timezone = "Europe/London",
            Rotations = new[]
            {
                new Incident.Inputs.ScheduleRotationArgs
                {
                    Id = "primary",
                    Name = "Primary",
                    Versions = new[]
                    {
                        new Incident.Inputs.ScheduleRotationVersionArgs
                        {
                            HandoverStartAt = "2024-05-01T12:00:00Z",
                            Users = new() { },
                            Layers = new[]
                            {
                                new Incident.Inputs.ScheduleRotationVersionLayerArgs
                                {
                                    Id = "primary",
                                    Name = "Primary",
                                },
                            },
                            Handovers = new[]
                            {
                                new Incident.Inputs.ScheduleRotationVersionHandoverArgs
                                {
                                    IntervalType = "daily",
                                    Interval = 1,
                                },
                            },
                        },
                    },
                },
            },
        });
    
        // If in working hours, send high-urgency alerts. Otherwise use low-urgency.
        var urgentSupport = new Incident.EscalationPath("urgent_support", new()
        {
            Name = "Urgent support",
            Paths = new[]
            {
                new Incident.Inputs.EscalationPathPathArgs
                {
                    Id = "start",
                    Type = "if_else",
                    IfElse = new Incident.Inputs.EscalationPathPathIfElseArgs
                    {
                        Conditions = new[]
                        {
                            new Incident.Inputs.EscalationPathPathIfElseConditionArgs
                            {
                                Operation = "is_active",
                                ParamBindings = new() { },
                                Subject = "escalation.working_hours[\"UK\"]",
                            },
                        },
                        ThenPaths = new[]
                        {
                            new Incident.Inputs.EscalationPathPathIfElseThenPathArgs
                            {
                                Type = "level",
                                Level = new Incident.Inputs.EscalationPathPathIfElseThenPathLevelArgs
                                {
                                    Targets = new[]
                                    {
                                        new Incident.Inputs.EscalationPathPathIfElseThenPathLevelTargetArgs
                                        {
                                            Type = "schedule",
                                            Id = primaryOnCall.Id,
                                            Urgency = "high",
                                        },
                                    },
                                    TimeToAckSeconds = 300,
                                },
                            },
                            new Incident.Inputs.EscalationPathPathIfElseThenPathArgs
                            {
                                Type = "delay",
                                Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathDelayArgs
                                {
                                    DelaySeconds = 120,
                                },
                            },
                            new Incident.Inputs.EscalationPathPathIfElseThenPathArgs
                            {
                                Type = "repeat",
                                Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathRepeatArgs
                                {
                                    RepeatTimes = 3,
                                    ToNode = "start",
                                },
                            },
                        },
                        ElsePaths = new[]
                        {
                            new Incident.Inputs.EscalationPathPathIfElseElsePathArgs
                            {
                                Type = "level",
                                Level = new Incident.Inputs.EscalationPathPathIfElseElsePathLevelArgs
                                {
                                    Targets = new[]
                                    {
                                        new Incident.Inputs.EscalationPathPathIfElseElsePathLevelTargetArgs
                                        {
                                            Type = "schedule",
                                            Id = primaryOnCall.Id,
                                            Urgency = "low",
                                        },
                                    },
                                    TimeToAckSeconds = 300,
                                },
                            },
                        },
                    },
                },
            },
            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",
                        },
                    },
                },
            },
            TeamIds = new[]
            {
                "01FCNDV6P870EA6S7TK1DSYD00",
                "01FCNDV6P870EA6S7TK1DSYD01",
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.incident.Schedule;
    import com.pulumi.incident.ScheduleArgs;
    import com.pulumi.incident.inputs.ScheduleRotationArgs;
    import com.pulumi.incident.EscalationPath;
    import com.pulumi.incident.EscalationPathArgs;
    import com.pulumi.incident.inputs.EscalationPathPathArgs;
    import com.pulumi.incident.inputs.EscalationPathPathIfElseArgs;
    import com.pulumi.incident.inputs.EscalationPathWorkingHourArgs;
    import java.util.List;
    import java.util.ArrayList;
    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) {
            // This is the primary schedule that receives pages in working hours.
            var primaryOnCall = new Schedule("primaryOnCall", ScheduleArgs.builder()
                .name("Primary")
                .timezone("Europe/London")
                .rotations(ScheduleRotationArgs.builder()
                    .id("primary")
                    .name("Primary")
                    .versions(ScheduleRotationVersionArgs.builder()
                        .handoverStartAt("2024-05-01T12:00:00Z")
                        .users()
                        .layers(ScheduleRotationVersionLayerArgs.builder()
                            .id("primary")
                            .name("Primary")
                            .build())
                        .handovers(ScheduleRotationVersionHandoverArgs.builder()
                            .intervalType("daily")
                            .interval(1.0)
                            .build())
                        .build())
                    .build())
                .build());
    
            // If in working hours, send high-urgency alerts. Otherwise use low-urgency.
            var urgentSupport = new EscalationPath("urgentSupport", EscalationPathArgs.builder()
                .name("Urgent support")
                .paths(EscalationPathPathArgs.builder()
                    .id("start")
                    .type("if_else")
                    .ifElse(EscalationPathPathIfElseArgs.builder()
                        .conditions(EscalationPathPathIfElseConditionArgs.builder()
                            .operation("is_active")
                            .paramBindings()
                            .subject("escalation.working_hours[\"UK\"]")
                            .build())
                        .thenPaths(                    
                            EscalationPathPathIfElseThenPathArgs.builder()
                                .type("level")
                                .level(EscalationPathPathIfElseThenPathLevelArgs.builder()
                                    .targets(EscalationPathPathIfElseThenPathLevelTargetArgs.builder()
                                        .type("schedule")
                                        .id(primaryOnCall.id())
                                        .urgency("high")
                                        .build())
                                    .timeToAckSeconds(300.0)
                                    .build())
                                .build(),
                            EscalationPathPathIfElseThenPathArgs.builder()
                                .type("delay")
                                .delay(EscalationPathPathIfElseThenPathDelayArgs.builder()
                                    .delaySeconds(120.0)
                                    .build())
                                .build(),
                            EscalationPathPathIfElseThenPathArgs.builder()
                                .type("repeat")
                                .repeat(EscalationPathPathIfElseThenPathRepeatArgs.builder()
                                    .repeatTimes(3.0)
                                    .toNode("start")
                                    .build())
                                .build())
                        .elsePaths(EscalationPathPathIfElseElsePathArgs.builder()
                            .type("level")
                            .level(EscalationPathPathIfElseElsePathLevelArgs.builder()
                                .targets(EscalationPathPathIfElseElsePathLevelTargetArgs.builder()
                                    .type("schedule")
                                    .id(primaryOnCall.id())
                                    .urgency("low")
                                    .build())
                                .timeToAckSeconds(300.0)
                                .build())
                            .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())
                .teamIds(            
                    "01FCNDV6P870EA6S7TK1DSYD00",
                    "01FCNDV6P870EA6S7TK1DSYD01")
                .build());
    
        }
    }
    
    resources:
      # This is the primary schedule that receives pages in working hours.
      primaryOnCall:
        type: incident:Schedule
        name: primary_on_call
        properties:
          name: Primary
          timezone: Europe/London
          rotations:
            - id: primary
              name: Primary
              versions:
                - handoverStartAt: 2024-05-01T12:00:00Z
                  users: []
                  layers:
                    - id: primary
                      name: Primary
                  handovers:
                    - intervalType: daily
                      interval: 1
      # If in working hours, send high-urgency alerts. Otherwise use low-urgency.
      urgentSupport:
        type: incident:EscalationPath
        name: urgent_support
        properties:
          name: Urgent support
          paths:
            - id: start
              type: if_else
              ifElse:
                conditions:
                  - operation: is_active
                    paramBindings: []
                    subject: escalation.working_hours["UK"]
                thenPaths:
                  - type: level
                    level:
                      targets:
                        - type: schedule
                          id: ${primaryOnCall.id}
                          urgency: high
                      timeToAckSeconds: 300
                  - type: delay
                    delay:
                      delaySeconds: 120
                  - type: repeat
                    repeat:
                      repeatTimes: 3
                      toNode: start
                elsePaths:
                  - type: level
                    level:
                      targets:
                        - type: schedule
                          id: ${primaryOnCall.id}
                          urgency: low
                      timeToAckSeconds: 300
          workingHours:
            - id: UK
              name: UK
              timezone: Europe/London
              weekdayIntervals:
                - weekday: monday
                  startTime: 09:00
                  endTime: 17:00
          teamIds:
            - 01FCNDV6P870EA6S7TK1DSYD00
            - 01FCNDV6P870EA6S7TK1DSYD01
    

    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: EscalationPathArgs,
                       opts: Optional[ResourceOptions] = None)
    
    @overload
    def EscalationPath(resource_name: str,
                       opts: Optional[ResourceOptions] = None,
                       paths: Optional[Sequence[EscalationPathPathArgs]] = None,
                       name: Optional[str] = None,
                       repeat_config: Optional[EscalationPathRepeatConfigArgs] = None,
                       team_ids: Optional[Sequence[str]] = 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, 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.
    
    

    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()
    {
        Paths = new[]
        {
            new Incident.Inputs.EscalationPathPathArgs
            {
                Type = "string",
                Delay = new Incident.Inputs.EscalationPathPathDelayArgs
                {
                    DelayIntervalCondition = "string",
                    DelaySeconds = 0,
                    DelayWeekdayIntervalConfigId = "string",
                },
                Id = "string",
                IfElse = new Incident.Inputs.EscalationPathPathIfElseArgs
                {
                    Conditions = new[]
                    {
                        new Incident.Inputs.EscalationPathPathIfElseConditionArgs
                        {
                            Operation = "string",
                            ParamBindings = new[]
                            {
                                new Incident.Inputs.EscalationPathPathIfElseConditionParamBindingArgs
                                {
                                    ArrayValues = new[]
                                    {
                                        new Incident.Inputs.EscalationPathPathIfElseConditionParamBindingArrayValueArgs
                                        {
                                            Literal = "string",
                                            Reference = "string",
                                        },
                                    },
                                    Value = new Incident.Inputs.EscalationPathPathIfElseConditionParamBindingValueArgs
                                    {
                                        Literal = "string",
                                        Reference = "string",
                                    },
                                },
                            },
                            Subject = "string",
                        },
                    },
                    ThenPaths = new[]
                    {
                        new Incident.Inputs.EscalationPathPathIfElseThenPathArgs
                        {
                            Type = "string",
                            Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathDelayArgs
                            {
                                DelayIntervalCondition = "string",
                                DelaySeconds = 0,
                                DelayWeekdayIntervalConfigId = "string",
                            },
                            Id = "string",
                            IfElse = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseArgs
                            {
                                Conditions = new[]
                                {
                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseConditionArgs
                                    {
                                        Operation = "string",
                                        ParamBindings = new[]
                                        {
                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseConditionParamBindingArgs
                                            {
                                                ArrayValues = new[]
                                                {
                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs
                                                    {
                                                        Literal = "string",
                                                        Reference = "string",
                                                    },
                                                },
                                                Value = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseConditionParamBindingValueArgs
                                                {
                                                    Literal = "string",
                                                    Reference = "string",
                                                },
                                            },
                                        },
                                        Subject = "string",
                                    },
                                },
                                ThenPaths = new[]
                                {
                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathArgs
                                    {
                                        Type = "string",
                                        Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathDelayArgs
                                        {
                                            DelayIntervalCondition = "string",
                                            DelaySeconds = 0,
                                            DelayWeekdayIntervalConfigId = "string",
                                        },
                                        Id = "string",
                                        IfElse = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseArgs
                                        {
                                            Conditions = new[]
                                            {
                                                new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseConditionArgs
                                                {
                                                    Operation = "string",
                                                    ParamBindings = new[]
                                                    {
                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArgs
                                                        {
                                                            ArrayValues = new[]
                                                            {
                                                                new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs
                                                                {
                                                                    Literal = "string",
                                                                    Reference = "string",
                                                                },
                                                            },
                                                            Value = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingValueArgs
                                                            {
                                                                Literal = "string",
                                                                Reference = "string",
                                                            },
                                                        },
                                                    },
                                                    Subject = "string",
                                                },
                                            },
                                            ThenPaths = new[]
                                            {
                                                new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathArgs
                                                {
                                                    Type = "string",
                                                    Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathDelayArgs
                                                    {
                                                        DelayIntervalCondition = "string",
                                                        DelaySeconds = 0,
                                                        DelayWeekdayIntervalConfigId = "string",
                                                    },
                                                    Id = "string",
                                                    IfElse = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseArgs
                                                    {
                                                        Conditions = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionArgs
                                                            {
                                                                Operation = "string",
                                                                ParamBindings = new[]
                                                                {
                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArgs
                                                                    {
                                                                        ArrayValues = new[]
                                                                        {
                                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs
                                                                            {
                                                                                Literal = "string",
                                                                                Reference = "string",
                                                                            },
                                                                        },
                                                                        Value = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingValueArgs
                                                                        {
                                                                            Literal = "string",
                                                                            Reference = "string",
                                                                        },
                                                                    },
                                                                },
                                                                Subject = "string",
                                                            },
                                                        },
                                                        ThenPaths = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathArgs
                                                            {
                                                                Type = "string",
                                                                Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathDelayArgs
                                                                {
                                                                    DelayIntervalCondition = "string",
                                                                    DelaySeconds = 0,
                                                                    DelayWeekdayIntervalConfigId = "string",
                                                                },
                                                                Id = "string",
                                                                IfElse = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseArgs
                                                                {
                                                                    Conditions = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionArgs
                                                                        {
                                                                            Operation = "string",
                                                                            ParamBindings = new[]
                                                                            {
                                                                                new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArgs
                                                                                {
                                                                                    ArrayValues = new[]
                                                                                    {
                                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs
                                                                                        {
                                                                                            Literal = "string",
                                                                                            Reference = "string",
                                                                                        },
                                                                                    },
                                                                                    Value = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingValueArgs
                                                                                    {
                                                                                        Literal = "string",
                                                                                        Reference = "string",
                                                                                    },
                                                                                },
                                                                            },
                                                                            Subject = "string",
                                                                        },
                                                                    },
                                                                    ThenPaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                    ElsePaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                },
                                                                Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    AckMode = "string",
                                                                    RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs
                                                                    {
                                                                        Enabled = false,
                                                                        RotateAfterSeconds = 0,
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathRepeatArgs
                                                                {
                                                                    RepeatTimes = 0,
                                                                    ToNode = "string",
                                                                },
                                                            },
                                                        },
                                                        ElsePaths = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathArgs
                                                            {
                                                                Type = "string",
                                                                Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathDelayArgs
                                                                {
                                                                    DelayIntervalCondition = "string",
                                                                    DelaySeconds = 0,
                                                                    DelayWeekdayIntervalConfigId = "string",
                                                                },
                                                                Id = "string",
                                                                IfElse = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseArgs
                                                                {
                                                                    Conditions = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionArgs
                                                                        {
                                                                            Operation = "string",
                                                                            ParamBindings = new[]
                                                                            {
                                                                                new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArgs
                                                                                {
                                                                                    ArrayValues = new[]
                                                                                    {
                                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs
                                                                                        {
                                                                                            Literal = "string",
                                                                                            Reference = "string",
                                                                                        },
                                                                                    },
                                                                                    Value = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingValueArgs
                                                                                    {
                                                                                        Literal = "string",
                                                                                        Reference = "string",
                                                                                    },
                                                                                },
                                                                            },
                                                                            Subject = "string",
                                                                        },
                                                                    },
                                                                    ThenPaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                    ElsePaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                },
                                                                Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    AckMode = "string",
                                                                    RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs
                                                                    {
                                                                        Enabled = false,
                                                                        RotateAfterSeconds = 0,
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathRepeatArgs
                                                                {
                                                                    RepeatTimes = 0,
                                                                    ToNode = "string",
                                                                },
                                                            },
                                                        },
                                                    },
                                                    Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathLevelArgs
                                                    {
                                                        Targets = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArgs
                                                            {
                                                                Id = "string",
                                                                Type = "string",
                                                                Urgency = "string",
                                                                ScheduleMode = "string",
                                                            },
                                                        },
                                                        AckMode = "string",
                                                        RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs
                                                        {
                                                            Enabled = false,
                                                            RotateAfterSeconds = 0,
                                                        },
                                                        TimeToAckIntervalCondition = "string",
                                                        TimeToAckSeconds = 0,
                                                        TimeToAckWeekdayIntervalConfigId = "string",
                                                    },
                                                    NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelArgs
                                                    {
                                                        Targets = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs
                                                            {
                                                                Id = "string",
                                                                Type = "string",
                                                                Urgency = "string",
                                                                ScheduleMode = "string",
                                                            },
                                                        },
                                                        TimeToAckIntervalCondition = "string",
                                                        TimeToAckSeconds = 0,
                                                        TimeToAckWeekdayIntervalConfigId = "string",
                                                    },
                                                    Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathRepeatArgs
                                                    {
                                                        RepeatTimes = 0,
                                                        ToNode = "string",
                                                    },
                                                },
                                            },
                                            ElsePaths = new[]
                                            {
                                                new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathArgs
                                                {
                                                    Type = "string",
                                                    Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathDelayArgs
                                                    {
                                                        DelayIntervalCondition = "string",
                                                        DelaySeconds = 0,
                                                        DelayWeekdayIntervalConfigId = "string",
                                                    },
                                                    Id = "string",
                                                    IfElse = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseArgs
                                                    {
                                                        Conditions = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionArgs
                                                            {
                                                                Operation = "string",
                                                                ParamBindings = new[]
                                                                {
                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArgs
                                                                    {
                                                                        ArrayValues = new[]
                                                                        {
                                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs
                                                                            {
                                                                                Literal = "string",
                                                                                Reference = "string",
                                                                            },
                                                                        },
                                                                        Value = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingValueArgs
                                                                        {
                                                                            Literal = "string",
                                                                            Reference = "string",
                                                                        },
                                                                    },
                                                                },
                                                                Subject = "string",
                                                            },
                                                        },
                                                        ThenPaths = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathArgs
                                                            {
                                                                Type = "string",
                                                                Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathDelayArgs
                                                                {
                                                                    DelayIntervalCondition = "string",
                                                                    DelaySeconds = 0,
                                                                    DelayWeekdayIntervalConfigId = "string",
                                                                },
                                                                Id = "string",
                                                                IfElse = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseArgs
                                                                {
                                                                    Conditions = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionArgs
                                                                        {
                                                                            Operation = "string",
                                                                            ParamBindings = new[]
                                                                            {
                                                                                new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArgs
                                                                                {
                                                                                    ArrayValues = new[]
                                                                                    {
                                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArgs
                                                                                        {
                                                                                            Literal = "string",
                                                                                            Reference = "string",
                                                                                        },
                                                                                    },
                                                                                    Value = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingValueArgs
                                                                                    {
                                                                                        Literal = "string",
                                                                                        Reference = "string",
                                                                                    },
                                                                                },
                                                                            },
                                                                            Subject = "string",
                                                                        },
                                                                    },
                                                                    ThenPaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                    ElsePaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                },
                                                                Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    AckMode = "string",
                                                                    RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs
                                                                    {
                                                                        Enabled = false,
                                                                        RotateAfterSeconds = 0,
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathRepeatArgs
                                                                {
                                                                    RepeatTimes = 0,
                                                                    ToNode = "string",
                                                                },
                                                            },
                                                        },
                                                        ElsePaths = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathArgs
                                                            {
                                                                Type = "string",
                                                                Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathDelayArgs
                                                                {
                                                                    DelayIntervalCondition = "string",
                                                                    DelaySeconds = 0,
                                                                    DelayWeekdayIntervalConfigId = "string",
                                                                },
                                                                Id = "string",
                                                                IfElse = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseArgs
                                                                {
                                                                    Conditions = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionArgs
                                                                        {
                                                                            Operation = "string",
                                                                            ParamBindings = new[]
                                                                            {
                                                                                new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs
                                                                                {
                                                                                    ArrayValues = new[]
                                                                                    {
                                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs
                                                                                        {
                                                                                            Literal = "string",
                                                                                            Reference = "string",
                                                                                        },
                                                                                    },
                                                                                    Value = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs
                                                                                    {
                                                                                        Literal = "string",
                                                                                        Reference = "string",
                                                                                    },
                                                                                },
                                                                            },
                                                                            Subject = "string",
                                                                        },
                                                                    },
                                                                    ThenPaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                    ElsePaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                },
                                                                Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    AckMode = "string",
                                                                    RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs
                                                                    {
                                                                        Enabled = false,
                                                                        RotateAfterSeconds = 0,
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathRepeatArgs
                                                                {
                                                                    RepeatTimes = 0,
                                                                    ToNode = "string",
                                                                },
                                                            },
                                                        },
                                                    },
                                                    Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathLevelArgs
                                                    {
                                                        Targets = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArgs
                                                            {
                                                                Id = "string",
                                                                Type = "string",
                                                                Urgency = "string",
                                                                ScheduleMode = "string",
                                                            },
                                                        },
                                                        AckMode = "string",
                                                        RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs
                                                        {
                                                            Enabled = false,
                                                            RotateAfterSeconds = 0,
                                                        },
                                                        TimeToAckIntervalCondition = "string",
                                                        TimeToAckSeconds = 0,
                                                        TimeToAckWeekdayIntervalConfigId = "string",
                                                    },
                                                    NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelArgs
                                                    {
                                                        Targets = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs
                                                            {
                                                                Id = "string",
                                                                Type = "string",
                                                                Urgency = "string",
                                                                ScheduleMode = "string",
                                                            },
                                                        },
                                                        TimeToAckIntervalCondition = "string",
                                                        TimeToAckSeconds = 0,
                                                        TimeToAckWeekdayIntervalConfigId = "string",
                                                    },
                                                    Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathRepeatArgs
                                                    {
                                                        RepeatTimes = 0,
                                                        ToNode = "string",
                                                    },
                                                },
                                            },
                                        },
                                        Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathLevelArgs
                                        {
                                            Targets = new[]
                                            {
                                                new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathLevelTargetArgs
                                                {
                                                    Id = "string",
                                                    Type = "string",
                                                    Urgency = "string",
                                                    ScheduleMode = "string",
                                                },
                                            },
                                            AckMode = "string",
                                            RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs
                                            {
                                                Enabled = false,
                                                RotateAfterSeconds = 0,
                                            },
                                            TimeToAckIntervalCondition = "string",
                                            TimeToAckSeconds = 0,
                                            TimeToAckWeekdayIntervalConfigId = "string",
                                        },
                                        NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathNotifyChannelArgs
                                        {
                                            Targets = new[]
                                            {
                                                new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs
                                                {
                                                    Id = "string",
                                                    Type = "string",
                                                    Urgency = "string",
                                                    ScheduleMode = "string",
                                                },
                                            },
                                            TimeToAckIntervalCondition = "string",
                                            TimeToAckSeconds = 0,
                                            TimeToAckWeekdayIntervalConfigId = "string",
                                        },
                                        Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseThenPathRepeatArgs
                                        {
                                            RepeatTimes = 0,
                                            ToNode = "string",
                                        },
                                    },
                                },
                                ElsePaths = new[]
                                {
                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathArgs
                                    {
                                        Type = "string",
                                        Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathDelayArgs
                                        {
                                            DelayIntervalCondition = "string",
                                            DelaySeconds = 0,
                                            DelayWeekdayIntervalConfigId = "string",
                                        },
                                        Id = "string",
                                        IfElse = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseArgs
                                        {
                                            Conditions = new[]
                                            {
                                                new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseConditionArgs
                                                {
                                                    Operation = "string",
                                                    ParamBindings = new[]
                                                    {
                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArgs
                                                        {
                                                            ArrayValues = new[]
                                                            {
                                                                new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs
                                                                {
                                                                    Literal = "string",
                                                                    Reference = "string",
                                                                },
                                                            },
                                                            Value = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingValueArgs
                                                            {
                                                                Literal = "string",
                                                                Reference = "string",
                                                            },
                                                        },
                                                    },
                                                    Subject = "string",
                                                },
                                            },
                                            ThenPaths = new[]
                                            {
                                                new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathArgs
                                                {
                                                    Type = "string",
                                                    Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathDelayArgs
                                                    {
                                                        DelayIntervalCondition = "string",
                                                        DelaySeconds = 0,
                                                        DelayWeekdayIntervalConfigId = "string",
                                                    },
                                                    Id = "string",
                                                    IfElse = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseArgs
                                                    {
                                                        Conditions = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionArgs
                                                            {
                                                                Operation = "string",
                                                                ParamBindings = new[]
                                                                {
                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArgs
                                                                    {
                                                                        ArrayValues = new[]
                                                                        {
                                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArgs
                                                                            {
                                                                                Literal = "string",
                                                                                Reference = "string",
                                                                            },
                                                                        },
                                                                        Value = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingValueArgs
                                                                        {
                                                                            Literal = "string",
                                                                            Reference = "string",
                                                                        },
                                                                    },
                                                                },
                                                                Subject = "string",
                                                            },
                                                        },
                                                        ThenPaths = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathArgs
                                                            {
                                                                Type = "string",
                                                                Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathDelayArgs
                                                                {
                                                                    DelayIntervalCondition = "string",
                                                                    DelaySeconds = 0,
                                                                    DelayWeekdayIntervalConfigId = "string",
                                                                },
                                                                Id = "string",
                                                                IfElse = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseArgs
                                                                {
                                                                    Conditions = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionArgs
                                                                        {
                                                                            Operation = "string",
                                                                            ParamBindings = new[]
                                                                            {
                                                                                new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArgs
                                                                                {
                                                                                    ArrayValues = new[]
                                                                                    {
                                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs
                                                                                        {
                                                                                            Literal = "string",
                                                                                            Reference = "string",
                                                                                        },
                                                                                    },
                                                                                    Value = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingValueArgs
                                                                                    {
                                                                                        Literal = "string",
                                                                                        Reference = "string",
                                                                                    },
                                                                                },
                                                                            },
                                                                            Subject = "string",
                                                                        },
                                                                    },
                                                                    ThenPaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                    ElsePaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                },
                                                                Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    AckMode = "string",
                                                                    RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs
                                                                    {
                                                                        Enabled = false,
                                                                        RotateAfterSeconds = 0,
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathRepeatArgs
                                                                {
                                                                    RepeatTimes = 0,
                                                                    ToNode = "string",
                                                                },
                                                            },
                                                        },
                                                        ElsePaths = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathArgs
                                                            {
                                                                Type = "string",
                                                                Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathDelayArgs
                                                                {
                                                                    DelayIntervalCondition = "string",
                                                                    DelaySeconds = 0,
                                                                    DelayWeekdayIntervalConfigId = "string",
                                                                },
                                                                Id = "string",
                                                                IfElse = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseArgs
                                                                {
                                                                    Conditions = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionArgs
                                                                        {
                                                                            Operation = "string",
                                                                            ParamBindings = new[]
                                                                            {
                                                                                new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArgs
                                                                                {
                                                                                    ArrayValues = new[]
                                                                                    {
                                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs
                                                                                        {
                                                                                            Literal = "string",
                                                                                            Reference = "string",
                                                                                        },
                                                                                    },
                                                                                    Value = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingValueArgs
                                                                                    {
                                                                                        Literal = "string",
                                                                                        Reference = "string",
                                                                                    },
                                                                                },
                                                                            },
                                                                            Subject = "string",
                                                                        },
                                                                    },
                                                                    ThenPaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                    ElsePaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                },
                                                                Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    AckMode = "string",
                                                                    RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs
                                                                    {
                                                                        Enabled = false,
                                                                        RotateAfterSeconds = 0,
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathRepeatArgs
                                                                {
                                                                    RepeatTimes = 0,
                                                                    ToNode = "string",
                                                                },
                                                            },
                                                        },
                                                    },
                                                    Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathLevelArgs
                                                    {
                                                        Targets = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArgs
                                                            {
                                                                Id = "string",
                                                                Type = "string",
                                                                Urgency = "string",
                                                                ScheduleMode = "string",
                                                            },
                                                        },
                                                        AckMode = "string",
                                                        RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs
                                                        {
                                                            Enabled = false,
                                                            RotateAfterSeconds = 0,
                                                        },
                                                        TimeToAckIntervalCondition = "string",
                                                        TimeToAckSeconds = 0,
                                                        TimeToAckWeekdayIntervalConfigId = "string",
                                                    },
                                                    NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelArgs
                                                    {
                                                        Targets = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs
                                                            {
                                                                Id = "string",
                                                                Type = "string",
                                                                Urgency = "string",
                                                                ScheduleMode = "string",
                                                            },
                                                        },
                                                        TimeToAckIntervalCondition = "string",
                                                        TimeToAckSeconds = 0,
                                                        TimeToAckWeekdayIntervalConfigId = "string",
                                                    },
                                                    Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathRepeatArgs
                                                    {
                                                        RepeatTimes = 0,
                                                        ToNode = "string",
                                                    },
                                                },
                                            },
                                            ElsePaths = new[]
                                            {
                                                new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathArgs
                                                {
                                                    Type = "string",
                                                    Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathDelayArgs
                                                    {
                                                        DelayIntervalCondition = "string",
                                                        DelaySeconds = 0,
                                                        DelayWeekdayIntervalConfigId = "string",
                                                    },
                                                    Id = "string",
                                                    IfElse = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseArgs
                                                    {
                                                        Conditions = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionArgs
                                                            {
                                                                Operation = "string",
                                                                ParamBindings = new[]
                                                                {
                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs
                                                                    {
                                                                        ArrayValues = new[]
                                                                        {
                                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs
                                                                            {
                                                                                Literal = "string",
                                                                                Reference = "string",
                                                                            },
                                                                        },
                                                                        Value = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs
                                                                        {
                                                                            Literal = "string",
                                                                            Reference = "string",
                                                                        },
                                                                    },
                                                                },
                                                                Subject = "string",
                                                            },
                                                        },
                                                        ThenPaths = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathArgs
                                                            {
                                                                Type = "string",
                                                                Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathDelayArgs
                                                                {
                                                                    DelayIntervalCondition = "string",
                                                                    DelaySeconds = 0,
                                                                    DelayWeekdayIntervalConfigId = "string",
                                                                },
                                                                Id = "string",
                                                                IfElse = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseArgs
                                                                {
                                                                    Conditions = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionArgs
                                                                        {
                                                                            Operation = "string",
                                                                            ParamBindings = new[]
                                                                            {
                                                                                new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArgs
                                                                                {
                                                                                    ArrayValues = new[]
                                                                                    {
                                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArgs
                                                                                        {
                                                                                            Literal = "string",
                                                                                            Reference = "string",
                                                                                        },
                                                                                    },
                                                                                    Value = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingValueArgs
                                                                                    {
                                                                                        Literal = "string",
                                                                                        Reference = "string",
                                                                                    },
                                                                                },
                                                                            },
                                                                            Subject = "string",
                                                                        },
                                                                    },
                                                                    ThenPaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                    ElsePaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                },
                                                                Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    AckMode = "string",
                                                                    RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs
                                                                    {
                                                                        Enabled = false,
                                                                        RotateAfterSeconds = 0,
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathRepeatArgs
                                                                {
                                                                    RepeatTimes = 0,
                                                                    ToNode = "string",
                                                                },
                                                            },
                                                        },
                                                        ElsePaths = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathArgs
                                                            {
                                                                Type = "string",
                                                                Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs
                                                                {
                                                                    DelayIntervalCondition = "string",
                                                                    DelaySeconds = 0,
                                                                    DelayWeekdayIntervalConfigId = "string",
                                                                },
                                                                Id = "string",
                                                                IfElse = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseArgs
                                                                {
                                                                    Conditions = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionArgs
                                                                        {
                                                                            Operation = "string",
                                                                            ParamBindings = new[]
                                                                            {
                                                                                new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs
                                                                                {
                                                                                    ArrayValues = new[]
                                                                                    {
                                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs
                                                                                        {
                                                                                            Literal = "string",
                                                                                            Reference = "string",
                                                                                        },
                                                                                    },
                                                                                    Value = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs
                                                                                    {
                                                                                        Literal = "string",
                                                                                        Reference = "string",
                                                                                    },
                                                                                },
                                                                            },
                                                                            Subject = "string",
                                                                        },
                                                                    },
                                                                    ThenPaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                    ElsePaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                },
                                                                Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    AckMode = "string",
                                                                    RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs
                                                                    {
                                                                        Enabled = false,
                                                                        RotateAfterSeconds = 0,
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathRepeatArgs
                                                                {
                                                                    RepeatTimes = 0,
                                                                    ToNode = "string",
                                                                },
                                                            },
                                                        },
                                                    },
                                                    Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathLevelArgs
                                                    {
                                                        Targets = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArgs
                                                            {
                                                                Id = "string",
                                                                Type = "string",
                                                                Urgency = "string",
                                                                ScheduleMode = "string",
                                                            },
                                                        },
                                                        AckMode = "string",
                                                        RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs
                                                        {
                                                            Enabled = false,
                                                            RotateAfterSeconds = 0,
                                                        },
                                                        TimeToAckIntervalCondition = "string",
                                                        TimeToAckSeconds = 0,
                                                        TimeToAckWeekdayIntervalConfigId = "string",
                                                    },
                                                    NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelArgs
                                                    {
                                                        Targets = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs
                                                            {
                                                                Id = "string",
                                                                Type = "string",
                                                                Urgency = "string",
                                                                ScheduleMode = "string",
                                                            },
                                                        },
                                                        TimeToAckIntervalCondition = "string",
                                                        TimeToAckSeconds = 0,
                                                        TimeToAckWeekdayIntervalConfigId = "string",
                                                    },
                                                    Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathRepeatArgs
                                                    {
                                                        RepeatTimes = 0,
                                                        ToNode = "string",
                                                    },
                                                },
                                            },
                                        },
                                        Level = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathLevelArgs
                                        {
                                            Targets = new[]
                                            {
                                                new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathLevelTargetArgs
                                                {
                                                    Id = "string",
                                                    Type = "string",
                                                    Urgency = "string",
                                                    ScheduleMode = "string",
                                                },
                                            },
                                            AckMode = "string",
                                            RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs
                                            {
                                                Enabled = false,
                                                RotateAfterSeconds = 0,
                                            },
                                            TimeToAckIntervalCondition = "string",
                                            TimeToAckSeconds = 0,
                                            TimeToAckWeekdayIntervalConfigId = "string",
                                        },
                                        NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathNotifyChannelArgs
                                        {
                                            Targets = new[]
                                            {
                                                new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs
                                                {
                                                    Id = "string",
                                                    Type = "string",
                                                    Urgency = "string",
                                                    ScheduleMode = "string",
                                                },
                                            },
                                            TimeToAckIntervalCondition = "string",
                                            TimeToAckSeconds = 0,
                                            TimeToAckWeekdayIntervalConfigId = "string",
                                        },
                                        Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathIfElseElsePathRepeatArgs
                                        {
                                            RepeatTimes = 0,
                                            ToNode = "string",
                                        },
                                    },
                                },
                            },
                            Level = new Incident.Inputs.EscalationPathPathIfElseThenPathLevelArgs
                            {
                                Targets = new[]
                                {
                                    new Incident.Inputs.EscalationPathPathIfElseThenPathLevelTargetArgs
                                    {
                                        Id = "string",
                                        Type = "string",
                                        Urgency = "string",
                                        ScheduleMode = "string",
                                    },
                                },
                                AckMode = "string",
                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseThenPathLevelRoundRobinConfigArgs
                                {
                                    Enabled = false,
                                    RotateAfterSeconds = 0,
                                },
                                TimeToAckIntervalCondition = "string",
                                TimeToAckSeconds = 0,
                                TimeToAckWeekdayIntervalConfigId = "string",
                            },
                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseThenPathNotifyChannelArgs
                            {
                                Targets = new[]
                                {
                                    new Incident.Inputs.EscalationPathPathIfElseThenPathNotifyChannelTargetArgs
                                    {
                                        Id = "string",
                                        Type = "string",
                                        Urgency = "string",
                                        ScheduleMode = "string",
                                    },
                                },
                                TimeToAckIntervalCondition = "string",
                                TimeToAckSeconds = 0,
                                TimeToAckWeekdayIntervalConfigId = "string",
                            },
                            Repeat = new Incident.Inputs.EscalationPathPathIfElseThenPathRepeatArgs
                            {
                                RepeatTimes = 0,
                                ToNode = "string",
                            },
                        },
                    },
                    ElsePaths = new[]
                    {
                        new Incident.Inputs.EscalationPathPathIfElseElsePathArgs
                        {
                            Type = "string",
                            Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathDelayArgs
                            {
                                DelayIntervalCondition = "string",
                                DelaySeconds = 0,
                                DelayWeekdayIntervalConfigId = "string",
                            },
                            Id = "string",
                            IfElse = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseArgs
                            {
                                Conditions = new[]
                                {
                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseConditionArgs
                                    {
                                        Operation = "string",
                                        ParamBindings = new[]
                                        {
                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseConditionParamBindingArgs
                                            {
                                                ArrayValues = new[]
                                                {
                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs
                                                    {
                                                        Literal = "string",
                                                        Reference = "string",
                                                    },
                                                },
                                                Value = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseConditionParamBindingValueArgs
                                                {
                                                    Literal = "string",
                                                    Reference = "string",
                                                },
                                            },
                                        },
                                        Subject = "string",
                                    },
                                },
                                ThenPaths = new[]
                                {
                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathArgs
                                    {
                                        Type = "string",
                                        Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathDelayArgs
                                        {
                                            DelayIntervalCondition = "string",
                                            DelaySeconds = 0,
                                            DelayWeekdayIntervalConfigId = "string",
                                        },
                                        Id = "string",
                                        IfElse = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseArgs
                                        {
                                            Conditions = new[]
                                            {
                                                new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseConditionArgs
                                                {
                                                    Operation = "string",
                                                    ParamBindings = new[]
                                                    {
                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArgs
                                                        {
                                                            ArrayValues = new[]
                                                            {
                                                                new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArgs
                                                                {
                                                                    Literal = "string",
                                                                    Reference = "string",
                                                                },
                                                            },
                                                            Value = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingValueArgs
                                                            {
                                                                Literal = "string",
                                                                Reference = "string",
                                                            },
                                                        },
                                                    },
                                                    Subject = "string",
                                                },
                                            },
                                            ThenPaths = new[]
                                            {
                                                new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathArgs
                                                {
                                                    Type = "string",
                                                    Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathDelayArgs
                                                    {
                                                        DelayIntervalCondition = "string",
                                                        DelaySeconds = 0,
                                                        DelayWeekdayIntervalConfigId = "string",
                                                    },
                                                    Id = "string",
                                                    IfElse = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseArgs
                                                    {
                                                        Conditions = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionArgs
                                                            {
                                                                Operation = "string",
                                                                ParamBindings = new[]
                                                                {
                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArgs
                                                                    {
                                                                        ArrayValues = new[]
                                                                        {
                                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs
                                                                            {
                                                                                Literal = "string",
                                                                                Reference = "string",
                                                                            },
                                                                        },
                                                                        Value = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingValueArgs
                                                                        {
                                                                            Literal = "string",
                                                                            Reference = "string",
                                                                        },
                                                                    },
                                                                },
                                                                Subject = "string",
                                                            },
                                                        },
                                                        ThenPaths = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathArgs
                                                            {
                                                                Type = "string",
                                                                Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathDelayArgs
                                                                {
                                                                    DelayIntervalCondition = "string",
                                                                    DelaySeconds = 0,
                                                                    DelayWeekdayIntervalConfigId = "string",
                                                                },
                                                                Id = "string",
                                                                IfElse = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseArgs
                                                                {
                                                                    Conditions = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionArgs
                                                                        {
                                                                            Operation = "string",
                                                                            ParamBindings = new[]
                                                                            {
                                                                                new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArgs
                                                                                {
                                                                                    ArrayValues = new[]
                                                                                    {
                                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs
                                                                                        {
                                                                                            Literal = "string",
                                                                                            Reference = "string",
                                                                                        },
                                                                                    },
                                                                                    Value = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingValueArgs
                                                                                    {
                                                                                        Literal = "string",
                                                                                        Reference = "string",
                                                                                    },
                                                                                },
                                                                            },
                                                                            Subject = "string",
                                                                        },
                                                                    },
                                                                    ThenPaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                    ElsePaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                },
                                                                Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    AckMode = "string",
                                                                    RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs
                                                                    {
                                                                        Enabled = false,
                                                                        RotateAfterSeconds = 0,
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathRepeatArgs
                                                                {
                                                                    RepeatTimes = 0,
                                                                    ToNode = "string",
                                                                },
                                                            },
                                                        },
                                                        ElsePaths = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathArgs
                                                            {
                                                                Type = "string",
                                                                Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathDelayArgs
                                                                {
                                                                    DelayIntervalCondition = "string",
                                                                    DelaySeconds = 0,
                                                                    DelayWeekdayIntervalConfigId = "string",
                                                                },
                                                                Id = "string",
                                                                IfElse = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseArgs
                                                                {
                                                                    Conditions = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionArgs
                                                                        {
                                                                            Operation = "string",
                                                                            ParamBindings = new[]
                                                                            {
                                                                                new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArgs
                                                                                {
                                                                                    ArrayValues = new[]
                                                                                    {
                                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs
                                                                                        {
                                                                                            Literal = "string",
                                                                                            Reference = "string",
                                                                                        },
                                                                                    },
                                                                                    Value = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingValueArgs
                                                                                    {
                                                                                        Literal = "string",
                                                                                        Reference = "string",
                                                                                    },
                                                                                },
                                                                            },
                                                                            Subject = "string",
                                                                        },
                                                                    },
                                                                    ThenPaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                    ElsePaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                },
                                                                Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    AckMode = "string",
                                                                    RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs
                                                                    {
                                                                        Enabled = false,
                                                                        RotateAfterSeconds = 0,
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathRepeatArgs
                                                                {
                                                                    RepeatTimes = 0,
                                                                    ToNode = "string",
                                                                },
                                                            },
                                                        },
                                                    },
                                                    Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathLevelArgs
                                                    {
                                                        Targets = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArgs
                                                            {
                                                                Id = "string",
                                                                Type = "string",
                                                                Urgency = "string",
                                                                ScheduleMode = "string",
                                                            },
                                                        },
                                                        AckMode = "string",
                                                        RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs
                                                        {
                                                            Enabled = false,
                                                            RotateAfterSeconds = 0,
                                                        },
                                                        TimeToAckIntervalCondition = "string",
                                                        TimeToAckSeconds = 0,
                                                        TimeToAckWeekdayIntervalConfigId = "string",
                                                    },
                                                    NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelArgs
                                                    {
                                                        Targets = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs
                                                            {
                                                                Id = "string",
                                                                Type = "string",
                                                                Urgency = "string",
                                                                ScheduleMode = "string",
                                                            },
                                                        },
                                                        TimeToAckIntervalCondition = "string",
                                                        TimeToAckSeconds = 0,
                                                        TimeToAckWeekdayIntervalConfigId = "string",
                                                    },
                                                    Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathRepeatArgs
                                                    {
                                                        RepeatTimes = 0,
                                                        ToNode = "string",
                                                    },
                                                },
                                            },
                                            ElsePaths = new[]
                                            {
                                                new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathArgs
                                                {
                                                    Type = "string",
                                                    Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathDelayArgs
                                                    {
                                                        DelayIntervalCondition = "string",
                                                        DelaySeconds = 0,
                                                        DelayWeekdayIntervalConfigId = "string",
                                                    },
                                                    Id = "string",
                                                    IfElse = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseArgs
                                                    {
                                                        Conditions = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionArgs
                                                            {
                                                                Operation = "string",
                                                                ParamBindings = new[]
                                                                {
                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArgs
                                                                    {
                                                                        ArrayValues = new[]
                                                                        {
                                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs
                                                                            {
                                                                                Literal = "string",
                                                                                Reference = "string",
                                                                            },
                                                                        },
                                                                        Value = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingValueArgs
                                                                        {
                                                                            Literal = "string",
                                                                            Reference = "string",
                                                                        },
                                                                    },
                                                                },
                                                                Subject = "string",
                                                            },
                                                        },
                                                        ThenPaths = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathArgs
                                                            {
                                                                Type = "string",
                                                                Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathDelayArgs
                                                                {
                                                                    DelayIntervalCondition = "string",
                                                                    DelaySeconds = 0,
                                                                    DelayWeekdayIntervalConfigId = "string",
                                                                },
                                                                Id = "string",
                                                                IfElse = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseArgs
                                                                {
                                                                    Conditions = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionArgs
                                                                        {
                                                                            Operation = "string",
                                                                            ParamBindings = new[]
                                                                            {
                                                                                new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArgs
                                                                                {
                                                                                    ArrayValues = new[]
                                                                                    {
                                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArgs
                                                                                        {
                                                                                            Literal = "string",
                                                                                            Reference = "string",
                                                                                        },
                                                                                    },
                                                                                    Value = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingValueArgs
                                                                                    {
                                                                                        Literal = "string",
                                                                                        Reference = "string",
                                                                                    },
                                                                                },
                                                                            },
                                                                            Subject = "string",
                                                                        },
                                                                    },
                                                                    ThenPaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                    ElsePaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                },
                                                                Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    AckMode = "string",
                                                                    RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs
                                                                    {
                                                                        Enabled = false,
                                                                        RotateAfterSeconds = 0,
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathRepeatArgs
                                                                {
                                                                    RepeatTimes = 0,
                                                                    ToNode = "string",
                                                                },
                                                            },
                                                        },
                                                        ElsePaths = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathArgs
                                                            {
                                                                Type = "string",
                                                                Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathDelayArgs
                                                                {
                                                                    DelayIntervalCondition = "string",
                                                                    DelaySeconds = 0,
                                                                    DelayWeekdayIntervalConfigId = "string",
                                                                },
                                                                Id = "string",
                                                                IfElse = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseArgs
                                                                {
                                                                    Conditions = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionArgs
                                                                        {
                                                                            Operation = "string",
                                                                            ParamBindings = new[]
                                                                            {
                                                                                new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs
                                                                                {
                                                                                    ArrayValues = new[]
                                                                                    {
                                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs
                                                                                        {
                                                                                            Literal = "string",
                                                                                            Reference = "string",
                                                                                        },
                                                                                    },
                                                                                    Value = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs
                                                                                    {
                                                                                        Literal = "string",
                                                                                        Reference = "string",
                                                                                    },
                                                                                },
                                                                            },
                                                                            Subject = "string",
                                                                        },
                                                                    },
                                                                    ThenPaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                    ElsePaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                },
                                                                Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    AckMode = "string",
                                                                    RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs
                                                                    {
                                                                        Enabled = false,
                                                                        RotateAfterSeconds = 0,
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathRepeatArgs
                                                                {
                                                                    RepeatTimes = 0,
                                                                    ToNode = "string",
                                                                },
                                                            },
                                                        },
                                                    },
                                                    Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathLevelArgs
                                                    {
                                                        Targets = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArgs
                                                            {
                                                                Id = "string",
                                                                Type = "string",
                                                                Urgency = "string",
                                                                ScheduleMode = "string",
                                                            },
                                                        },
                                                        AckMode = "string",
                                                        RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs
                                                        {
                                                            Enabled = false,
                                                            RotateAfterSeconds = 0,
                                                        },
                                                        TimeToAckIntervalCondition = "string",
                                                        TimeToAckSeconds = 0,
                                                        TimeToAckWeekdayIntervalConfigId = "string",
                                                    },
                                                    NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelArgs
                                                    {
                                                        Targets = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs
                                                            {
                                                                Id = "string",
                                                                Type = "string",
                                                                Urgency = "string",
                                                                ScheduleMode = "string",
                                                            },
                                                        },
                                                        TimeToAckIntervalCondition = "string",
                                                        TimeToAckSeconds = 0,
                                                        TimeToAckWeekdayIntervalConfigId = "string",
                                                    },
                                                    Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathRepeatArgs
                                                    {
                                                        RepeatTimes = 0,
                                                        ToNode = "string",
                                                    },
                                                },
                                            },
                                        },
                                        Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathLevelArgs
                                        {
                                            Targets = new[]
                                            {
                                                new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathLevelTargetArgs
                                                {
                                                    Id = "string",
                                                    Type = "string",
                                                    Urgency = "string",
                                                    ScheduleMode = "string",
                                                },
                                            },
                                            AckMode = "string",
                                            RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs
                                            {
                                                Enabled = false,
                                                RotateAfterSeconds = 0,
                                            },
                                            TimeToAckIntervalCondition = "string",
                                            TimeToAckSeconds = 0,
                                            TimeToAckWeekdayIntervalConfigId = "string",
                                        },
                                        NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathNotifyChannelArgs
                                        {
                                            Targets = new[]
                                            {
                                                new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs
                                                {
                                                    Id = "string",
                                                    Type = "string",
                                                    Urgency = "string",
                                                    ScheduleMode = "string",
                                                },
                                            },
                                            TimeToAckIntervalCondition = "string",
                                            TimeToAckSeconds = 0,
                                            TimeToAckWeekdayIntervalConfigId = "string",
                                        },
                                        Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseThenPathRepeatArgs
                                        {
                                            RepeatTimes = 0,
                                            ToNode = "string",
                                        },
                                    },
                                },
                                ElsePaths = new[]
                                {
                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathArgs
                                    {
                                        Type = "string",
                                        Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathDelayArgs
                                        {
                                            DelayIntervalCondition = "string",
                                            DelaySeconds = 0,
                                            DelayWeekdayIntervalConfigId = "string",
                                        },
                                        Id = "string",
                                        IfElse = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseArgs
                                        {
                                            Conditions = new[]
                                            {
                                                new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseConditionArgs
                                                {
                                                    Operation = "string",
                                                    ParamBindings = new[]
                                                    {
                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs
                                                        {
                                                            ArrayValues = new[]
                                                            {
                                                                new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs
                                                                {
                                                                    Literal = "string",
                                                                    Reference = "string",
                                                                },
                                                            },
                                                            Value = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs
                                                            {
                                                                Literal = "string",
                                                                Reference = "string",
                                                            },
                                                        },
                                                    },
                                                    Subject = "string",
                                                },
                                            },
                                            ThenPaths = new[]
                                            {
                                                new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathArgs
                                                {
                                                    Type = "string",
                                                    Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathDelayArgs
                                                    {
                                                        DelayIntervalCondition = "string",
                                                        DelaySeconds = 0,
                                                        DelayWeekdayIntervalConfigId = "string",
                                                    },
                                                    Id = "string",
                                                    IfElse = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseArgs
                                                    {
                                                        Conditions = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionArgs
                                                            {
                                                                Operation = "string",
                                                                ParamBindings = new[]
                                                                {
                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArgs
                                                                    {
                                                                        ArrayValues = new[]
                                                                        {
                                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArgs
                                                                            {
                                                                                Literal = "string",
                                                                                Reference = "string",
                                                                            },
                                                                        },
                                                                        Value = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingValueArgs
                                                                        {
                                                                            Literal = "string",
                                                                            Reference = "string",
                                                                        },
                                                                    },
                                                                },
                                                                Subject = "string",
                                                            },
                                                        },
                                                        ThenPaths = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathArgs
                                                            {
                                                                Type = "string",
                                                                Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathDelayArgs
                                                                {
                                                                    DelayIntervalCondition = "string",
                                                                    DelaySeconds = 0,
                                                                    DelayWeekdayIntervalConfigId = "string",
                                                                },
                                                                Id = "string",
                                                                IfElse = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseArgs
                                                                {
                                                                    Conditions = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionArgs
                                                                        {
                                                                            Operation = "string",
                                                                            ParamBindings = new[]
                                                                            {
                                                                                new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArgs
                                                                                {
                                                                                    ArrayValues = new[]
                                                                                    {
                                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs
                                                                                        {
                                                                                            Literal = "string",
                                                                                            Reference = "string",
                                                                                        },
                                                                                    },
                                                                                    Value = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingValueArgs
                                                                                    {
                                                                                        Literal = "string",
                                                                                        Reference = "string",
                                                                                    },
                                                                                },
                                                                            },
                                                                            Subject = "string",
                                                                        },
                                                                    },
                                                                    ThenPaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                    ElsePaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                },
                                                                Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    AckMode = "string",
                                                                    RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs
                                                                    {
                                                                        Enabled = false,
                                                                        RotateAfterSeconds = 0,
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathRepeatArgs
                                                                {
                                                                    RepeatTimes = 0,
                                                                    ToNode = "string",
                                                                },
                                                            },
                                                        },
                                                        ElsePaths = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathArgs
                                                            {
                                                                Type = "string",
                                                                Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathDelayArgs
                                                                {
                                                                    DelayIntervalCondition = "string",
                                                                    DelaySeconds = 0,
                                                                    DelayWeekdayIntervalConfigId = "string",
                                                                },
                                                                Id = "string",
                                                                IfElse = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseArgs
                                                                {
                                                                    Conditions = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionArgs
                                                                        {
                                                                            Operation = "string",
                                                                            ParamBindings = new[]
                                                                            {
                                                                                new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArgs
                                                                                {
                                                                                    ArrayValues = new[]
                                                                                    {
                                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs
                                                                                        {
                                                                                            Literal = "string",
                                                                                            Reference = "string",
                                                                                        },
                                                                                    },
                                                                                    Value = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingValueArgs
                                                                                    {
                                                                                        Literal = "string",
                                                                                        Reference = "string",
                                                                                    },
                                                                                },
                                                                            },
                                                                            Subject = "string",
                                                                        },
                                                                    },
                                                                    ThenPaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                    ElsePaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                },
                                                                Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    AckMode = "string",
                                                                    RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs
                                                                    {
                                                                        Enabled = false,
                                                                        RotateAfterSeconds = 0,
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathRepeatArgs
                                                                {
                                                                    RepeatTimes = 0,
                                                                    ToNode = "string",
                                                                },
                                                            },
                                                        },
                                                    },
                                                    Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathLevelArgs
                                                    {
                                                        Targets = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArgs
                                                            {
                                                                Id = "string",
                                                                Type = "string",
                                                                Urgency = "string",
                                                                ScheduleMode = "string",
                                                            },
                                                        },
                                                        AckMode = "string",
                                                        RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs
                                                        {
                                                            Enabled = false,
                                                            RotateAfterSeconds = 0,
                                                        },
                                                        TimeToAckIntervalCondition = "string",
                                                        TimeToAckSeconds = 0,
                                                        TimeToAckWeekdayIntervalConfigId = "string",
                                                    },
                                                    NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelArgs
                                                    {
                                                        Targets = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs
                                                            {
                                                                Id = "string",
                                                                Type = "string",
                                                                Urgency = "string",
                                                                ScheduleMode = "string",
                                                            },
                                                        },
                                                        TimeToAckIntervalCondition = "string",
                                                        TimeToAckSeconds = 0,
                                                        TimeToAckWeekdayIntervalConfigId = "string",
                                                    },
                                                    Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathRepeatArgs
                                                    {
                                                        RepeatTimes = 0,
                                                        ToNode = "string",
                                                    },
                                                },
                                            },
                                            ElsePaths = new[]
                                            {
                                                new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathArgs
                                                {
                                                    Type = "string",
                                                    Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs
                                                    {
                                                        DelayIntervalCondition = "string",
                                                        DelaySeconds = 0,
                                                        DelayWeekdayIntervalConfigId = "string",
                                                    },
                                                    Id = "string",
                                                    IfElse = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseArgs
                                                    {
                                                        Conditions = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionArgs
                                                            {
                                                                Operation = "string",
                                                                ParamBindings = new[]
                                                                {
                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs
                                                                    {
                                                                        ArrayValues = new[]
                                                                        {
                                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs
                                                                            {
                                                                                Literal = "string",
                                                                                Reference = "string",
                                                                            },
                                                                        },
                                                                        Value = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs
                                                                        {
                                                                            Literal = "string",
                                                                            Reference = "string",
                                                                        },
                                                                    },
                                                                },
                                                                Subject = "string",
                                                            },
                                                        },
                                                        ThenPaths = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathArgs
                                                            {
                                                                Type = "string",
                                                                Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathDelayArgs
                                                                {
                                                                    DelayIntervalCondition = "string",
                                                                    DelaySeconds = 0,
                                                                    DelayWeekdayIntervalConfigId = "string",
                                                                },
                                                                Id = "string",
                                                                IfElse = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseArgs
                                                                {
                                                                    Conditions = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionArgs
                                                                        {
                                                                            Operation = "string",
                                                                            ParamBindings = new[]
                                                                            {
                                                                                new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArgs
                                                                                {
                                                                                    ArrayValues = new[]
                                                                                    {
                                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArgs
                                                                                        {
                                                                                            Literal = "string",
                                                                                            Reference = "string",
                                                                                        },
                                                                                    },
                                                                                    Value = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingValueArgs
                                                                                    {
                                                                                        Literal = "string",
                                                                                        Reference = "string",
                                                                                    },
                                                                                },
                                                                            },
                                                                            Subject = "string",
                                                                        },
                                                                    },
                                                                    ThenPaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                    ElsePaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                },
                                                                Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    AckMode = "string",
                                                                    RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs
                                                                    {
                                                                        Enabled = false,
                                                                        RotateAfterSeconds = 0,
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathRepeatArgs
                                                                {
                                                                    RepeatTimes = 0,
                                                                    ToNode = "string",
                                                                },
                                                            },
                                                        },
                                                        ElsePaths = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathArgs
                                                            {
                                                                Type = "string",
                                                                Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs
                                                                {
                                                                    DelayIntervalCondition = "string",
                                                                    DelaySeconds = 0,
                                                                    DelayWeekdayIntervalConfigId = "string",
                                                                },
                                                                Id = "string",
                                                                IfElse = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseArgs
                                                                {
                                                                    Conditions = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionArgs
                                                                        {
                                                                            Operation = "string",
                                                                            ParamBindings = new[]
                                                                            {
                                                                                new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs
                                                                                {
                                                                                    ArrayValues = new[]
                                                                                    {
                                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs
                                                                                        {
                                                                                            Literal = "string",
                                                                                            Reference = "string",
                                                                                        },
                                                                                    },
                                                                                    Value = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs
                                                                                    {
                                                                                        Literal = "string",
                                                                                        Reference = "string",
                                                                                    },
                                                                                },
                                                                            },
                                                                            Subject = "string",
                                                                        },
                                                                    },
                                                                    ThenPaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                    ElsePaths = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathArgs
                                                                        {
                                                                            Type = "string",
                                                                            Delay = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs
                                                                            {
                                                                                DelayIntervalCondition = "string",
                                                                                DelaySeconds = 0,
                                                                                DelayWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Id = "string",
                                                                            Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                AckMode = "string",
                                                                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs
                                                                                {
                                                                                    Enabled = false,
                                                                                    RotateAfterSeconds = 0,
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelArgs
                                                                            {
                                                                                Targets = new[]
                                                                                {
                                                                                    new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs
                                                                                    {
                                                                                        Id = "string",
                                                                                        Type = "string",
                                                                                        Urgency = "string",
                                                                                        ScheduleMode = "string",
                                                                                    },
                                                                                },
                                                                                TimeToAckIntervalCondition = "string",
                                                                                TimeToAckSeconds = 0,
                                                                                TimeToAckWeekdayIntervalConfigId = "string",
                                                                            },
                                                                            Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathRepeatArgs
                                                                            {
                                                                                RepeatTimes = 0,
                                                                                ToNode = "string",
                                                                            },
                                                                        },
                                                                    },
                                                                },
                                                                Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    AckMode = "string",
                                                                    RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs
                                                                    {
                                                                        Enabled = false,
                                                                        RotateAfterSeconds = 0,
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelArgs
                                                                {
                                                                    Targets = new[]
                                                                    {
                                                                        new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs
                                                                        {
                                                                            Id = "string",
                                                                            Type = "string",
                                                                            Urgency = "string",
                                                                            ScheduleMode = "string",
                                                                        },
                                                                    },
                                                                    TimeToAckIntervalCondition = "string",
                                                                    TimeToAckSeconds = 0,
                                                                    TimeToAckWeekdayIntervalConfigId = "string",
                                                                },
                                                                Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathRepeatArgs
                                                                {
                                                                    RepeatTimes = 0,
                                                                    ToNode = "string",
                                                                },
                                                            },
                                                        },
                                                    },
                                                    Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathLevelArgs
                                                    {
                                                        Targets = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArgs
                                                            {
                                                                Id = "string",
                                                                Type = "string",
                                                                Urgency = "string",
                                                                ScheduleMode = "string",
                                                            },
                                                        },
                                                        AckMode = "string",
                                                        RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs
                                                        {
                                                            Enabled = false,
                                                            RotateAfterSeconds = 0,
                                                        },
                                                        TimeToAckIntervalCondition = "string",
                                                        TimeToAckSeconds = 0,
                                                        TimeToAckWeekdayIntervalConfigId = "string",
                                                    },
                                                    NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelArgs
                                                    {
                                                        Targets = new[]
                                                        {
                                                            new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs
                                                            {
                                                                Id = "string",
                                                                Type = "string",
                                                                Urgency = "string",
                                                                ScheduleMode = "string",
                                                            },
                                                        },
                                                        TimeToAckIntervalCondition = "string",
                                                        TimeToAckSeconds = 0,
                                                        TimeToAckWeekdayIntervalConfigId = "string",
                                                    },
                                                    Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathRepeatArgs
                                                    {
                                                        RepeatTimes = 0,
                                                        ToNode = "string",
                                                    },
                                                },
                                            },
                                        },
                                        Level = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathLevelArgs
                                        {
                                            Targets = new[]
                                            {
                                                new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathLevelTargetArgs
                                                {
                                                    Id = "string",
                                                    Type = "string",
                                                    Urgency = "string",
                                                    ScheduleMode = "string",
                                                },
                                            },
                                            AckMode = "string",
                                            RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs
                                            {
                                                Enabled = false,
                                                RotateAfterSeconds = 0,
                                            },
                                            TimeToAckIntervalCondition = "string",
                                            TimeToAckSeconds = 0,
                                            TimeToAckWeekdayIntervalConfigId = "string",
                                        },
                                        NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathNotifyChannelArgs
                                        {
                                            Targets = new[]
                                            {
                                                new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs
                                                {
                                                    Id = "string",
                                                    Type = "string",
                                                    Urgency = "string",
                                                    ScheduleMode = "string",
                                                },
                                            },
                                            TimeToAckIntervalCondition = "string",
                                            TimeToAckSeconds = 0,
                                            TimeToAckWeekdayIntervalConfigId = "string",
                                        },
                                        Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathIfElseElsePathRepeatArgs
                                        {
                                            RepeatTimes = 0,
                                            ToNode = "string",
                                        },
                                    },
                                },
                            },
                            Level = new Incident.Inputs.EscalationPathPathIfElseElsePathLevelArgs
                            {
                                Targets = new[]
                                {
                                    new Incident.Inputs.EscalationPathPathIfElseElsePathLevelTargetArgs
                                    {
                                        Id = "string",
                                        Type = "string",
                                        Urgency = "string",
                                        ScheduleMode = "string",
                                    },
                                },
                                AckMode = "string",
                                RoundRobinConfig = new Incident.Inputs.EscalationPathPathIfElseElsePathLevelRoundRobinConfigArgs
                                {
                                    Enabled = false,
                                    RotateAfterSeconds = 0,
                                },
                                TimeToAckIntervalCondition = "string",
                                TimeToAckSeconds = 0,
                                TimeToAckWeekdayIntervalConfigId = "string",
                            },
                            NotifyChannel = new Incident.Inputs.EscalationPathPathIfElseElsePathNotifyChannelArgs
                            {
                                Targets = new[]
                                {
                                    new Incident.Inputs.EscalationPathPathIfElseElsePathNotifyChannelTargetArgs
                                    {
                                        Id = "string",
                                        Type = "string",
                                        Urgency = "string",
                                        ScheduleMode = "string",
                                    },
                                },
                                TimeToAckIntervalCondition = "string",
                                TimeToAckSeconds = 0,
                                TimeToAckWeekdayIntervalConfigId = "string",
                            },
                            Repeat = new Incident.Inputs.EscalationPathPathIfElseElsePathRepeatArgs
                            {
                                RepeatTimes = 0,
                                ToNode = "string",
                            },
                        },
                    },
                },
                Level = new Incident.Inputs.EscalationPathPathLevelArgs
                {
                    Targets = new[]
                    {
                        new Incident.Inputs.EscalationPathPathLevelTargetArgs
                        {
                            Id = "string",
                            Type = "string",
                            Urgency = "string",
                            ScheduleMode = "string",
                        },
                    },
                    AckMode = "string",
                    RoundRobinConfig = new Incident.Inputs.EscalationPathPathLevelRoundRobinConfigArgs
                    {
                        Enabled = false,
                        RotateAfterSeconds = 0,
                    },
                    TimeToAckIntervalCondition = "string",
                    TimeToAckSeconds = 0,
                    TimeToAckWeekdayIntervalConfigId = "string",
                },
                NotifyChannel = new Incident.Inputs.EscalationPathPathNotifyChannelArgs
                {
                    Targets = new[]
                    {
                        new Incident.Inputs.EscalationPathPathNotifyChannelTargetArgs
                        {
                            Id = "string",
                            Type = "string",
                            Urgency = "string",
                            ScheduleMode = "string",
                        },
                    },
                    TimeToAckIntervalCondition = "string",
                    TimeToAckSeconds = 0,
                    TimeToAckWeekdayIntervalConfigId = "string",
                },
                Repeat = new Incident.Inputs.EscalationPathPathRepeatArgs
                {
                    RepeatTimes = 0,
                    ToNode = "string",
                },
            },
        },
        Name = "string",
        RepeatConfig = new Incident.Inputs.EscalationPathRepeatConfigArgs
        {
            DelayRepeatOnActivity = false,
            RepeatAfterSeconds = 0,
        },
        TeamIds = new[]
        {
            "string",
        },
        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{
    	Paths: incident.EscalationPathPathArray{
    		&incident.EscalationPathPathArgs{
    			Type: pulumi.String("string"),
    			Delay: &incident.EscalationPathPathDelayArgs{
    				DelayIntervalCondition:       pulumi.String("string"),
    				DelaySeconds:                 pulumi.Float64(0),
    				DelayWeekdayIntervalConfigId: pulumi.String("string"),
    			},
    			Id: pulumi.String("string"),
    			IfElse: &incident.EscalationPathPathIfElseArgs{
    				Conditions: incident.EscalationPathPathIfElseConditionArray{
    					&incident.EscalationPathPathIfElseConditionArgs{
    						Operation: pulumi.String("string"),
    						ParamBindings: incident.EscalationPathPathIfElseConditionParamBindingArray{
    							&incident.EscalationPathPathIfElseConditionParamBindingArgs{
    								ArrayValues: incident.EscalationPathPathIfElseConditionParamBindingArrayValueArray{
    									&incident.EscalationPathPathIfElseConditionParamBindingArrayValueArgs{
    										Literal:   pulumi.String("string"),
    										Reference: pulumi.String("string"),
    									},
    								},
    								Value: &incident.EscalationPathPathIfElseConditionParamBindingValueArgs{
    									Literal:   pulumi.String("string"),
    									Reference: pulumi.String("string"),
    								},
    							},
    						},
    						Subject: pulumi.String("string"),
    					},
    				},
    				ThenPaths: incident.EscalationPathPathIfElseThenPathArray{
    					&incident.EscalationPathPathIfElseThenPathArgs{
    						Type: pulumi.String("string"),
    						Delay: &incident.EscalationPathPathIfElseThenPathDelayArgs{
    							DelayIntervalCondition:       pulumi.String("string"),
    							DelaySeconds:                 pulumi.Float64(0),
    							DelayWeekdayIntervalConfigId: pulumi.String("string"),
    						},
    						Id: pulumi.String("string"),
    						IfElse: &incident.EscalationPathPathIfElseThenPathIfElseArgs{
    							Conditions: incident.EscalationPathPathIfElseThenPathIfElseConditionArray{
    								&incident.EscalationPathPathIfElseThenPathIfElseConditionArgs{
    									Operation: pulumi.String("string"),
    									ParamBindings: incident.EscalationPathPathIfElseThenPathIfElseConditionParamBindingArray{
    										&incident.EscalationPathPathIfElseThenPathIfElseConditionParamBindingArgs{
    											ArrayValues: incident.EscalationPathPathIfElseThenPathIfElseConditionParamBindingArrayValueArray{
    												&incident.EscalationPathPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs{
    													Literal:   pulumi.String("string"),
    													Reference: pulumi.String("string"),
    												},
    											},
    											Value: &incident.EscalationPathPathIfElseThenPathIfElseConditionParamBindingValueArgs{
    												Literal:   pulumi.String("string"),
    												Reference: pulumi.String("string"),
    											},
    										},
    									},
    									Subject: pulumi.String("string"),
    								},
    							},
    							ThenPaths: incident.EscalationPathPathIfElseThenPathIfElseThenPathArray{
    								&incident.EscalationPathPathIfElseThenPathIfElseThenPathArgs{
    									Type: pulumi.String("string"),
    									Delay: &incident.EscalationPathPathIfElseThenPathIfElseThenPathDelayArgs{
    										DelayIntervalCondition:       pulumi.String("string"),
    										DelaySeconds:                 pulumi.Float64(0),
    										DelayWeekdayIntervalConfigId: pulumi.String("string"),
    									},
    									Id: pulumi.String("string"),
    									IfElse: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseArgs{
    										Conditions: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseConditionArray{
    											&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseConditionArgs{
    												Operation: pulumi.String("string"),
    												ParamBindings: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArray{
    													&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArgs{
    														ArrayValues: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArray{
    															&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs{
    																Literal:   pulumi.String("string"),
    																Reference: pulumi.String("string"),
    															},
    														},
    														Value: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingValueArgs{
    															Literal:   pulumi.String("string"),
    															Reference: pulumi.String("string"),
    														},
    													},
    												},
    												Subject: pulumi.String("string"),
    											},
    										},
    										ThenPaths: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathArray{
    											&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathArgs{
    												Type: pulumi.String("string"),
    												Delay: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathDelayArgs{
    													DelayIntervalCondition:       pulumi.String("string"),
    													DelaySeconds:                 pulumi.Float64(0),
    													DelayWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												Id: pulumi.String("string"),
    												IfElse: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseArgs{
    													Conditions: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionArray{
    														&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionArgs{
    															Operation: pulumi.String("string"),
    															ParamBindings: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArray{
    																&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArgs{
    																	ArrayValues: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArray{
    																		&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs{
    																			Literal:   pulumi.String("string"),
    																			Reference: pulumi.String("string"),
    																		},
    																	},
    																	Value: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingValueArgs{
    																		Literal:   pulumi.String("string"),
    																		Reference: pulumi.String("string"),
    																	},
    																},
    															},
    															Subject: pulumi.String("string"),
    														},
    													},
    													ThenPaths: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathArray{
    														&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathArgs{
    															Type: pulumi.String("string"),
    															Delay: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathDelayArgs{
    																DelayIntervalCondition:       pulumi.String("string"),
    																DelaySeconds:                 pulumi.Float64(0),
    																DelayWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Id: pulumi.String("string"),
    															IfElse: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseArgs{
    																Conditions: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionArgs{
    																		Operation: pulumi.String("string"),
    																		ParamBindings: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArray{
    																			&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArgs{
    																				ArrayValues: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArray{
    																					&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs{
    																						Literal:   pulumi.String("string"),
    																						Reference: pulumi.String("string"),
    																					},
    																				},
    																				Value: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingValueArgs{
    																					Literal:   pulumi.String("string"),
    																					Reference: pulumi.String("string"),
    																				},
    																			},
    																		},
    																		Subject: pulumi.String("string"),
    																	},
    																},
    																ThenPaths: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    																ElsePaths: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    															},
    															Level: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelArgs{
    																Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																AckMode: pulumi.String("string"),
    																RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs{
    																	Enabled:            pulumi.Bool(false),
    																	RotateAfterSeconds: pulumi.Float64(0),
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelArgs{
    																Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Repeat: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathRepeatArgs{
    																RepeatTimes: pulumi.Float64(0),
    																ToNode:      pulumi.String("string"),
    															},
    														},
    													},
    													ElsePaths: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathArray{
    														&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathArgs{
    															Type: pulumi.String("string"),
    															Delay: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathDelayArgs{
    																DelayIntervalCondition:       pulumi.String("string"),
    																DelaySeconds:                 pulumi.Float64(0),
    																DelayWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Id: pulumi.String("string"),
    															IfElse: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseArgs{
    																Conditions: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionArgs{
    																		Operation: pulumi.String("string"),
    																		ParamBindings: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArray{
    																			&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArgs{
    																				ArrayValues: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArray{
    																					&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs{
    																						Literal:   pulumi.String("string"),
    																						Reference: pulumi.String("string"),
    																					},
    																				},
    																				Value: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingValueArgs{
    																					Literal:   pulumi.String("string"),
    																					Reference: pulumi.String("string"),
    																				},
    																			},
    																		},
    																		Subject: pulumi.String("string"),
    																	},
    																},
    																ThenPaths: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    																ElsePaths: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    															},
    															Level: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelArgs{
    																Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																AckMode: pulumi.String("string"),
    																RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs{
    																	Enabled:            pulumi.Bool(false),
    																	RotateAfterSeconds: pulumi.Float64(0),
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelArgs{
    																Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Repeat: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathRepeatArgs{
    																RepeatTimes: pulumi.Float64(0),
    																ToNode:      pulumi.String("string"),
    															},
    														},
    													},
    												},
    												Level: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathLevelArgs{
    													Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArray{
    														&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArgs{
    															Id:           pulumi.String("string"),
    															Type:         pulumi.String("string"),
    															Urgency:      pulumi.String("string"),
    															ScheduleMode: pulumi.String("string"),
    														},
    													},
    													AckMode: pulumi.String("string"),
    													RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs{
    														Enabled:            pulumi.Bool(false),
    														RotateAfterSeconds: pulumi.Float64(0),
    													},
    													TimeToAckIntervalCondition:       pulumi.String("string"),
    													TimeToAckSeconds:                 pulumi.Float64(0),
    													TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelArgs{
    													Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArray{
    														&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs{
    															Id:           pulumi.String("string"),
    															Type:         pulumi.String("string"),
    															Urgency:      pulumi.String("string"),
    															ScheduleMode: pulumi.String("string"),
    														},
    													},
    													TimeToAckIntervalCondition:       pulumi.String("string"),
    													TimeToAckSeconds:                 pulumi.Float64(0),
    													TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												Repeat: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathRepeatArgs{
    													RepeatTimes: pulumi.Float64(0),
    													ToNode:      pulumi.String("string"),
    												},
    											},
    										},
    										ElsePaths: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathArray{
    											&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathArgs{
    												Type: pulumi.String("string"),
    												Delay: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathDelayArgs{
    													DelayIntervalCondition:       pulumi.String("string"),
    													DelaySeconds:                 pulumi.Float64(0),
    													DelayWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												Id: pulumi.String("string"),
    												IfElse: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseArgs{
    													Conditions: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionArray{
    														&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionArgs{
    															Operation: pulumi.String("string"),
    															ParamBindings: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArray{
    																&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArgs{
    																	ArrayValues: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArray{
    																		&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs{
    																			Literal:   pulumi.String("string"),
    																			Reference: pulumi.String("string"),
    																		},
    																	},
    																	Value: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingValueArgs{
    																		Literal:   pulumi.String("string"),
    																		Reference: pulumi.String("string"),
    																	},
    																},
    															},
    															Subject: pulumi.String("string"),
    														},
    													},
    													ThenPaths: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathArray{
    														&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathArgs{
    															Type: pulumi.String("string"),
    															Delay: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathDelayArgs{
    																DelayIntervalCondition:       pulumi.String("string"),
    																DelaySeconds:                 pulumi.Float64(0),
    																DelayWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Id: pulumi.String("string"),
    															IfElse: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseArgs{
    																Conditions: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionArgs{
    																		Operation: pulumi.String("string"),
    																		ParamBindings: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArray{
    																			&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArgs{
    																				ArrayValues: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArray{
    																					&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArgs{
    																						Literal:   pulumi.String("string"),
    																						Reference: pulumi.String("string"),
    																					},
    																				},
    																				Value: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingValueArgs{
    																					Literal:   pulumi.String("string"),
    																					Reference: pulumi.String("string"),
    																				},
    																			},
    																		},
    																		Subject: pulumi.String("string"),
    																	},
    																},
    																ThenPaths: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    																ElsePaths: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    															},
    															Level: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelArgs{
    																Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																AckMode: pulumi.String("string"),
    																RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs{
    																	Enabled:            pulumi.Bool(false),
    																	RotateAfterSeconds: pulumi.Float64(0),
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelArgs{
    																Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Repeat: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathRepeatArgs{
    																RepeatTimes: pulumi.Float64(0),
    																ToNode:      pulumi.String("string"),
    															},
    														},
    													},
    													ElsePaths: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathArray{
    														&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathArgs{
    															Type: pulumi.String("string"),
    															Delay: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathDelayArgs{
    																DelayIntervalCondition:       pulumi.String("string"),
    																DelaySeconds:                 pulumi.Float64(0),
    																DelayWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Id: pulumi.String("string"),
    															IfElse: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseArgs{
    																Conditions: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionArgs{
    																		Operation: pulumi.String("string"),
    																		ParamBindings: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArray{
    																			&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs{
    																				ArrayValues: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArray{
    																					&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs{
    																						Literal:   pulumi.String("string"),
    																						Reference: pulumi.String("string"),
    																					},
    																				},
    																				Value: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs{
    																					Literal:   pulumi.String("string"),
    																					Reference: pulumi.String("string"),
    																				},
    																			},
    																		},
    																		Subject: pulumi.String("string"),
    																	},
    																},
    																ThenPaths: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    																ElsePaths: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    															},
    															Level: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelArgs{
    																Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																AckMode: pulumi.String("string"),
    																RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs{
    																	Enabled:            pulumi.Bool(false),
    																	RotateAfterSeconds: pulumi.Float64(0),
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelArgs{
    																Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Repeat: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathRepeatArgs{
    																RepeatTimes: pulumi.Float64(0),
    																ToNode:      pulumi.String("string"),
    															},
    														},
    													},
    												},
    												Level: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathLevelArgs{
    													Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArray{
    														&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArgs{
    															Id:           pulumi.String("string"),
    															Type:         pulumi.String("string"),
    															Urgency:      pulumi.String("string"),
    															ScheduleMode: pulumi.String("string"),
    														},
    													},
    													AckMode: pulumi.String("string"),
    													RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs{
    														Enabled:            pulumi.Bool(false),
    														RotateAfterSeconds: pulumi.Float64(0),
    													},
    													TimeToAckIntervalCondition:       pulumi.String("string"),
    													TimeToAckSeconds:                 pulumi.Float64(0),
    													TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelArgs{
    													Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArray{
    														&incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs{
    															Id:           pulumi.String("string"),
    															Type:         pulumi.String("string"),
    															Urgency:      pulumi.String("string"),
    															ScheduleMode: pulumi.String("string"),
    														},
    													},
    													TimeToAckIntervalCondition:       pulumi.String("string"),
    													TimeToAckSeconds:                 pulumi.Float64(0),
    													TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												Repeat: &incident.EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathRepeatArgs{
    													RepeatTimes: pulumi.Float64(0),
    													ToNode:      pulumi.String("string"),
    												},
    											},
    										},
    									},
    									Level: &incident.EscalationPathPathIfElseThenPathIfElseThenPathLevelArgs{
    										Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathLevelTargetArray{
    											&incident.EscalationPathPathIfElseThenPathIfElseThenPathLevelTargetArgs{
    												Id:           pulumi.String("string"),
    												Type:         pulumi.String("string"),
    												Urgency:      pulumi.String("string"),
    												ScheduleMode: pulumi.String("string"),
    											},
    										},
    										AckMode: pulumi.String("string"),
    										RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs{
    											Enabled:            pulumi.Bool(false),
    											RotateAfterSeconds: pulumi.Float64(0),
    										},
    										TimeToAckIntervalCondition:       pulumi.String("string"),
    										TimeToAckSeconds:                 pulumi.Float64(0),
    										TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    									},
    									NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseThenPathNotifyChannelArgs{
    										Targets: incident.EscalationPathPathIfElseThenPathIfElseThenPathNotifyChannelTargetArray{
    											&incident.EscalationPathPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs{
    												Id:           pulumi.String("string"),
    												Type:         pulumi.String("string"),
    												Urgency:      pulumi.String("string"),
    												ScheduleMode: pulumi.String("string"),
    											},
    										},
    										TimeToAckIntervalCondition:       pulumi.String("string"),
    										TimeToAckSeconds:                 pulumi.Float64(0),
    										TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    									},
    									Repeat: &incident.EscalationPathPathIfElseThenPathIfElseThenPathRepeatArgs{
    										RepeatTimes: pulumi.Float64(0),
    										ToNode:      pulumi.String("string"),
    									},
    								},
    							},
    							ElsePaths: incident.EscalationPathPathIfElseThenPathIfElseElsePathArray{
    								&incident.EscalationPathPathIfElseThenPathIfElseElsePathArgs{
    									Type: pulumi.String("string"),
    									Delay: &incident.EscalationPathPathIfElseThenPathIfElseElsePathDelayArgs{
    										DelayIntervalCondition:       pulumi.String("string"),
    										DelaySeconds:                 pulumi.Float64(0),
    										DelayWeekdayIntervalConfigId: pulumi.String("string"),
    									},
    									Id: pulumi.String("string"),
    									IfElse: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseArgs{
    										Conditions: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseConditionArray{
    											&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseConditionArgs{
    												Operation: pulumi.String("string"),
    												ParamBindings: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArray{
    													&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArgs{
    														ArrayValues: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArray{
    															&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs{
    																Literal:   pulumi.String("string"),
    																Reference: pulumi.String("string"),
    															},
    														},
    														Value: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingValueArgs{
    															Literal:   pulumi.String("string"),
    															Reference: pulumi.String("string"),
    														},
    													},
    												},
    												Subject: pulumi.String("string"),
    											},
    										},
    										ThenPaths: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathArray{
    											&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathArgs{
    												Type: pulumi.String("string"),
    												Delay: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathDelayArgs{
    													DelayIntervalCondition:       pulumi.String("string"),
    													DelaySeconds:                 pulumi.Float64(0),
    													DelayWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												Id: pulumi.String("string"),
    												IfElse: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseArgs{
    													Conditions: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionArray{
    														&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionArgs{
    															Operation: pulumi.String("string"),
    															ParamBindings: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArray{
    																&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArgs{
    																	ArrayValues: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArray{
    																		&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArgs{
    																			Literal:   pulumi.String("string"),
    																			Reference: pulumi.String("string"),
    																		},
    																	},
    																	Value: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingValueArgs{
    																		Literal:   pulumi.String("string"),
    																		Reference: pulumi.String("string"),
    																	},
    																},
    															},
    															Subject: pulumi.String("string"),
    														},
    													},
    													ThenPaths: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathArray{
    														&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathArgs{
    															Type: pulumi.String("string"),
    															Delay: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathDelayArgs{
    																DelayIntervalCondition:       pulumi.String("string"),
    																DelaySeconds:                 pulumi.Float64(0),
    																DelayWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Id: pulumi.String("string"),
    															IfElse: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseArgs{
    																Conditions: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionArgs{
    																		Operation: pulumi.String("string"),
    																		ParamBindings: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArray{
    																			&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArgs{
    																				ArrayValues: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArray{
    																					&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs{
    																						Literal:   pulumi.String("string"),
    																						Reference: pulumi.String("string"),
    																					},
    																				},
    																				Value: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingValueArgs{
    																					Literal:   pulumi.String("string"),
    																					Reference: pulumi.String("string"),
    																				},
    																			},
    																		},
    																		Subject: pulumi.String("string"),
    																	},
    																},
    																ThenPaths: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    																ElsePaths: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    															},
    															Level: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelArgs{
    																Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																AckMode: pulumi.String("string"),
    																RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs{
    																	Enabled:            pulumi.Bool(false),
    																	RotateAfterSeconds: pulumi.Float64(0),
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelArgs{
    																Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Repeat: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathRepeatArgs{
    																RepeatTimes: pulumi.Float64(0),
    																ToNode:      pulumi.String("string"),
    															},
    														},
    													},
    													ElsePaths: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathArray{
    														&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathArgs{
    															Type: pulumi.String("string"),
    															Delay: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathDelayArgs{
    																DelayIntervalCondition:       pulumi.String("string"),
    																DelaySeconds:                 pulumi.Float64(0),
    																DelayWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Id: pulumi.String("string"),
    															IfElse: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseArgs{
    																Conditions: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionArgs{
    																		Operation: pulumi.String("string"),
    																		ParamBindings: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArray{
    																			&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArgs{
    																				ArrayValues: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArray{
    																					&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs{
    																						Literal:   pulumi.String("string"),
    																						Reference: pulumi.String("string"),
    																					},
    																				},
    																				Value: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingValueArgs{
    																					Literal:   pulumi.String("string"),
    																					Reference: pulumi.String("string"),
    																				},
    																			},
    																		},
    																		Subject: pulumi.String("string"),
    																	},
    																},
    																ThenPaths: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    																ElsePaths: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    															},
    															Level: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelArgs{
    																Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																AckMode: pulumi.String("string"),
    																RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs{
    																	Enabled:            pulumi.Bool(false),
    																	RotateAfterSeconds: pulumi.Float64(0),
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelArgs{
    																Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Repeat: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathRepeatArgs{
    																RepeatTimes: pulumi.Float64(0),
    																ToNode:      pulumi.String("string"),
    															},
    														},
    													},
    												},
    												Level: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathLevelArgs{
    													Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArray{
    														&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArgs{
    															Id:           pulumi.String("string"),
    															Type:         pulumi.String("string"),
    															Urgency:      pulumi.String("string"),
    															ScheduleMode: pulumi.String("string"),
    														},
    													},
    													AckMode: pulumi.String("string"),
    													RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs{
    														Enabled:            pulumi.Bool(false),
    														RotateAfterSeconds: pulumi.Float64(0),
    													},
    													TimeToAckIntervalCondition:       pulumi.String("string"),
    													TimeToAckSeconds:                 pulumi.Float64(0),
    													TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelArgs{
    													Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArray{
    														&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs{
    															Id:           pulumi.String("string"),
    															Type:         pulumi.String("string"),
    															Urgency:      pulumi.String("string"),
    															ScheduleMode: pulumi.String("string"),
    														},
    													},
    													TimeToAckIntervalCondition:       pulumi.String("string"),
    													TimeToAckSeconds:                 pulumi.Float64(0),
    													TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												Repeat: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathRepeatArgs{
    													RepeatTimes: pulumi.Float64(0),
    													ToNode:      pulumi.String("string"),
    												},
    											},
    										},
    										ElsePaths: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathArray{
    											&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathArgs{
    												Type: pulumi.String("string"),
    												Delay: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathDelayArgs{
    													DelayIntervalCondition:       pulumi.String("string"),
    													DelaySeconds:                 pulumi.Float64(0),
    													DelayWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												Id: pulumi.String("string"),
    												IfElse: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseArgs{
    													Conditions: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionArray{
    														&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionArgs{
    															Operation: pulumi.String("string"),
    															ParamBindings: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArray{
    																&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs{
    																	ArrayValues: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArray{
    																		&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs{
    																			Literal:   pulumi.String("string"),
    																			Reference: pulumi.String("string"),
    																		},
    																	},
    																	Value: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs{
    																		Literal:   pulumi.String("string"),
    																		Reference: pulumi.String("string"),
    																	},
    																},
    															},
    															Subject: pulumi.String("string"),
    														},
    													},
    													ThenPaths: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathArray{
    														&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathArgs{
    															Type: pulumi.String("string"),
    															Delay: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathDelayArgs{
    																DelayIntervalCondition:       pulumi.String("string"),
    																DelaySeconds:                 pulumi.Float64(0),
    																DelayWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Id: pulumi.String("string"),
    															IfElse: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseArgs{
    																Conditions: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionArgs{
    																		Operation: pulumi.String("string"),
    																		ParamBindings: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArray{
    																			&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArgs{
    																				ArrayValues: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArray{
    																					&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArgs{
    																						Literal:   pulumi.String("string"),
    																						Reference: pulumi.String("string"),
    																					},
    																				},
    																				Value: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingValueArgs{
    																					Literal:   pulumi.String("string"),
    																					Reference: pulumi.String("string"),
    																				},
    																			},
    																		},
    																		Subject: pulumi.String("string"),
    																	},
    																},
    																ThenPaths: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    																ElsePaths: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    															},
    															Level: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelArgs{
    																Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																AckMode: pulumi.String("string"),
    																RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs{
    																	Enabled:            pulumi.Bool(false),
    																	RotateAfterSeconds: pulumi.Float64(0),
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelArgs{
    																Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Repeat: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathRepeatArgs{
    																RepeatTimes: pulumi.Float64(0),
    																ToNode:      pulumi.String("string"),
    															},
    														},
    													},
    													ElsePaths: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathArray{
    														&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathArgs{
    															Type: pulumi.String("string"),
    															Delay: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs{
    																DelayIntervalCondition:       pulumi.String("string"),
    																DelaySeconds:                 pulumi.Float64(0),
    																DelayWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Id: pulumi.String("string"),
    															IfElse: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseArgs{
    																Conditions: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionArgs{
    																		Operation: pulumi.String("string"),
    																		ParamBindings: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArray{
    																			&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs{
    																				ArrayValues: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArray{
    																					&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs{
    																						Literal:   pulumi.String("string"),
    																						Reference: pulumi.String("string"),
    																					},
    																				},
    																				Value: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs{
    																					Literal:   pulumi.String("string"),
    																					Reference: pulumi.String("string"),
    																				},
    																			},
    																		},
    																		Subject: pulumi.String("string"),
    																	},
    																},
    																ThenPaths: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    																ElsePaths: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    															},
    															Level: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelArgs{
    																Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																AckMode: pulumi.String("string"),
    																RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs{
    																	Enabled:            pulumi.Bool(false),
    																	RotateAfterSeconds: pulumi.Float64(0),
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelArgs{
    																Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArray{
    																	&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Repeat: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathRepeatArgs{
    																RepeatTimes: pulumi.Float64(0),
    																ToNode:      pulumi.String("string"),
    															},
    														},
    													},
    												},
    												Level: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathLevelArgs{
    													Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArray{
    														&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArgs{
    															Id:           pulumi.String("string"),
    															Type:         pulumi.String("string"),
    															Urgency:      pulumi.String("string"),
    															ScheduleMode: pulumi.String("string"),
    														},
    													},
    													AckMode: pulumi.String("string"),
    													RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs{
    														Enabled:            pulumi.Bool(false),
    														RotateAfterSeconds: pulumi.Float64(0),
    													},
    													TimeToAckIntervalCondition:       pulumi.String("string"),
    													TimeToAckSeconds:                 pulumi.Float64(0),
    													TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelArgs{
    													Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArray{
    														&incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs{
    															Id:           pulumi.String("string"),
    															Type:         pulumi.String("string"),
    															Urgency:      pulumi.String("string"),
    															ScheduleMode: pulumi.String("string"),
    														},
    													},
    													TimeToAckIntervalCondition:       pulumi.String("string"),
    													TimeToAckSeconds:                 pulumi.Float64(0),
    													TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												Repeat: &incident.EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathRepeatArgs{
    													RepeatTimes: pulumi.Float64(0),
    													ToNode:      pulumi.String("string"),
    												},
    											},
    										},
    									},
    									Level: &incident.EscalationPathPathIfElseThenPathIfElseElsePathLevelArgs{
    										Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathLevelTargetArray{
    											&incident.EscalationPathPathIfElseThenPathIfElseElsePathLevelTargetArgs{
    												Id:           pulumi.String("string"),
    												Type:         pulumi.String("string"),
    												Urgency:      pulumi.String("string"),
    												ScheduleMode: pulumi.String("string"),
    											},
    										},
    										AckMode: pulumi.String("string"),
    										RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs{
    											Enabled:            pulumi.Bool(false),
    											RotateAfterSeconds: pulumi.Float64(0),
    										},
    										TimeToAckIntervalCondition:       pulumi.String("string"),
    										TimeToAckSeconds:                 pulumi.Float64(0),
    										TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    									},
    									NotifyChannel: &incident.EscalationPathPathIfElseThenPathIfElseElsePathNotifyChannelArgs{
    										Targets: incident.EscalationPathPathIfElseThenPathIfElseElsePathNotifyChannelTargetArray{
    											&incident.EscalationPathPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs{
    												Id:           pulumi.String("string"),
    												Type:         pulumi.String("string"),
    												Urgency:      pulumi.String("string"),
    												ScheduleMode: pulumi.String("string"),
    											},
    										},
    										TimeToAckIntervalCondition:       pulumi.String("string"),
    										TimeToAckSeconds:                 pulumi.Float64(0),
    										TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    									},
    									Repeat: &incident.EscalationPathPathIfElseThenPathIfElseElsePathRepeatArgs{
    										RepeatTimes: pulumi.Float64(0),
    										ToNode:      pulumi.String("string"),
    									},
    								},
    							},
    						},
    						Level: &incident.EscalationPathPathIfElseThenPathLevelArgs{
    							Targets: incident.EscalationPathPathIfElseThenPathLevelTargetArray{
    								&incident.EscalationPathPathIfElseThenPathLevelTargetArgs{
    									Id:           pulumi.String("string"),
    									Type:         pulumi.String("string"),
    									Urgency:      pulumi.String("string"),
    									ScheduleMode: pulumi.String("string"),
    								},
    							},
    							AckMode: pulumi.String("string"),
    							RoundRobinConfig: &incident.EscalationPathPathIfElseThenPathLevelRoundRobinConfigArgs{
    								Enabled:            pulumi.Bool(false),
    								RotateAfterSeconds: pulumi.Float64(0),
    							},
    							TimeToAckIntervalCondition:       pulumi.String("string"),
    							TimeToAckSeconds:                 pulumi.Float64(0),
    							TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    						},
    						NotifyChannel: &incident.EscalationPathPathIfElseThenPathNotifyChannelArgs{
    							Targets: incident.EscalationPathPathIfElseThenPathNotifyChannelTargetArray{
    								&incident.EscalationPathPathIfElseThenPathNotifyChannelTargetArgs{
    									Id:           pulumi.String("string"),
    									Type:         pulumi.String("string"),
    									Urgency:      pulumi.String("string"),
    									ScheduleMode: pulumi.String("string"),
    								},
    							},
    							TimeToAckIntervalCondition:       pulumi.String("string"),
    							TimeToAckSeconds:                 pulumi.Float64(0),
    							TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    						},
    						Repeat: &incident.EscalationPathPathIfElseThenPathRepeatArgs{
    							RepeatTimes: pulumi.Float64(0),
    							ToNode:      pulumi.String("string"),
    						},
    					},
    				},
    				ElsePaths: incident.EscalationPathPathIfElseElsePathArray{
    					&incident.EscalationPathPathIfElseElsePathArgs{
    						Type: pulumi.String("string"),
    						Delay: &incident.EscalationPathPathIfElseElsePathDelayArgs{
    							DelayIntervalCondition:       pulumi.String("string"),
    							DelaySeconds:                 pulumi.Float64(0),
    							DelayWeekdayIntervalConfigId: pulumi.String("string"),
    						},
    						Id: pulumi.String("string"),
    						IfElse: &incident.EscalationPathPathIfElseElsePathIfElseArgs{
    							Conditions: incident.EscalationPathPathIfElseElsePathIfElseConditionArray{
    								&incident.EscalationPathPathIfElseElsePathIfElseConditionArgs{
    									Operation: pulumi.String("string"),
    									ParamBindings: incident.EscalationPathPathIfElseElsePathIfElseConditionParamBindingArray{
    										&incident.EscalationPathPathIfElseElsePathIfElseConditionParamBindingArgs{
    											ArrayValues: incident.EscalationPathPathIfElseElsePathIfElseConditionParamBindingArrayValueArray{
    												&incident.EscalationPathPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs{
    													Literal:   pulumi.String("string"),
    													Reference: pulumi.String("string"),
    												},
    											},
    											Value: &incident.EscalationPathPathIfElseElsePathIfElseConditionParamBindingValueArgs{
    												Literal:   pulumi.String("string"),
    												Reference: pulumi.String("string"),
    											},
    										},
    									},
    									Subject: pulumi.String("string"),
    								},
    							},
    							ThenPaths: incident.EscalationPathPathIfElseElsePathIfElseThenPathArray{
    								&incident.EscalationPathPathIfElseElsePathIfElseThenPathArgs{
    									Type: pulumi.String("string"),
    									Delay: &incident.EscalationPathPathIfElseElsePathIfElseThenPathDelayArgs{
    										DelayIntervalCondition:       pulumi.String("string"),
    										DelaySeconds:                 pulumi.Float64(0),
    										DelayWeekdayIntervalConfigId: pulumi.String("string"),
    									},
    									Id: pulumi.String("string"),
    									IfElse: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseArgs{
    										Conditions: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseConditionArray{
    											&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseConditionArgs{
    												Operation: pulumi.String("string"),
    												ParamBindings: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArray{
    													&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArgs{
    														ArrayValues: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArray{
    															&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArgs{
    																Literal:   pulumi.String("string"),
    																Reference: pulumi.String("string"),
    															},
    														},
    														Value: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingValueArgs{
    															Literal:   pulumi.String("string"),
    															Reference: pulumi.String("string"),
    														},
    													},
    												},
    												Subject: pulumi.String("string"),
    											},
    										},
    										ThenPaths: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathArray{
    											&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathArgs{
    												Type: pulumi.String("string"),
    												Delay: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathDelayArgs{
    													DelayIntervalCondition:       pulumi.String("string"),
    													DelaySeconds:                 pulumi.Float64(0),
    													DelayWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												Id: pulumi.String("string"),
    												IfElse: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseArgs{
    													Conditions: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionArray{
    														&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionArgs{
    															Operation: pulumi.String("string"),
    															ParamBindings: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArray{
    																&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArgs{
    																	ArrayValues: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArray{
    																		&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs{
    																			Literal:   pulumi.String("string"),
    																			Reference: pulumi.String("string"),
    																		},
    																	},
    																	Value: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingValueArgs{
    																		Literal:   pulumi.String("string"),
    																		Reference: pulumi.String("string"),
    																	},
    																},
    															},
    															Subject: pulumi.String("string"),
    														},
    													},
    													ThenPaths: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathArray{
    														&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathArgs{
    															Type: pulumi.String("string"),
    															Delay: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathDelayArgs{
    																DelayIntervalCondition:       pulumi.String("string"),
    																DelaySeconds:                 pulumi.Float64(0),
    																DelayWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Id: pulumi.String("string"),
    															IfElse: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseArgs{
    																Conditions: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionArgs{
    																		Operation: pulumi.String("string"),
    																		ParamBindings: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArray{
    																			&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArgs{
    																				ArrayValues: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArray{
    																					&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs{
    																						Literal:   pulumi.String("string"),
    																						Reference: pulumi.String("string"),
    																					},
    																				},
    																				Value: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingValueArgs{
    																					Literal:   pulumi.String("string"),
    																					Reference: pulumi.String("string"),
    																				},
    																			},
    																		},
    																		Subject: pulumi.String("string"),
    																	},
    																},
    																ThenPaths: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    																ElsePaths: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    															},
    															Level: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelArgs{
    																Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																AckMode: pulumi.String("string"),
    																RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs{
    																	Enabled:            pulumi.Bool(false),
    																	RotateAfterSeconds: pulumi.Float64(0),
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelArgs{
    																Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Repeat: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathRepeatArgs{
    																RepeatTimes: pulumi.Float64(0),
    																ToNode:      pulumi.String("string"),
    															},
    														},
    													},
    													ElsePaths: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathArray{
    														&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathArgs{
    															Type: pulumi.String("string"),
    															Delay: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathDelayArgs{
    																DelayIntervalCondition:       pulumi.String("string"),
    																DelaySeconds:                 pulumi.Float64(0),
    																DelayWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Id: pulumi.String("string"),
    															IfElse: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseArgs{
    																Conditions: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionArgs{
    																		Operation: pulumi.String("string"),
    																		ParamBindings: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArray{
    																			&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArgs{
    																				ArrayValues: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArray{
    																					&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs{
    																						Literal:   pulumi.String("string"),
    																						Reference: pulumi.String("string"),
    																					},
    																				},
    																				Value: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingValueArgs{
    																					Literal:   pulumi.String("string"),
    																					Reference: pulumi.String("string"),
    																				},
    																			},
    																		},
    																		Subject: pulumi.String("string"),
    																	},
    																},
    																ThenPaths: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    																ElsePaths: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    															},
    															Level: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelArgs{
    																Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																AckMode: pulumi.String("string"),
    																RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs{
    																	Enabled:            pulumi.Bool(false),
    																	RotateAfterSeconds: pulumi.Float64(0),
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelArgs{
    																Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Repeat: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathRepeatArgs{
    																RepeatTimes: pulumi.Float64(0),
    																ToNode:      pulumi.String("string"),
    															},
    														},
    													},
    												},
    												Level: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathLevelArgs{
    													Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArray{
    														&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArgs{
    															Id:           pulumi.String("string"),
    															Type:         pulumi.String("string"),
    															Urgency:      pulumi.String("string"),
    															ScheduleMode: pulumi.String("string"),
    														},
    													},
    													AckMode: pulumi.String("string"),
    													RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs{
    														Enabled:            pulumi.Bool(false),
    														RotateAfterSeconds: pulumi.Float64(0),
    													},
    													TimeToAckIntervalCondition:       pulumi.String("string"),
    													TimeToAckSeconds:                 pulumi.Float64(0),
    													TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelArgs{
    													Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArray{
    														&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs{
    															Id:           pulumi.String("string"),
    															Type:         pulumi.String("string"),
    															Urgency:      pulumi.String("string"),
    															ScheduleMode: pulumi.String("string"),
    														},
    													},
    													TimeToAckIntervalCondition:       pulumi.String("string"),
    													TimeToAckSeconds:                 pulumi.Float64(0),
    													TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												Repeat: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathRepeatArgs{
    													RepeatTimes: pulumi.Float64(0),
    													ToNode:      pulumi.String("string"),
    												},
    											},
    										},
    										ElsePaths: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathArray{
    											&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathArgs{
    												Type: pulumi.String("string"),
    												Delay: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathDelayArgs{
    													DelayIntervalCondition:       pulumi.String("string"),
    													DelaySeconds:                 pulumi.Float64(0),
    													DelayWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												Id: pulumi.String("string"),
    												IfElse: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseArgs{
    													Conditions: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionArray{
    														&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionArgs{
    															Operation: pulumi.String("string"),
    															ParamBindings: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArray{
    																&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArgs{
    																	ArrayValues: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArray{
    																		&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs{
    																			Literal:   pulumi.String("string"),
    																			Reference: pulumi.String("string"),
    																		},
    																	},
    																	Value: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingValueArgs{
    																		Literal:   pulumi.String("string"),
    																		Reference: pulumi.String("string"),
    																	},
    																},
    															},
    															Subject: pulumi.String("string"),
    														},
    													},
    													ThenPaths: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathArray{
    														&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathArgs{
    															Type: pulumi.String("string"),
    															Delay: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathDelayArgs{
    																DelayIntervalCondition:       pulumi.String("string"),
    																DelaySeconds:                 pulumi.Float64(0),
    																DelayWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Id: pulumi.String("string"),
    															IfElse: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseArgs{
    																Conditions: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionArgs{
    																		Operation: pulumi.String("string"),
    																		ParamBindings: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArray{
    																			&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArgs{
    																				ArrayValues: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArray{
    																					&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArgs{
    																						Literal:   pulumi.String("string"),
    																						Reference: pulumi.String("string"),
    																					},
    																				},
    																				Value: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingValueArgs{
    																					Literal:   pulumi.String("string"),
    																					Reference: pulumi.String("string"),
    																				},
    																			},
    																		},
    																		Subject: pulumi.String("string"),
    																	},
    																},
    																ThenPaths: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    																ElsePaths: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    															},
    															Level: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelArgs{
    																Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																AckMode: pulumi.String("string"),
    																RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs{
    																	Enabled:            pulumi.Bool(false),
    																	RotateAfterSeconds: pulumi.Float64(0),
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelArgs{
    																Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Repeat: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathRepeatArgs{
    																RepeatTimes: pulumi.Float64(0),
    																ToNode:      pulumi.String("string"),
    															},
    														},
    													},
    													ElsePaths: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathArray{
    														&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathArgs{
    															Type: pulumi.String("string"),
    															Delay: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathDelayArgs{
    																DelayIntervalCondition:       pulumi.String("string"),
    																DelaySeconds:                 pulumi.Float64(0),
    																DelayWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Id: pulumi.String("string"),
    															IfElse: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseArgs{
    																Conditions: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionArgs{
    																		Operation: pulumi.String("string"),
    																		ParamBindings: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArray{
    																			&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs{
    																				ArrayValues: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArray{
    																					&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs{
    																						Literal:   pulumi.String("string"),
    																						Reference: pulumi.String("string"),
    																					},
    																				},
    																				Value: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs{
    																					Literal:   pulumi.String("string"),
    																					Reference: pulumi.String("string"),
    																				},
    																			},
    																		},
    																		Subject: pulumi.String("string"),
    																	},
    																},
    																ThenPaths: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    																ElsePaths: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    															},
    															Level: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelArgs{
    																Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																AckMode: pulumi.String("string"),
    																RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs{
    																	Enabled:            pulumi.Bool(false),
    																	RotateAfterSeconds: pulumi.Float64(0),
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelArgs{
    																Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Repeat: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathRepeatArgs{
    																RepeatTimes: pulumi.Float64(0),
    																ToNode:      pulumi.String("string"),
    															},
    														},
    													},
    												},
    												Level: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathLevelArgs{
    													Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArray{
    														&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArgs{
    															Id:           pulumi.String("string"),
    															Type:         pulumi.String("string"),
    															Urgency:      pulumi.String("string"),
    															ScheduleMode: pulumi.String("string"),
    														},
    													},
    													AckMode: pulumi.String("string"),
    													RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs{
    														Enabled:            pulumi.Bool(false),
    														RotateAfterSeconds: pulumi.Float64(0),
    													},
    													TimeToAckIntervalCondition:       pulumi.String("string"),
    													TimeToAckSeconds:                 pulumi.Float64(0),
    													TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelArgs{
    													Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArray{
    														&incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs{
    															Id:           pulumi.String("string"),
    															Type:         pulumi.String("string"),
    															Urgency:      pulumi.String("string"),
    															ScheduleMode: pulumi.String("string"),
    														},
    													},
    													TimeToAckIntervalCondition:       pulumi.String("string"),
    													TimeToAckSeconds:                 pulumi.Float64(0),
    													TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												Repeat: &incident.EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathRepeatArgs{
    													RepeatTimes: pulumi.Float64(0),
    													ToNode:      pulumi.String("string"),
    												},
    											},
    										},
    									},
    									Level: &incident.EscalationPathPathIfElseElsePathIfElseThenPathLevelArgs{
    										Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathLevelTargetArray{
    											&incident.EscalationPathPathIfElseElsePathIfElseThenPathLevelTargetArgs{
    												Id:           pulumi.String("string"),
    												Type:         pulumi.String("string"),
    												Urgency:      pulumi.String("string"),
    												ScheduleMode: pulumi.String("string"),
    											},
    										},
    										AckMode: pulumi.String("string"),
    										RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs{
    											Enabled:            pulumi.Bool(false),
    											RotateAfterSeconds: pulumi.Float64(0),
    										},
    										TimeToAckIntervalCondition:       pulumi.String("string"),
    										TimeToAckSeconds:                 pulumi.Float64(0),
    										TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    									},
    									NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseThenPathNotifyChannelArgs{
    										Targets: incident.EscalationPathPathIfElseElsePathIfElseThenPathNotifyChannelTargetArray{
    											&incident.EscalationPathPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs{
    												Id:           pulumi.String("string"),
    												Type:         pulumi.String("string"),
    												Urgency:      pulumi.String("string"),
    												ScheduleMode: pulumi.String("string"),
    											},
    										},
    										TimeToAckIntervalCondition:       pulumi.String("string"),
    										TimeToAckSeconds:                 pulumi.Float64(0),
    										TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    									},
    									Repeat: &incident.EscalationPathPathIfElseElsePathIfElseThenPathRepeatArgs{
    										RepeatTimes: pulumi.Float64(0),
    										ToNode:      pulumi.String("string"),
    									},
    								},
    							},
    							ElsePaths: incident.EscalationPathPathIfElseElsePathIfElseElsePathArray{
    								&incident.EscalationPathPathIfElseElsePathIfElseElsePathArgs{
    									Type: pulumi.String("string"),
    									Delay: &incident.EscalationPathPathIfElseElsePathIfElseElsePathDelayArgs{
    										DelayIntervalCondition:       pulumi.String("string"),
    										DelaySeconds:                 pulumi.Float64(0),
    										DelayWeekdayIntervalConfigId: pulumi.String("string"),
    									},
    									Id: pulumi.String("string"),
    									IfElse: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseArgs{
    										Conditions: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseConditionArray{
    											&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseConditionArgs{
    												Operation: pulumi.String("string"),
    												ParamBindings: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArray{
    													&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs{
    														ArrayValues: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArray{
    															&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs{
    																Literal:   pulumi.String("string"),
    																Reference: pulumi.String("string"),
    															},
    														},
    														Value: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs{
    															Literal:   pulumi.String("string"),
    															Reference: pulumi.String("string"),
    														},
    													},
    												},
    												Subject: pulumi.String("string"),
    											},
    										},
    										ThenPaths: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathArray{
    											&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathArgs{
    												Type: pulumi.String("string"),
    												Delay: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathDelayArgs{
    													DelayIntervalCondition:       pulumi.String("string"),
    													DelaySeconds:                 pulumi.Float64(0),
    													DelayWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												Id: pulumi.String("string"),
    												IfElse: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseArgs{
    													Conditions: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionArray{
    														&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionArgs{
    															Operation: pulumi.String("string"),
    															ParamBindings: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArray{
    																&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArgs{
    																	ArrayValues: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArray{
    																		&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArgs{
    																			Literal:   pulumi.String("string"),
    																			Reference: pulumi.String("string"),
    																		},
    																	},
    																	Value: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingValueArgs{
    																		Literal:   pulumi.String("string"),
    																		Reference: pulumi.String("string"),
    																	},
    																},
    															},
    															Subject: pulumi.String("string"),
    														},
    													},
    													ThenPaths: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathArray{
    														&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathArgs{
    															Type: pulumi.String("string"),
    															Delay: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathDelayArgs{
    																DelayIntervalCondition:       pulumi.String("string"),
    																DelaySeconds:                 pulumi.Float64(0),
    																DelayWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Id: pulumi.String("string"),
    															IfElse: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseArgs{
    																Conditions: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionArgs{
    																		Operation: pulumi.String("string"),
    																		ParamBindings: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArray{
    																			&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArgs{
    																				ArrayValues: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArray{
    																					&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs{
    																						Literal:   pulumi.String("string"),
    																						Reference: pulumi.String("string"),
    																					},
    																				},
    																				Value: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingValueArgs{
    																					Literal:   pulumi.String("string"),
    																					Reference: pulumi.String("string"),
    																				},
    																			},
    																		},
    																		Subject: pulumi.String("string"),
    																	},
    																},
    																ThenPaths: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    																ElsePaths: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    															},
    															Level: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelArgs{
    																Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																AckMode: pulumi.String("string"),
    																RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs{
    																	Enabled:            pulumi.Bool(false),
    																	RotateAfterSeconds: pulumi.Float64(0),
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelArgs{
    																Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Repeat: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathRepeatArgs{
    																RepeatTimes: pulumi.Float64(0),
    																ToNode:      pulumi.String("string"),
    															},
    														},
    													},
    													ElsePaths: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathArray{
    														&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathArgs{
    															Type: pulumi.String("string"),
    															Delay: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathDelayArgs{
    																DelayIntervalCondition:       pulumi.String("string"),
    																DelaySeconds:                 pulumi.Float64(0),
    																DelayWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Id: pulumi.String("string"),
    															IfElse: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseArgs{
    																Conditions: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionArgs{
    																		Operation: pulumi.String("string"),
    																		ParamBindings: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArray{
    																			&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArgs{
    																				ArrayValues: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArray{
    																					&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs{
    																						Literal:   pulumi.String("string"),
    																						Reference: pulumi.String("string"),
    																					},
    																				},
    																				Value: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingValueArgs{
    																					Literal:   pulumi.String("string"),
    																					Reference: pulumi.String("string"),
    																				},
    																			},
    																		},
    																		Subject: pulumi.String("string"),
    																	},
    																},
    																ThenPaths: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    																ElsePaths: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    															},
    															Level: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelArgs{
    																Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																AckMode: pulumi.String("string"),
    																RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs{
    																	Enabled:            pulumi.Bool(false),
    																	RotateAfterSeconds: pulumi.Float64(0),
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelArgs{
    																Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Repeat: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathRepeatArgs{
    																RepeatTimes: pulumi.Float64(0),
    																ToNode:      pulumi.String("string"),
    															},
    														},
    													},
    												},
    												Level: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathLevelArgs{
    													Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArray{
    														&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArgs{
    															Id:           pulumi.String("string"),
    															Type:         pulumi.String("string"),
    															Urgency:      pulumi.String("string"),
    															ScheduleMode: pulumi.String("string"),
    														},
    													},
    													AckMode: pulumi.String("string"),
    													RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs{
    														Enabled:            pulumi.Bool(false),
    														RotateAfterSeconds: pulumi.Float64(0),
    													},
    													TimeToAckIntervalCondition:       pulumi.String("string"),
    													TimeToAckSeconds:                 pulumi.Float64(0),
    													TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelArgs{
    													Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArray{
    														&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs{
    															Id:           pulumi.String("string"),
    															Type:         pulumi.String("string"),
    															Urgency:      pulumi.String("string"),
    															ScheduleMode: pulumi.String("string"),
    														},
    													},
    													TimeToAckIntervalCondition:       pulumi.String("string"),
    													TimeToAckSeconds:                 pulumi.Float64(0),
    													TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												Repeat: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathRepeatArgs{
    													RepeatTimes: pulumi.Float64(0),
    													ToNode:      pulumi.String("string"),
    												},
    											},
    										},
    										ElsePaths: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathArray{
    											&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathArgs{
    												Type: pulumi.String("string"),
    												Delay: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs{
    													DelayIntervalCondition:       pulumi.String("string"),
    													DelaySeconds:                 pulumi.Float64(0),
    													DelayWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												Id: pulumi.String("string"),
    												IfElse: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseArgs{
    													Conditions: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionArray{
    														&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionArgs{
    															Operation: pulumi.String("string"),
    															ParamBindings: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArray{
    																&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs{
    																	ArrayValues: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArray{
    																		&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs{
    																			Literal:   pulumi.String("string"),
    																			Reference: pulumi.String("string"),
    																		},
    																	},
    																	Value: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs{
    																		Literal:   pulumi.String("string"),
    																		Reference: pulumi.String("string"),
    																	},
    																},
    															},
    															Subject: pulumi.String("string"),
    														},
    													},
    													ThenPaths: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathArray{
    														&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathArgs{
    															Type: pulumi.String("string"),
    															Delay: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathDelayArgs{
    																DelayIntervalCondition:       pulumi.String("string"),
    																DelaySeconds:                 pulumi.Float64(0),
    																DelayWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Id: pulumi.String("string"),
    															IfElse: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseArgs{
    																Conditions: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionArgs{
    																		Operation: pulumi.String("string"),
    																		ParamBindings: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArray{
    																			&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArgs{
    																				ArrayValues: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArray{
    																					&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArgs{
    																						Literal:   pulumi.String("string"),
    																						Reference: pulumi.String("string"),
    																					},
    																				},
    																				Value: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingValueArgs{
    																					Literal:   pulumi.String("string"),
    																					Reference: pulumi.String("string"),
    																				},
    																			},
    																		},
    																		Subject: pulumi.String("string"),
    																	},
    																},
    																ThenPaths: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    																ElsePaths: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    															},
    															Level: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelArgs{
    																Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																AckMode: pulumi.String("string"),
    																RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs{
    																	Enabled:            pulumi.Bool(false),
    																	RotateAfterSeconds: pulumi.Float64(0),
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelArgs{
    																Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Repeat: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathRepeatArgs{
    																RepeatTimes: pulumi.Float64(0),
    																ToNode:      pulumi.String("string"),
    															},
    														},
    													},
    													ElsePaths: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathArray{
    														&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathArgs{
    															Type: pulumi.String("string"),
    															Delay: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs{
    																DelayIntervalCondition:       pulumi.String("string"),
    																DelaySeconds:                 pulumi.Float64(0),
    																DelayWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Id: pulumi.String("string"),
    															IfElse: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseArgs{
    																Conditions: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionArgs{
    																		Operation: pulumi.String("string"),
    																		ParamBindings: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArray{
    																			&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs{
    																				ArrayValues: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArray{
    																					&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs{
    																						Literal:   pulumi.String("string"),
    																						Reference: pulumi.String("string"),
    																					},
    																				},
    																				Value: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs{
    																					Literal:   pulumi.String("string"),
    																					Reference: pulumi.String("string"),
    																				},
    																			},
    																		},
    																		Subject: pulumi.String("string"),
    																	},
    																},
    																ThenPaths: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    																ElsePaths: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathArgs{
    																		Type: pulumi.String("string"),
    																		Delay: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs{
    																			DelayIntervalCondition:       pulumi.String("string"),
    																			DelaySeconds:                 pulumi.Float64(0),
    																			DelayWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Id: pulumi.String("string"),
    																		Level: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			AckMode: pulumi.String("string"),
    																			RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs{
    																				Enabled:            pulumi.Bool(false),
    																				RotateAfterSeconds: pulumi.Float64(0),
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelArgs{
    																			Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArray{
    																				&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs{
    																					Id:           pulumi.String("string"),
    																					Type:         pulumi.String("string"),
    																					Urgency:      pulumi.String("string"),
    																					ScheduleMode: pulumi.String("string"),
    																				},
    																			},
    																			TimeToAckIntervalCondition:       pulumi.String("string"),
    																			TimeToAckSeconds:                 pulumi.Float64(0),
    																			TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    																		},
    																		Repeat: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathRepeatArgs{
    																			RepeatTimes: pulumi.Float64(0),
    																			ToNode:      pulumi.String("string"),
    																		},
    																	},
    																},
    															},
    															Level: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelArgs{
    																Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																AckMode: pulumi.String("string"),
    																RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs{
    																	Enabled:            pulumi.Bool(false),
    																	RotateAfterSeconds: pulumi.Float64(0),
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelArgs{
    																Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArray{
    																	&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs{
    																		Id:           pulumi.String("string"),
    																		Type:         pulumi.String("string"),
    																		Urgency:      pulumi.String("string"),
    																		ScheduleMode: pulumi.String("string"),
    																	},
    																},
    																TimeToAckIntervalCondition:       pulumi.String("string"),
    																TimeToAckSeconds:                 pulumi.Float64(0),
    																TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    															},
    															Repeat: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathRepeatArgs{
    																RepeatTimes: pulumi.Float64(0),
    																ToNode:      pulumi.String("string"),
    															},
    														},
    													},
    												},
    												Level: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathLevelArgs{
    													Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArray{
    														&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArgs{
    															Id:           pulumi.String("string"),
    															Type:         pulumi.String("string"),
    															Urgency:      pulumi.String("string"),
    															ScheduleMode: pulumi.String("string"),
    														},
    													},
    													AckMode: pulumi.String("string"),
    													RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs{
    														Enabled:            pulumi.Bool(false),
    														RotateAfterSeconds: pulumi.Float64(0),
    													},
    													TimeToAckIntervalCondition:       pulumi.String("string"),
    													TimeToAckSeconds:                 pulumi.Float64(0),
    													TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelArgs{
    													Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArray{
    														&incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs{
    															Id:           pulumi.String("string"),
    															Type:         pulumi.String("string"),
    															Urgency:      pulumi.String("string"),
    															ScheduleMode: pulumi.String("string"),
    														},
    													},
    													TimeToAckIntervalCondition:       pulumi.String("string"),
    													TimeToAckSeconds:                 pulumi.Float64(0),
    													TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    												},
    												Repeat: &incident.EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathRepeatArgs{
    													RepeatTimes: pulumi.Float64(0),
    													ToNode:      pulumi.String("string"),
    												},
    											},
    										},
    									},
    									Level: &incident.EscalationPathPathIfElseElsePathIfElseElsePathLevelArgs{
    										Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathLevelTargetArray{
    											&incident.EscalationPathPathIfElseElsePathIfElseElsePathLevelTargetArgs{
    												Id:           pulumi.String("string"),
    												Type:         pulumi.String("string"),
    												Urgency:      pulumi.String("string"),
    												ScheduleMode: pulumi.String("string"),
    											},
    										},
    										AckMode: pulumi.String("string"),
    										RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs{
    											Enabled:            pulumi.Bool(false),
    											RotateAfterSeconds: pulumi.Float64(0),
    										},
    										TimeToAckIntervalCondition:       pulumi.String("string"),
    										TimeToAckSeconds:                 pulumi.Float64(0),
    										TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    									},
    									NotifyChannel: &incident.EscalationPathPathIfElseElsePathIfElseElsePathNotifyChannelArgs{
    										Targets: incident.EscalationPathPathIfElseElsePathIfElseElsePathNotifyChannelTargetArray{
    											&incident.EscalationPathPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs{
    												Id:           pulumi.String("string"),
    												Type:         pulumi.String("string"),
    												Urgency:      pulumi.String("string"),
    												ScheduleMode: pulumi.String("string"),
    											},
    										},
    										TimeToAckIntervalCondition:       pulumi.String("string"),
    										TimeToAckSeconds:                 pulumi.Float64(0),
    										TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    									},
    									Repeat: &incident.EscalationPathPathIfElseElsePathIfElseElsePathRepeatArgs{
    										RepeatTimes: pulumi.Float64(0),
    										ToNode:      pulumi.String("string"),
    									},
    								},
    							},
    						},
    						Level: &incident.EscalationPathPathIfElseElsePathLevelArgs{
    							Targets: incident.EscalationPathPathIfElseElsePathLevelTargetArray{
    								&incident.EscalationPathPathIfElseElsePathLevelTargetArgs{
    									Id:           pulumi.String("string"),
    									Type:         pulumi.String("string"),
    									Urgency:      pulumi.String("string"),
    									ScheduleMode: pulumi.String("string"),
    								},
    							},
    							AckMode: pulumi.String("string"),
    							RoundRobinConfig: &incident.EscalationPathPathIfElseElsePathLevelRoundRobinConfigArgs{
    								Enabled:            pulumi.Bool(false),
    								RotateAfterSeconds: pulumi.Float64(0),
    							},
    							TimeToAckIntervalCondition:       pulumi.String("string"),
    							TimeToAckSeconds:                 pulumi.Float64(0),
    							TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    						},
    						NotifyChannel: &incident.EscalationPathPathIfElseElsePathNotifyChannelArgs{
    							Targets: incident.EscalationPathPathIfElseElsePathNotifyChannelTargetArray{
    								&incident.EscalationPathPathIfElseElsePathNotifyChannelTargetArgs{
    									Id:           pulumi.String("string"),
    									Type:         pulumi.String("string"),
    									Urgency:      pulumi.String("string"),
    									ScheduleMode: pulumi.String("string"),
    								},
    							},
    							TimeToAckIntervalCondition:       pulumi.String("string"),
    							TimeToAckSeconds:                 pulumi.Float64(0),
    							TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    						},
    						Repeat: &incident.EscalationPathPathIfElseElsePathRepeatArgs{
    							RepeatTimes: pulumi.Float64(0),
    							ToNode:      pulumi.String("string"),
    						},
    					},
    				},
    			},
    			Level: &incident.EscalationPathPathLevelArgs{
    				Targets: incident.EscalationPathPathLevelTargetArray{
    					&incident.EscalationPathPathLevelTargetArgs{
    						Id:           pulumi.String("string"),
    						Type:         pulumi.String("string"),
    						Urgency:      pulumi.String("string"),
    						ScheduleMode: pulumi.String("string"),
    					},
    				},
    				AckMode: pulumi.String("string"),
    				RoundRobinConfig: &incident.EscalationPathPathLevelRoundRobinConfigArgs{
    					Enabled:            pulumi.Bool(false),
    					RotateAfterSeconds: pulumi.Float64(0),
    				},
    				TimeToAckIntervalCondition:       pulumi.String("string"),
    				TimeToAckSeconds:                 pulumi.Float64(0),
    				TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    			},
    			NotifyChannel: &incident.EscalationPathPathNotifyChannelArgs{
    				Targets: incident.EscalationPathPathNotifyChannelTargetArray{
    					&incident.EscalationPathPathNotifyChannelTargetArgs{
    						Id:           pulumi.String("string"),
    						Type:         pulumi.String("string"),
    						Urgency:      pulumi.String("string"),
    						ScheduleMode: pulumi.String("string"),
    					},
    				},
    				TimeToAckIntervalCondition:       pulumi.String("string"),
    				TimeToAckSeconds:                 pulumi.Float64(0),
    				TimeToAckWeekdayIntervalConfigId: pulumi.String("string"),
    			},
    			Repeat: &incident.EscalationPathPathRepeatArgs{
    				RepeatTimes: pulumi.Float64(0),
    				ToNode:      pulumi.String("string"),
    			},
    		},
    	},
    	Name: pulumi.String("string"),
    	RepeatConfig: &incident.EscalationPathRepeatConfigArgs{
    		DelayRepeatOnActivity: pulumi.Bool(false),
    		RepeatAfterSeconds:    pulumi.Float64(0),
    	},
    	TeamIds: pulumi.StringArray{
    		pulumi.String("string"),
    	},
    	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"),
    				},
    			},
    		},
    	},
    })
    
    var escalationPathResource = new EscalationPath("escalationPathResource", EscalationPathArgs.builder()
        .paths(EscalationPathPathArgs.builder()
            .type("string")
            .delay(EscalationPathPathDelayArgs.builder()
                .delayIntervalCondition("string")
                .delaySeconds(0.0)
                .delayWeekdayIntervalConfigId("string")
                .build())
            .id("string")
            .ifElse(EscalationPathPathIfElseArgs.builder()
                .conditions(EscalationPathPathIfElseConditionArgs.builder()
                    .operation("string")
                    .paramBindings(EscalationPathPathIfElseConditionParamBindingArgs.builder()
                        .arrayValues(EscalationPathPathIfElseConditionParamBindingArrayValueArgs.builder()
                            .literal("string")
                            .reference("string")
                            .build())
                        .value(EscalationPathPathIfElseConditionParamBindingValueArgs.builder()
                            .literal("string")
                            .reference("string")
                            .build())
                        .build())
                    .subject("string")
                    .build())
                .thenPaths(EscalationPathPathIfElseThenPathArgs.builder()
                    .type("string")
                    .delay(EscalationPathPathIfElseThenPathDelayArgs.builder()
                        .delayIntervalCondition("string")
                        .delaySeconds(0.0)
                        .delayWeekdayIntervalConfigId("string")
                        .build())
                    .id("string")
                    .ifElse(EscalationPathPathIfElseThenPathIfElseArgs.builder()
                        .conditions(EscalationPathPathIfElseThenPathIfElseConditionArgs.builder()
                            .operation("string")
                            .paramBindings(EscalationPathPathIfElseThenPathIfElseConditionParamBindingArgs.builder()
                                .arrayValues(EscalationPathPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs.builder()
                                    .literal("string")
                                    .reference("string")
                                    .build())
                                .value(EscalationPathPathIfElseThenPathIfElseConditionParamBindingValueArgs.builder()
                                    .literal("string")
                                    .reference("string")
                                    .build())
                                .build())
                            .subject("string")
                            .build())
                        .thenPaths(EscalationPathPathIfElseThenPathIfElseThenPathArgs.builder()
                            .type("string")
                            .delay(EscalationPathPathIfElseThenPathIfElseThenPathDelayArgs.builder()
                                .delayIntervalCondition("string")
                                .delaySeconds(0.0)
                                .delayWeekdayIntervalConfigId("string")
                                .build())
                            .id("string")
                            .ifElse(EscalationPathPathIfElseThenPathIfElseThenPathIfElseArgs.builder()
                                .conditions(EscalationPathPathIfElseThenPathIfElseThenPathIfElseConditionArgs.builder()
                                    .operation("string")
                                    .paramBindings(EscalationPathPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArgs.builder()
                                        .arrayValues(EscalationPathPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs.builder()
                                            .literal("string")
                                            .reference("string")
                                            .build())
                                        .value(EscalationPathPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingValueArgs.builder()
                                            .literal("string")
                                            .reference("string")
                                            .build())
                                        .build())
                                    .subject("string")
                                    .build())
                                .thenPaths(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathArgs.builder()
                                    .type("string")
                                    .delay(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathDelayArgs.builder()
                                        .delayIntervalCondition("string")
                                        .delaySeconds(0.0)
                                        .delayWeekdayIntervalConfigId("string")
                                        .build())
                                    .id("string")
                                    .ifElse(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseArgs.builder()
                                        .conditions(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionArgs.builder()
                                            .operation("string")
                                            .paramBindings(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArgs.builder()
                                                .arrayValues(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs.builder()
                                                    .literal("string")
                                                    .reference("string")
                                                    .build())
                                                .value(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingValueArgs.builder()
                                                    .literal("string")
                                                    .reference("string")
                                                    .build())
                                                .build())
                                            .subject("string")
                                            .build())
                                        .thenPaths(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathArgs.builder()
                                            .type("string")
                                            .delay(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathDelayArgs.builder()
                                                .delayIntervalCondition("string")
                                                .delaySeconds(0.0)
                                                .delayWeekdayIntervalConfigId("string")
                                                .build())
                                            .id("string")
                                            .ifElse(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseArgs.builder()
                                                .conditions(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionArgs.builder()
                                                    .operation("string")
                                                    .paramBindings(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArgs.builder()
                                                        .arrayValues(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .value(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .build())
                                                    .subject("string")
                                                    .build())
                                                .thenPaths(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .elsePaths(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .build())
                                            .level(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelArgs.builder()
                                                .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .ackMode("string")
                                                .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                    .enabled(false)
                                                    .rotateAfterSeconds(0.0)
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .notifyChannel(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelArgs.builder()
                                                .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .repeat(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathRepeatArgs.builder()
                                                .repeatTimes(0.0)
                                                .toNode("string")
                                                .build())
                                            .build())
                                        .elsePaths(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathArgs.builder()
                                            .type("string")
                                            .delay(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathDelayArgs.builder()
                                                .delayIntervalCondition("string")
                                                .delaySeconds(0.0)
                                                .delayWeekdayIntervalConfigId("string")
                                                .build())
                                            .id("string")
                                            .ifElse(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseArgs.builder()
                                                .conditions(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionArgs.builder()
                                                    .operation("string")
                                                    .paramBindings(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArgs.builder()
                                                        .arrayValues(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .value(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .build())
                                                    .subject("string")
                                                    .build())
                                                .thenPaths(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .elsePaths(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .build())
                                            .level(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelArgs.builder()
                                                .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .ackMode("string")
                                                .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                    .enabled(false)
                                                    .rotateAfterSeconds(0.0)
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .notifyChannel(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelArgs.builder()
                                                .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .repeat(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathRepeatArgs.builder()
                                                .repeatTimes(0.0)
                                                .toNode("string")
                                                .build())
                                            .build())
                                        .build())
                                    .level(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathLevelArgs.builder()
                                        .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArgs.builder()
                                            .id("string")
                                            .type("string")
                                            .urgency("string")
                                            .scheduleMode("string")
                                            .build())
                                        .ackMode("string")
                                        .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                            .enabled(false)
                                            .rotateAfterSeconds(0.0)
                                            .build())
                                        .timeToAckIntervalCondition("string")
                                        .timeToAckSeconds(0.0)
                                        .timeToAckWeekdayIntervalConfigId("string")
                                        .build())
                                    .notifyChannel(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelArgs.builder()
                                        .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs.builder()
                                            .id("string")
                                            .type("string")
                                            .urgency("string")
                                            .scheduleMode("string")
                                            .build())
                                        .timeToAckIntervalCondition("string")
                                        .timeToAckSeconds(0.0)
                                        .timeToAckWeekdayIntervalConfigId("string")
                                        .build())
                                    .repeat(EscalationPathPathIfElseThenPathIfElseThenPathIfElseThenPathRepeatArgs.builder()
                                        .repeatTimes(0.0)
                                        .toNode("string")
                                        .build())
                                    .build())
                                .elsePaths(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathArgs.builder()
                                    .type("string")
                                    .delay(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathDelayArgs.builder()
                                        .delayIntervalCondition("string")
                                        .delaySeconds(0.0)
                                        .delayWeekdayIntervalConfigId("string")
                                        .build())
                                    .id("string")
                                    .ifElse(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseArgs.builder()
                                        .conditions(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionArgs.builder()
                                            .operation("string")
                                            .paramBindings(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArgs.builder()
                                                .arrayValues(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs.builder()
                                                    .literal("string")
                                                    .reference("string")
                                                    .build())
                                                .value(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingValueArgs.builder()
                                                    .literal("string")
                                                    .reference("string")
                                                    .build())
                                                .build())
                                            .subject("string")
                                            .build())
                                        .thenPaths(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathArgs.builder()
                                            .type("string")
                                            .delay(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathDelayArgs.builder()
                                                .delayIntervalCondition("string")
                                                .delaySeconds(0.0)
                                                .delayWeekdayIntervalConfigId("string")
                                                .build())
                                            .id("string")
                                            .ifElse(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseArgs.builder()
                                                .conditions(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionArgs.builder()
                                                    .operation("string")
                                                    .paramBindings(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArgs.builder()
                                                        .arrayValues(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .value(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .build())
                                                    .subject("string")
                                                    .build())
                                                .thenPaths(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .elsePaths(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .build())
                                            .level(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelArgs.builder()
                                                .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .ackMode("string")
                                                .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                    .enabled(false)
                                                    .rotateAfterSeconds(0.0)
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .notifyChannel(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelArgs.builder()
                                                .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .repeat(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathRepeatArgs.builder()
                                                .repeatTimes(0.0)
                                                .toNode("string")
                                                .build())
                                            .build())
                                        .elsePaths(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathArgs.builder()
                                            .type("string")
                                            .delay(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathDelayArgs.builder()
                                                .delayIntervalCondition("string")
                                                .delaySeconds(0.0)
                                                .delayWeekdayIntervalConfigId("string")
                                                .build())
                                            .id("string")
                                            .ifElse(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseArgs.builder()
                                                .conditions(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionArgs.builder()
                                                    .operation("string")
                                                    .paramBindings(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs.builder()
                                                        .arrayValues(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .value(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .build())
                                                    .subject("string")
                                                    .build())
                                                .thenPaths(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .elsePaths(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .build())
                                            .level(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelArgs.builder()
                                                .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .ackMode("string")
                                                .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                    .enabled(false)
                                                    .rotateAfterSeconds(0.0)
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .notifyChannel(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelArgs.builder()
                                                .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .repeat(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathRepeatArgs.builder()
                                                .repeatTimes(0.0)
                                                .toNode("string")
                                                .build())
                                            .build())
                                        .build())
                                    .level(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathLevelArgs.builder()
                                        .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArgs.builder()
                                            .id("string")
                                            .type("string")
                                            .urgency("string")
                                            .scheduleMode("string")
                                            .build())
                                        .ackMode("string")
                                        .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                            .enabled(false)
                                            .rotateAfterSeconds(0.0)
                                            .build())
                                        .timeToAckIntervalCondition("string")
                                        .timeToAckSeconds(0.0)
                                        .timeToAckWeekdayIntervalConfigId("string")
                                        .build())
                                    .notifyChannel(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelArgs.builder()
                                        .targets(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs.builder()
                                            .id("string")
                                            .type("string")
                                            .urgency("string")
                                            .scheduleMode("string")
                                            .build())
                                        .timeToAckIntervalCondition("string")
                                        .timeToAckSeconds(0.0)
                                        .timeToAckWeekdayIntervalConfigId("string")
                                        .build())
                                    .repeat(EscalationPathPathIfElseThenPathIfElseThenPathIfElseElsePathRepeatArgs.builder()
                                        .repeatTimes(0.0)
                                        .toNode("string")
                                        .build())
                                    .build())
                                .build())
                            .level(EscalationPathPathIfElseThenPathIfElseThenPathLevelArgs.builder()
                                .targets(EscalationPathPathIfElseThenPathIfElseThenPathLevelTargetArgs.builder()
                                    .id("string")
                                    .type("string")
                                    .urgency("string")
                                    .scheduleMode("string")
                                    .build())
                                .ackMode("string")
                                .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                    .enabled(false)
                                    .rotateAfterSeconds(0.0)
                                    .build())
                                .timeToAckIntervalCondition("string")
                                .timeToAckSeconds(0.0)
                                .timeToAckWeekdayIntervalConfigId("string")
                                .build())
                            .notifyChannel(EscalationPathPathIfElseThenPathIfElseThenPathNotifyChannelArgs.builder()
                                .targets(EscalationPathPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs.builder()
                                    .id("string")
                                    .type("string")
                                    .urgency("string")
                                    .scheduleMode("string")
                                    .build())
                                .timeToAckIntervalCondition("string")
                                .timeToAckSeconds(0.0)
                                .timeToAckWeekdayIntervalConfigId("string")
                                .build())
                            .repeat(EscalationPathPathIfElseThenPathIfElseThenPathRepeatArgs.builder()
                                .repeatTimes(0.0)
                                .toNode("string")
                                .build())
                            .build())
                        .elsePaths(EscalationPathPathIfElseThenPathIfElseElsePathArgs.builder()
                            .type("string")
                            .delay(EscalationPathPathIfElseThenPathIfElseElsePathDelayArgs.builder()
                                .delayIntervalCondition("string")
                                .delaySeconds(0.0)
                                .delayWeekdayIntervalConfigId("string")
                                .build())
                            .id("string")
                            .ifElse(EscalationPathPathIfElseThenPathIfElseElsePathIfElseArgs.builder()
                                .conditions(EscalationPathPathIfElseThenPathIfElseElsePathIfElseConditionArgs.builder()
                                    .operation("string")
                                    .paramBindings(EscalationPathPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArgs.builder()
                                        .arrayValues(EscalationPathPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs.builder()
                                            .literal("string")
                                            .reference("string")
                                            .build())
                                        .value(EscalationPathPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingValueArgs.builder()
                                            .literal("string")
                                            .reference("string")
                                            .build())
                                        .build())
                                    .subject("string")
                                    .build())
                                .thenPaths(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathArgs.builder()
                                    .type("string")
                                    .delay(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathDelayArgs.builder()
                                        .delayIntervalCondition("string")
                                        .delaySeconds(0.0)
                                        .delayWeekdayIntervalConfigId("string")
                                        .build())
                                    .id("string")
                                    .ifElse(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseArgs.builder()
                                        .conditions(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionArgs.builder()
                                            .operation("string")
                                            .paramBindings(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArgs.builder()
                                                .arrayValues(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArgs.builder()
                                                    .literal("string")
                                                    .reference("string")
                                                    .build())
                                                .value(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingValueArgs.builder()
                                                    .literal("string")
                                                    .reference("string")
                                                    .build())
                                                .build())
                                            .subject("string")
                                            .build())
                                        .thenPaths(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathArgs.builder()
                                            .type("string")
                                            .delay(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathDelayArgs.builder()
                                                .delayIntervalCondition("string")
                                                .delaySeconds(0.0)
                                                .delayWeekdayIntervalConfigId("string")
                                                .build())
                                            .id("string")
                                            .ifElse(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseArgs.builder()
                                                .conditions(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionArgs.builder()
                                                    .operation("string")
                                                    .paramBindings(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArgs.builder()
                                                        .arrayValues(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .value(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .build())
                                                    .subject("string")
                                                    .build())
                                                .thenPaths(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .elsePaths(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .build())
                                            .level(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelArgs.builder()
                                                .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .ackMode("string")
                                                .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                    .enabled(false)
                                                    .rotateAfterSeconds(0.0)
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .notifyChannel(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelArgs.builder()
                                                .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .repeat(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathRepeatArgs.builder()
                                                .repeatTimes(0.0)
                                                .toNode("string")
                                                .build())
                                            .build())
                                        .elsePaths(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathArgs.builder()
                                            .type("string")
                                            .delay(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathDelayArgs.builder()
                                                .delayIntervalCondition("string")
                                                .delaySeconds(0.0)
                                                .delayWeekdayIntervalConfigId("string")
                                                .build())
                                            .id("string")
                                            .ifElse(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseArgs.builder()
                                                .conditions(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionArgs.builder()
                                                    .operation("string")
                                                    .paramBindings(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArgs.builder()
                                                        .arrayValues(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .value(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .build())
                                                    .subject("string")
                                                    .build())
                                                .thenPaths(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .elsePaths(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .build())
                                            .level(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelArgs.builder()
                                                .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .ackMode("string")
                                                .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                    .enabled(false)
                                                    .rotateAfterSeconds(0.0)
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .notifyChannel(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelArgs.builder()
                                                .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .repeat(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathRepeatArgs.builder()
                                                .repeatTimes(0.0)
                                                .toNode("string")
                                                .build())
                                            .build())
                                        .build())
                                    .level(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathLevelArgs.builder()
                                        .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArgs.builder()
                                            .id("string")
                                            .type("string")
                                            .urgency("string")
                                            .scheduleMode("string")
                                            .build())
                                        .ackMode("string")
                                        .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                            .enabled(false)
                                            .rotateAfterSeconds(0.0)
                                            .build())
                                        .timeToAckIntervalCondition("string")
                                        .timeToAckSeconds(0.0)
                                        .timeToAckWeekdayIntervalConfigId("string")
                                        .build())
                                    .notifyChannel(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelArgs.builder()
                                        .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs.builder()
                                            .id("string")
                                            .type("string")
                                            .urgency("string")
                                            .scheduleMode("string")
                                            .build())
                                        .timeToAckIntervalCondition("string")
                                        .timeToAckSeconds(0.0)
                                        .timeToAckWeekdayIntervalConfigId("string")
                                        .build())
                                    .repeat(EscalationPathPathIfElseThenPathIfElseElsePathIfElseThenPathRepeatArgs.builder()
                                        .repeatTimes(0.0)
                                        .toNode("string")
                                        .build())
                                    .build())
                                .elsePaths(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathArgs.builder()
                                    .type("string")
                                    .delay(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathDelayArgs.builder()
                                        .delayIntervalCondition("string")
                                        .delaySeconds(0.0)
                                        .delayWeekdayIntervalConfigId("string")
                                        .build())
                                    .id("string")
                                    .ifElse(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseArgs.builder()
                                        .conditions(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionArgs.builder()
                                            .operation("string")
                                            .paramBindings(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs.builder()
                                                .arrayValues(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs.builder()
                                                    .literal("string")
                                                    .reference("string")
                                                    .build())
                                                .value(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs.builder()
                                                    .literal("string")
                                                    .reference("string")
                                                    .build())
                                                .build())
                                            .subject("string")
                                            .build())
                                        .thenPaths(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathArgs.builder()
                                            .type("string")
                                            .delay(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathDelayArgs.builder()
                                                .delayIntervalCondition("string")
                                                .delaySeconds(0.0)
                                                .delayWeekdayIntervalConfigId("string")
                                                .build())
                                            .id("string")
                                            .ifElse(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseArgs.builder()
                                                .conditions(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionArgs.builder()
                                                    .operation("string")
                                                    .paramBindings(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArgs.builder()
                                                        .arrayValues(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .value(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .build())
                                                    .subject("string")
                                                    .build())
                                                .thenPaths(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .elsePaths(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .build())
                                            .level(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelArgs.builder()
                                                .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .ackMode("string")
                                                .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                    .enabled(false)
                                                    .rotateAfterSeconds(0.0)
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .notifyChannel(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelArgs.builder()
                                                .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .repeat(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathRepeatArgs.builder()
                                                .repeatTimes(0.0)
                                                .toNode("string")
                                                .build())
                                            .build())
                                        .elsePaths(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathArgs.builder()
                                            .type("string")
                                            .delay(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs.builder()
                                                .delayIntervalCondition("string")
                                                .delaySeconds(0.0)
                                                .delayWeekdayIntervalConfigId("string")
                                                .build())
                                            .id("string")
                                            .ifElse(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseArgs.builder()
                                                .conditions(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionArgs.builder()
                                                    .operation("string")
                                                    .paramBindings(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs.builder()
                                                        .arrayValues(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .value(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .build())
                                                    .subject("string")
                                                    .build())
                                                .thenPaths(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .elsePaths(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .build())
                                            .level(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelArgs.builder()
                                                .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .ackMode("string")
                                                .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                    .enabled(false)
                                                    .rotateAfterSeconds(0.0)
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .notifyChannel(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelArgs.builder()
                                                .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .repeat(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathRepeatArgs.builder()
                                                .repeatTimes(0.0)
                                                .toNode("string")
                                                .build())
                                            .build())
                                        .build())
                                    .level(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathLevelArgs.builder()
                                        .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArgs.builder()
                                            .id("string")
                                            .type("string")
                                            .urgency("string")
                                            .scheduleMode("string")
                                            .build())
                                        .ackMode("string")
                                        .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                            .enabled(false)
                                            .rotateAfterSeconds(0.0)
                                            .build())
                                        .timeToAckIntervalCondition("string")
                                        .timeToAckSeconds(0.0)
                                        .timeToAckWeekdayIntervalConfigId("string")
                                        .build())
                                    .notifyChannel(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelArgs.builder()
                                        .targets(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs.builder()
                                            .id("string")
                                            .type("string")
                                            .urgency("string")
                                            .scheduleMode("string")
                                            .build())
                                        .timeToAckIntervalCondition("string")
                                        .timeToAckSeconds(0.0)
                                        .timeToAckWeekdayIntervalConfigId("string")
                                        .build())
                                    .repeat(EscalationPathPathIfElseThenPathIfElseElsePathIfElseElsePathRepeatArgs.builder()
                                        .repeatTimes(0.0)
                                        .toNode("string")
                                        .build())
                                    .build())
                                .build())
                            .level(EscalationPathPathIfElseThenPathIfElseElsePathLevelArgs.builder()
                                .targets(EscalationPathPathIfElseThenPathIfElseElsePathLevelTargetArgs.builder()
                                    .id("string")
                                    .type("string")
                                    .urgency("string")
                                    .scheduleMode("string")
                                    .build())
                                .ackMode("string")
                                .roundRobinConfig(EscalationPathPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                    .enabled(false)
                                    .rotateAfterSeconds(0.0)
                                    .build())
                                .timeToAckIntervalCondition("string")
                                .timeToAckSeconds(0.0)
                                .timeToAckWeekdayIntervalConfigId("string")
                                .build())
                            .notifyChannel(EscalationPathPathIfElseThenPathIfElseElsePathNotifyChannelArgs.builder()
                                .targets(EscalationPathPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs.builder()
                                    .id("string")
                                    .type("string")
                                    .urgency("string")
                                    .scheduleMode("string")
                                    .build())
                                .timeToAckIntervalCondition("string")
                                .timeToAckSeconds(0.0)
                                .timeToAckWeekdayIntervalConfigId("string")
                                .build())
                            .repeat(EscalationPathPathIfElseThenPathIfElseElsePathRepeatArgs.builder()
                                .repeatTimes(0.0)
                                .toNode("string")
                                .build())
                            .build())
                        .build())
                    .level(EscalationPathPathIfElseThenPathLevelArgs.builder()
                        .targets(EscalationPathPathIfElseThenPathLevelTargetArgs.builder()
                            .id("string")
                            .type("string")
                            .urgency("string")
                            .scheduleMode("string")
                            .build())
                        .ackMode("string")
                        .roundRobinConfig(EscalationPathPathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                            .enabled(false)
                            .rotateAfterSeconds(0.0)
                            .build())
                        .timeToAckIntervalCondition("string")
                        .timeToAckSeconds(0.0)
                        .timeToAckWeekdayIntervalConfigId("string")
                        .build())
                    .notifyChannel(EscalationPathPathIfElseThenPathNotifyChannelArgs.builder()
                        .targets(EscalationPathPathIfElseThenPathNotifyChannelTargetArgs.builder()
                            .id("string")
                            .type("string")
                            .urgency("string")
                            .scheduleMode("string")
                            .build())
                        .timeToAckIntervalCondition("string")
                        .timeToAckSeconds(0.0)
                        .timeToAckWeekdayIntervalConfigId("string")
                        .build())
                    .repeat(EscalationPathPathIfElseThenPathRepeatArgs.builder()
                        .repeatTimes(0.0)
                        .toNode("string")
                        .build())
                    .build())
                .elsePaths(EscalationPathPathIfElseElsePathArgs.builder()
                    .type("string")
                    .delay(EscalationPathPathIfElseElsePathDelayArgs.builder()
                        .delayIntervalCondition("string")
                        .delaySeconds(0.0)
                        .delayWeekdayIntervalConfigId("string")
                        .build())
                    .id("string")
                    .ifElse(EscalationPathPathIfElseElsePathIfElseArgs.builder()
                        .conditions(EscalationPathPathIfElseElsePathIfElseConditionArgs.builder()
                            .operation("string")
                            .paramBindings(EscalationPathPathIfElseElsePathIfElseConditionParamBindingArgs.builder()
                                .arrayValues(EscalationPathPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs.builder()
                                    .literal("string")
                                    .reference("string")
                                    .build())
                                .value(EscalationPathPathIfElseElsePathIfElseConditionParamBindingValueArgs.builder()
                                    .literal("string")
                                    .reference("string")
                                    .build())
                                .build())
                            .subject("string")
                            .build())
                        .thenPaths(EscalationPathPathIfElseElsePathIfElseThenPathArgs.builder()
                            .type("string")
                            .delay(EscalationPathPathIfElseElsePathIfElseThenPathDelayArgs.builder()
                                .delayIntervalCondition("string")
                                .delaySeconds(0.0)
                                .delayWeekdayIntervalConfigId("string")
                                .build())
                            .id("string")
                            .ifElse(EscalationPathPathIfElseElsePathIfElseThenPathIfElseArgs.builder()
                                .conditions(EscalationPathPathIfElseElsePathIfElseThenPathIfElseConditionArgs.builder()
                                    .operation("string")
                                    .paramBindings(EscalationPathPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArgs.builder()
                                        .arrayValues(EscalationPathPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArgs.builder()
                                            .literal("string")
                                            .reference("string")
                                            .build())
                                        .value(EscalationPathPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingValueArgs.builder()
                                            .literal("string")
                                            .reference("string")
                                            .build())
                                        .build())
                                    .subject("string")
                                    .build())
                                .thenPaths(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathArgs.builder()
                                    .type("string")
                                    .delay(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathDelayArgs.builder()
                                        .delayIntervalCondition("string")
                                        .delaySeconds(0.0)
                                        .delayWeekdayIntervalConfigId("string")
                                        .build())
                                    .id("string")
                                    .ifElse(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseArgs.builder()
                                        .conditions(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionArgs.builder()
                                            .operation("string")
                                            .paramBindings(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArgs.builder()
                                                .arrayValues(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs.builder()
                                                    .literal("string")
                                                    .reference("string")
                                                    .build())
                                                .value(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingValueArgs.builder()
                                                    .literal("string")
                                                    .reference("string")
                                                    .build())
                                                .build())
                                            .subject("string")
                                            .build())
                                        .thenPaths(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathArgs.builder()
                                            .type("string")
                                            .delay(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathDelayArgs.builder()
                                                .delayIntervalCondition("string")
                                                .delaySeconds(0.0)
                                                .delayWeekdayIntervalConfigId("string")
                                                .build())
                                            .id("string")
                                            .ifElse(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseArgs.builder()
                                                .conditions(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionArgs.builder()
                                                    .operation("string")
                                                    .paramBindings(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArgs.builder()
                                                        .arrayValues(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .value(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseConditionParamBindingValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .build())
                                                    .subject("string")
                                                    .build())
                                                .thenPaths(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseThenPathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .elsePaths(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathIfElseElsePathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .build())
                                            .level(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelArgs.builder()
                                                .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .ackMode("string")
                                                .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                    .enabled(false)
                                                    .rotateAfterSeconds(0.0)
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .notifyChannel(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelArgs.builder()
                                                .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .repeat(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathRepeatArgs.builder()
                                                .repeatTimes(0.0)
                                                .toNode("string")
                                                .build())
                                            .build())
                                        .elsePaths(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathArgs.builder()
                                            .type("string")
                                            .delay(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathDelayArgs.builder()
                                                .delayIntervalCondition("string")
                                                .delaySeconds(0.0)
                                                .delayWeekdayIntervalConfigId("string")
                                                .build())
                                            .id("string")
                                            .ifElse(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseArgs.builder()
                                                .conditions(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionArgs.builder()
                                                    .operation("string")
                                                    .paramBindings(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArgs.builder()
                                                        .arrayValues(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .value(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseConditionParamBindingValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .build())
                                                    .subject("string")
                                                    .build())
                                                .thenPaths(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseThenPathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .elsePaths(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathIfElseElsePathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .build())
                                            .level(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelArgs.builder()
                                                .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .ackMode("string")
                                                .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                    .enabled(false)
                                                    .rotateAfterSeconds(0.0)
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .notifyChannel(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelArgs.builder()
                                                .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .repeat(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathRepeatArgs.builder()
                                                .repeatTimes(0.0)
                                                .toNode("string")
                                                .build())
                                            .build())
                                        .build())
                                    .level(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathLevelArgs.builder()
                                        .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArgs.builder()
                                            .id("string")
                                            .type("string")
                                            .urgency("string")
                                            .scheduleMode("string")
                                            .build())
                                        .ackMode("string")
                                        .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                            .enabled(false)
                                            .rotateAfterSeconds(0.0)
                                            .build())
                                        .timeToAckIntervalCondition("string")
                                        .timeToAckSeconds(0.0)
                                        .timeToAckWeekdayIntervalConfigId("string")
                                        .build())
                                    .notifyChannel(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelArgs.builder()
                                        .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs.builder()
                                            .id("string")
                                            .type("string")
                                            .urgency("string")
                                            .scheduleMode("string")
                                            .build())
                                        .timeToAckIntervalCondition("string")
                                        .timeToAckSeconds(0.0)
                                        .timeToAckWeekdayIntervalConfigId("string")
                                        .build())
                                    .repeat(EscalationPathPathIfElseElsePathIfElseThenPathIfElseThenPathRepeatArgs.builder()
                                        .repeatTimes(0.0)
                                        .toNode("string")
                                        .build())
                                    .build())
                                .elsePaths(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathArgs.builder()
                                    .type("string")
                                    .delay(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathDelayArgs.builder()
                                        .delayIntervalCondition("string")
                                        .delaySeconds(0.0)
                                        .delayWeekdayIntervalConfigId("string")
                                        .build())
                                    .id("string")
                                    .ifElse(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseArgs.builder()
                                        .conditions(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionArgs.builder()
                                            .operation("string")
                                            .paramBindings(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArgs.builder()
                                                .arrayValues(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs.builder()
                                                    .literal("string")
                                                    .reference("string")
                                                    .build())
                                                .value(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingValueArgs.builder()
                                                    .literal("string")
                                                    .reference("string")
                                                    .build())
                                                .build())
                                            .subject("string")
                                            .build())
                                        .thenPaths(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathArgs.builder()
                                            .type("string")
                                            .delay(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathDelayArgs.builder()
                                                .delayIntervalCondition("string")
                                                .delaySeconds(0.0)
                                                .delayWeekdayIntervalConfigId("string")
                                                .build())
                                            .id("string")
                                            .ifElse(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseArgs.builder()
                                                .conditions(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionArgs.builder()
                                                    .operation("string")
                                                    .paramBindings(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArgs.builder()
                                                        .arrayValues(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .value(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseConditionParamBindingValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .build())
                                                    .subject("string")
                                                    .build())
                                                .thenPaths(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseThenPathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .elsePaths(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathIfElseElsePathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .build())
                                            .level(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelArgs.builder()
                                                .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .ackMode("string")
                                                .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                    .enabled(false)
                                                    .rotateAfterSeconds(0.0)
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .notifyChannel(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelArgs.builder()
                                                .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .repeat(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathRepeatArgs.builder()
                                                .repeatTimes(0.0)
                                                .toNode("string")
                                                .build())
                                            .build())
                                        .elsePaths(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathArgs.builder()
                                            .type("string")
                                            .delay(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathDelayArgs.builder()
                                                .delayIntervalCondition("string")
                                                .delaySeconds(0.0)
                                                .delayWeekdayIntervalConfigId("string")
                                                .build())
                                            .id("string")
                                            .ifElse(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseArgs.builder()
                                                .conditions(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionArgs.builder()
                                                    .operation("string")
                                                    .paramBindings(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs.builder()
                                                        .arrayValues(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .value(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .build())
                                                    .subject("string")
                                                    .build())
                                                .thenPaths(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseThenPathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .elsePaths(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathIfElseElsePathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .build())
                                            .level(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelArgs.builder()
                                                .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .ackMode("string")
                                                .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                    .enabled(false)
                                                    .rotateAfterSeconds(0.0)
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .notifyChannel(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelArgs.builder()
                                                .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .repeat(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathRepeatArgs.builder()
                                                .repeatTimes(0.0)
                                                .toNode("string")
                                                .build())
                                            .build())
                                        .build())
                                    .level(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathLevelArgs.builder()
                                        .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArgs.builder()
                                            .id("string")
                                            .type("string")
                                            .urgency("string")
                                            .scheduleMode("string")
                                            .build())
                                        .ackMode("string")
                                        .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                            .enabled(false)
                                            .rotateAfterSeconds(0.0)
                                            .build())
                                        .timeToAckIntervalCondition("string")
                                        .timeToAckSeconds(0.0)
                                        .timeToAckWeekdayIntervalConfigId("string")
                                        .build())
                                    .notifyChannel(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelArgs.builder()
                                        .targets(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs.builder()
                                            .id("string")
                                            .type("string")
                                            .urgency("string")
                                            .scheduleMode("string")
                                            .build())
                                        .timeToAckIntervalCondition("string")
                                        .timeToAckSeconds(0.0)
                                        .timeToAckWeekdayIntervalConfigId("string")
                                        .build())
                                    .repeat(EscalationPathPathIfElseElsePathIfElseThenPathIfElseElsePathRepeatArgs.builder()
                                        .repeatTimes(0.0)
                                        .toNode("string")
                                        .build())
                                    .build())
                                .build())
                            .level(EscalationPathPathIfElseElsePathIfElseThenPathLevelArgs.builder()
                                .targets(EscalationPathPathIfElseElsePathIfElseThenPathLevelTargetArgs.builder()
                                    .id("string")
                                    .type("string")
                                    .urgency("string")
                                    .scheduleMode("string")
                                    .build())
                                .ackMode("string")
                                .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                    .enabled(false)
                                    .rotateAfterSeconds(0.0)
                                    .build())
                                .timeToAckIntervalCondition("string")
                                .timeToAckSeconds(0.0)
                                .timeToAckWeekdayIntervalConfigId("string")
                                .build())
                            .notifyChannel(EscalationPathPathIfElseElsePathIfElseThenPathNotifyChannelArgs.builder()
                                .targets(EscalationPathPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs.builder()
                                    .id("string")
                                    .type("string")
                                    .urgency("string")
                                    .scheduleMode("string")
                                    .build())
                                .timeToAckIntervalCondition("string")
                                .timeToAckSeconds(0.0)
                                .timeToAckWeekdayIntervalConfigId("string")
                                .build())
                            .repeat(EscalationPathPathIfElseElsePathIfElseThenPathRepeatArgs.builder()
                                .repeatTimes(0.0)
                                .toNode("string")
                                .build())
                            .build())
                        .elsePaths(EscalationPathPathIfElseElsePathIfElseElsePathArgs.builder()
                            .type("string")
                            .delay(EscalationPathPathIfElseElsePathIfElseElsePathDelayArgs.builder()
                                .delayIntervalCondition("string")
                                .delaySeconds(0.0)
                                .delayWeekdayIntervalConfigId("string")
                                .build())
                            .id("string")
                            .ifElse(EscalationPathPathIfElseElsePathIfElseElsePathIfElseArgs.builder()
                                .conditions(EscalationPathPathIfElseElsePathIfElseElsePathIfElseConditionArgs.builder()
                                    .operation("string")
                                    .paramBindings(EscalationPathPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs.builder()
                                        .arrayValues(EscalationPathPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs.builder()
                                            .literal("string")
                                            .reference("string")
                                            .build())
                                        .value(EscalationPathPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs.builder()
                                            .literal("string")
                                            .reference("string")
                                            .build())
                                        .build())
                                    .subject("string")
                                    .build())
                                .thenPaths(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathArgs.builder()
                                    .type("string")
                                    .delay(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathDelayArgs.builder()
                                        .delayIntervalCondition("string")
                                        .delaySeconds(0.0)
                                        .delayWeekdayIntervalConfigId("string")
                                        .build())
                                    .id("string")
                                    .ifElse(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseArgs.builder()
                                        .conditions(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionArgs.builder()
                                            .operation("string")
                                            .paramBindings(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArgs.builder()
                                                .arrayValues(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArgs.builder()
                                                    .literal("string")
                                                    .reference("string")
                                                    .build())
                                                .value(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingValueArgs.builder()
                                                    .literal("string")
                                                    .reference("string")
                                                    .build())
                                                .build())
                                            .subject("string")
                                            .build())
                                        .thenPaths(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathArgs.builder()
                                            .type("string")
                                            .delay(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathDelayArgs.builder()
                                                .delayIntervalCondition("string")
                                                .delaySeconds(0.0)
                                                .delayWeekdayIntervalConfigId("string")
                                                .build())
                                            .id("string")
                                            .ifElse(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseArgs.builder()
                                                .conditions(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionArgs.builder()
                                                    .operation("string")
                                                    .paramBindings(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArgs.builder()
                                                        .arrayValues(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingArrayValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .value(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseConditionParamBindingValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .build())
                                                    .subject("string")
                                                    .build())
                                                .thenPaths(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseThenPathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .elsePaths(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathIfElseElsePathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .build())
                                            .level(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelArgs.builder()
                                                .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .ackMode("string")
                                                .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                    .enabled(false)
                                                    .rotateAfterSeconds(0.0)
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .notifyChannel(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelArgs.builder()
                                                .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .repeat(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathRepeatArgs.builder()
                                                .repeatTimes(0.0)
                                                .toNode("string")
                                                .build())
                                            .build())
                                        .elsePaths(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathArgs.builder()
                                            .type("string")
                                            .delay(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathDelayArgs.builder()
                                                .delayIntervalCondition("string")
                                                .delaySeconds(0.0)
                                                .delayWeekdayIntervalConfigId("string")
                                                .build())
                                            .id("string")
                                            .ifElse(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseArgs.builder()
                                                .conditions(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionArgs.builder()
                                                    .operation("string")
                                                    .paramBindings(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArgs.builder()
                                                        .arrayValues(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .value(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseConditionParamBindingValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .build())
                                                    .subject("string")
                                                    .build())
                                                .thenPaths(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseThenPathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .elsePaths(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathIfElseElsePathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .build())
                                            .level(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelArgs.builder()
                                                .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .ackMode("string")
                                                .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                    .enabled(false)
                                                    .rotateAfterSeconds(0.0)
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .notifyChannel(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelArgs.builder()
                                                .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .repeat(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathRepeatArgs.builder()
                                                .repeatTimes(0.0)
                                                .toNode("string")
                                                .build())
                                            .build())
                                        .build())
                                    .level(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathLevelArgs.builder()
                                        .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArgs.builder()
                                            .id("string")
                                            .type("string")
                                            .urgency("string")
                                            .scheduleMode("string")
                                            .build())
                                        .ackMode("string")
                                        .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                            .enabled(false)
                                            .rotateAfterSeconds(0.0)
                                            .build())
                                        .timeToAckIntervalCondition("string")
                                        .timeToAckSeconds(0.0)
                                        .timeToAckWeekdayIntervalConfigId("string")
                                        .build())
                                    .notifyChannel(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelArgs.builder()
                                        .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs.builder()
                                            .id("string")
                                            .type("string")
                                            .urgency("string")
                                            .scheduleMode("string")
                                            .build())
                                        .timeToAckIntervalCondition("string")
                                        .timeToAckSeconds(0.0)
                                        .timeToAckWeekdayIntervalConfigId("string")
                                        .build())
                                    .repeat(EscalationPathPathIfElseElsePathIfElseElsePathIfElseThenPathRepeatArgs.builder()
                                        .repeatTimes(0.0)
                                        .toNode("string")
                                        .build())
                                    .build())
                                .elsePaths(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathArgs.builder()
                                    .type("string")
                                    .delay(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs.builder()
                                        .delayIntervalCondition("string")
                                        .delaySeconds(0.0)
                                        .delayWeekdayIntervalConfigId("string")
                                        .build())
                                    .id("string")
                                    .ifElse(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseArgs.builder()
                                        .conditions(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionArgs.builder()
                                            .operation("string")
                                            .paramBindings(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs.builder()
                                                .arrayValues(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs.builder()
                                                    .literal("string")
                                                    .reference("string")
                                                    .build())
                                                .value(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs.builder()
                                                    .literal("string")
                                                    .reference("string")
                                                    .build())
                                                .build())
                                            .subject("string")
                                            .build())
                                        .thenPaths(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathArgs.builder()
                                            .type("string")
                                            .delay(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathDelayArgs.builder()
                                                .delayIntervalCondition("string")
                                                .delaySeconds(0.0)
                                                .delayWeekdayIntervalConfigId("string")
                                                .build())
                                            .id("string")
                                            .ifElse(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseArgs.builder()
                                                .conditions(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionArgs.builder()
                                                    .operation("string")
                                                    .paramBindings(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArgs.builder()
                                                        .arrayValues(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingArrayValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .value(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseConditionParamBindingValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .build())
                                                    .subject("string")
                                                    .build())
                                                .thenPaths(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseThenPathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .elsePaths(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathIfElseElsePathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .build())
                                            .level(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelArgs.builder()
                                                .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .ackMode("string")
                                                .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                    .enabled(false)
                                                    .rotateAfterSeconds(0.0)
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .notifyChannel(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelArgs.builder()
                                                .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .repeat(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathRepeatArgs.builder()
                                                .repeatTimes(0.0)
                                                .toNode("string")
                                                .build())
                                            .build())
                                        .elsePaths(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathArgs.builder()
                                            .type("string")
                                            .delay(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs.builder()
                                                .delayIntervalCondition("string")
                                                .delaySeconds(0.0)
                                                .delayWeekdayIntervalConfigId("string")
                                                .build())
                                            .id("string")
                                            .ifElse(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseArgs.builder()
                                                .conditions(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionArgs.builder()
                                                    .operation("string")
                                                    .paramBindings(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs.builder()
                                                        .arrayValues(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .value(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs.builder()
                                                            .literal("string")
                                                            .reference("string")
                                                            .build())
                                                        .build())
                                                    .subject("string")
                                                    .build())
                                                .thenPaths(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .elsePaths(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathArgs.builder()
                                                    .type("string")
                                                    .delay(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs.builder()
                                                        .delayIntervalCondition("string")
                                                        .delaySeconds(0.0)
                                                        .delayWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .id("string")
                                                    .level(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .ackMode("string")
                                                        .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                            .enabled(false)
                                                            .rotateAfterSeconds(0.0)
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .notifyChannel(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelArgs.builder()
                                                        .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                            .id("string")
                                                            .type("string")
                                                            .urgency("string")
                                                            .scheduleMode("string")
                                                            .build())
                                                        .timeToAckIntervalCondition("string")
                                                        .timeToAckSeconds(0.0)
                                                        .timeToAckWeekdayIntervalConfigId("string")
                                                        .build())
                                                    .repeat(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathRepeatArgs.builder()
                                                        .repeatTimes(0.0)
                                                        .toNode("string")
                                                        .build())
                                                    .build())
                                                .build())
                                            .level(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelArgs.builder()
                                                .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .ackMode("string")
                                                .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                                    .enabled(false)
                                                    .rotateAfterSeconds(0.0)
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .notifyChannel(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelArgs.builder()
                                                .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs.builder()
                                                    .id("string")
                                                    .type("string")
                                                    .urgency("string")
                                                    .scheduleMode("string")
                                                    .build())
                                                .timeToAckIntervalCondition("string")
                                                .timeToAckSeconds(0.0)
                                                .timeToAckWeekdayIntervalConfigId("string")
                                                .build())
                                            .repeat(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathRepeatArgs.builder()
                                                .repeatTimes(0.0)
                                                .toNode("string")
                                                .build())
                                            .build())
                                        .build())
                                    .level(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathLevelArgs.builder()
                                        .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArgs.builder()
                                            .id("string")
                                            .type("string")
                                            .urgency("string")
                                            .scheduleMode("string")
                                            .build())
                                        .ackMode("string")
                                        .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                            .enabled(false)
                                            .rotateAfterSeconds(0.0)
                                            .build())
                                        .timeToAckIntervalCondition("string")
                                        .timeToAckSeconds(0.0)
                                        .timeToAckWeekdayIntervalConfigId("string")
                                        .build())
                                    .notifyChannel(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelArgs.builder()
                                        .targets(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs.builder()
                                            .id("string")
                                            .type("string")
                                            .urgency("string")
                                            .scheduleMode("string")
                                            .build())
                                        .timeToAckIntervalCondition("string")
                                        .timeToAckSeconds(0.0)
                                        .timeToAckWeekdayIntervalConfigId("string")
                                        .build())
                                    .repeat(EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathRepeatArgs.builder()
                                        .repeatTimes(0.0)
                                        .toNode("string")
                                        .build())
                                    .build())
                                .build())
                            .level(EscalationPathPathIfElseElsePathIfElseElsePathLevelArgs.builder()
                                .targets(EscalationPathPathIfElseElsePathIfElseElsePathLevelTargetArgs.builder()
                                    .id("string")
                                    .type("string")
                                    .urgency("string")
                                    .scheduleMode("string")
                                    .build())
                                .ackMode("string")
                                .roundRobinConfig(EscalationPathPathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                                    .enabled(false)
                                    .rotateAfterSeconds(0.0)
                                    .build())
                                .timeToAckIntervalCondition("string")
                                .timeToAckSeconds(0.0)
                                .timeToAckWeekdayIntervalConfigId("string")
                                .build())
                            .notifyChannel(EscalationPathPathIfElseElsePathIfElseElsePathNotifyChannelArgs.builder()
                                .targets(EscalationPathPathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs.builder()
                                    .id("string")
                                    .type("string")
                                    .urgency("string")
                                    .scheduleMode("string")
                                    .build())
                                .timeToAckIntervalCondition("string")
                                .timeToAckSeconds(0.0)
                                .timeToAckWeekdayIntervalConfigId("string")
                                .build())
                            .repeat(EscalationPathPathIfElseElsePathIfElseElsePathRepeatArgs.builder()
                                .repeatTimes(0.0)
                                .toNode("string")
                                .build())
                            .build())
                        .build())
                    .level(EscalationPathPathIfElseElsePathLevelArgs.builder()
                        .targets(EscalationPathPathIfElseElsePathLevelTargetArgs.builder()
                            .id("string")
                            .type("string")
                            .urgency("string")
                            .scheduleMode("string")
                            .build())
                        .ackMode("string")
                        .roundRobinConfig(EscalationPathPathIfElseElsePathLevelRoundRobinConfigArgs.builder()
                            .enabled(false)
                            .rotateAfterSeconds(0.0)
                            .build())
                        .timeToAckIntervalCondition("string")
                        .timeToAckSeconds(0.0)
                        .timeToAckWeekdayIntervalConfigId("string")
                        .build())
                    .notifyChannel(EscalationPathPathIfElseElsePathNotifyChannelArgs.builder()
                        .targets(EscalationPathPathIfElseElsePathNotifyChannelTargetArgs.builder()
                            .id("string")
                            .type("string")
                            .urgency("string")
                            .scheduleMode("string")
                            .build())
                        .timeToAckIntervalCondition("string")
                        .timeToAckSeconds(0.0)
                        .timeToAckWeekdayIntervalConfigId("string")
                        .build())
                    .repeat(EscalationPathPathIfElseElsePathRepeatArgs.builder()
                        .repeatTimes(0.0)
                        .toNode("string")
                        .build())
                    .build())
                .build())
            .level(EscalationPathPathLevelArgs.builder()
                .targets(EscalationPathPathLevelTargetArgs.builder()
                    .id("string")
                    .type("string")
                    .urgency("string")
                    .scheduleMode("string")
                    .build())
                .ackMode("string")
                .roundRobinConfig(EscalationPathPathLevelRoundRobinConfigArgs.builder()
                    .enabled(false)
                    .rotateAfterSeconds(0.0)
                    .build())
                .timeToAckIntervalCondition("string")
                .timeToAckSeconds(0.0)
                .timeToAckWeekdayIntervalConfigId("string")
                .build())
            .notifyChannel(EscalationPathPathNotifyChannelArgs.builder()
                .targets(EscalationPathPathNotifyChannelTargetArgs.builder()
                    .id("string")
                    .type("string")
                    .urgency("string")
                    .scheduleMode("string")
                    .build())
                .timeToAckIntervalCondition("string")
                .timeToAckSeconds(0.0)
                .timeToAckWeekdayIntervalConfigId("string")
                .build())
            .repeat(EscalationPathPathRepeatArgs.builder()
                .repeatTimes(0.0)
                .toNode("string")
                .build())
            .build())
        .name("string")
        .repeatConfig(EscalationPathRepeatConfigArgs.builder()
            .delayRepeatOnActivity(false)
            .repeatAfterSeconds(0.0)
            .build())
        .teamIds("string")
        .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",
        paths=[{
            "type": "string",
            "delay": {
                "delay_interval_condition": "string",
                "delay_seconds": float(0),
                "delay_weekday_interval_config_id": "string",
            },
            "id": "string",
            "if_else": {
                "conditions": [{
                    "operation": "string",
                    "param_bindings": [{
                        "array_values": [{
                            "literal": "string",
                            "reference": "string",
                        }],
                        "value": {
                            "literal": "string",
                            "reference": "string",
                        },
                    }],
                    "subject": "string",
                }],
                "then_paths": [{
                    "type": "string",
                    "delay": {
                        "delay_interval_condition": "string",
                        "delay_seconds": float(0),
                        "delay_weekday_interval_config_id": "string",
                    },
                    "id": "string",
                    "if_else": {
                        "conditions": [{
                            "operation": "string",
                            "param_bindings": [{
                                "array_values": [{
                                    "literal": "string",
                                    "reference": "string",
                                }],
                                "value": {
                                    "literal": "string",
                                    "reference": "string",
                                },
                            }],
                            "subject": "string",
                        }],
                        "then_paths": [{
                            "type": "string",
                            "delay": {
                                "delay_interval_condition": "string",
                                "delay_seconds": float(0),
                                "delay_weekday_interval_config_id": "string",
                            },
                            "id": "string",
                            "if_else": {
                                "conditions": [{
                                    "operation": "string",
                                    "param_bindings": [{
                                        "array_values": [{
                                            "literal": "string",
                                            "reference": "string",
                                        }],
                                        "value": {
                                            "literal": "string",
                                            "reference": "string",
                                        },
                                    }],
                                    "subject": "string",
                                }],
                                "then_paths": [{
                                    "type": "string",
                                    "delay": {
                                        "delay_interval_condition": "string",
                                        "delay_seconds": float(0),
                                        "delay_weekday_interval_config_id": "string",
                                    },
                                    "id": "string",
                                    "if_else": {
                                        "conditions": [{
                                            "operation": "string",
                                            "param_bindings": [{
                                                "array_values": [{
                                                    "literal": "string",
                                                    "reference": "string",
                                                }],
                                                "value": {
                                                    "literal": "string",
                                                    "reference": "string",
                                                },
                                            }],
                                            "subject": "string",
                                        }],
                                        "then_paths": [{
                                            "type": "string",
                                            "delay": {
                                                "delay_interval_condition": "string",
                                                "delay_seconds": float(0),
                                                "delay_weekday_interval_config_id": "string",
                                            },
                                            "id": "string",
                                            "if_else": {
                                                "conditions": [{
                                                    "operation": "string",
                                                    "param_bindings": [{
                                                        "array_values": [{
                                                            "literal": "string",
                                                            "reference": "string",
                                                        }],
                                                        "value": {
                                                            "literal": "string",
                                                            "reference": "string",
                                                        },
                                                    }],
                                                    "subject": "string",
                                                }],
                                                "then_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                                "else_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                            },
                                            "level": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "ack_mode": "string",
                                                "round_robin_config": {
                                                    "enabled": False,
                                                    "rotate_after_seconds": float(0),
                                                },
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "notify_channel": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "repeat": {
                                                "repeat_times": float(0),
                                                "to_node": "string",
                                            },
                                        }],
                                        "else_paths": [{
                                            "type": "string",
                                            "delay": {
                                                "delay_interval_condition": "string",
                                                "delay_seconds": float(0),
                                                "delay_weekday_interval_config_id": "string",
                                            },
                                            "id": "string",
                                            "if_else": {
                                                "conditions": [{
                                                    "operation": "string",
                                                    "param_bindings": [{
                                                        "array_values": [{
                                                            "literal": "string",
                                                            "reference": "string",
                                                        }],
                                                        "value": {
                                                            "literal": "string",
                                                            "reference": "string",
                                                        },
                                                    }],
                                                    "subject": "string",
                                                }],
                                                "then_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                                "else_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                            },
                                            "level": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "ack_mode": "string",
                                                "round_robin_config": {
                                                    "enabled": False,
                                                    "rotate_after_seconds": float(0),
                                                },
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "notify_channel": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "repeat": {
                                                "repeat_times": float(0),
                                                "to_node": "string",
                                            },
                                        }],
                                    },
                                    "level": {
                                        "targets": [{
                                            "id": "string",
                                            "type": "string",
                                            "urgency": "string",
                                            "schedule_mode": "string",
                                        }],
                                        "ack_mode": "string",
                                        "round_robin_config": {
                                            "enabled": False,
                                            "rotate_after_seconds": float(0),
                                        },
                                        "time_to_ack_interval_condition": "string",
                                        "time_to_ack_seconds": float(0),
                                        "time_to_ack_weekday_interval_config_id": "string",
                                    },
                                    "notify_channel": {
                                        "targets": [{
                                            "id": "string",
                                            "type": "string",
                                            "urgency": "string",
                                            "schedule_mode": "string",
                                        }],
                                        "time_to_ack_interval_condition": "string",
                                        "time_to_ack_seconds": float(0),
                                        "time_to_ack_weekday_interval_config_id": "string",
                                    },
                                    "repeat": {
                                        "repeat_times": float(0),
                                        "to_node": "string",
                                    },
                                }],
                                "else_paths": [{
                                    "type": "string",
                                    "delay": {
                                        "delay_interval_condition": "string",
                                        "delay_seconds": float(0),
                                        "delay_weekday_interval_config_id": "string",
                                    },
                                    "id": "string",
                                    "if_else": {
                                        "conditions": [{
                                            "operation": "string",
                                            "param_bindings": [{
                                                "array_values": [{
                                                    "literal": "string",
                                                    "reference": "string",
                                                }],
                                                "value": {
                                                    "literal": "string",
                                                    "reference": "string",
                                                },
                                            }],
                                            "subject": "string",
                                        }],
                                        "then_paths": [{
                                            "type": "string",
                                            "delay": {
                                                "delay_interval_condition": "string",
                                                "delay_seconds": float(0),
                                                "delay_weekday_interval_config_id": "string",
                                            },
                                            "id": "string",
                                            "if_else": {
                                                "conditions": [{
                                                    "operation": "string",
                                                    "param_bindings": [{
                                                        "array_values": [{
                                                            "literal": "string",
                                                            "reference": "string",
                                                        }],
                                                        "value": {
                                                            "literal": "string",
                                                            "reference": "string",
                                                        },
                                                    }],
                                                    "subject": "string",
                                                }],
                                                "then_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                                "else_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                            },
                                            "level": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "ack_mode": "string",
                                                "round_robin_config": {
                                                    "enabled": False,
                                                    "rotate_after_seconds": float(0),
                                                },
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "notify_channel": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "repeat": {
                                                "repeat_times": float(0),
                                                "to_node": "string",
                                            },
                                        }],
                                        "else_paths": [{
                                            "type": "string",
                                            "delay": {
                                                "delay_interval_condition": "string",
                                                "delay_seconds": float(0),
                                                "delay_weekday_interval_config_id": "string",
                                            },
                                            "id": "string",
                                            "if_else": {
                                                "conditions": [{
                                                    "operation": "string",
                                                    "param_bindings": [{
                                                        "array_values": [{
                                                            "literal": "string",
                                                            "reference": "string",
                                                        }],
                                                        "value": {
                                                            "literal": "string",
                                                            "reference": "string",
                                                        },
                                                    }],
                                                    "subject": "string",
                                                }],
                                                "then_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                                "else_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                            },
                                            "level": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "ack_mode": "string",
                                                "round_robin_config": {
                                                    "enabled": False,
                                                    "rotate_after_seconds": float(0),
                                                },
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "notify_channel": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "repeat": {
                                                "repeat_times": float(0),
                                                "to_node": "string",
                                            },
                                        }],
                                    },
                                    "level": {
                                        "targets": [{
                                            "id": "string",
                                            "type": "string",
                                            "urgency": "string",
                                            "schedule_mode": "string",
                                        }],
                                        "ack_mode": "string",
                                        "round_robin_config": {
                                            "enabled": False,
                                            "rotate_after_seconds": float(0),
                                        },
                                        "time_to_ack_interval_condition": "string",
                                        "time_to_ack_seconds": float(0),
                                        "time_to_ack_weekday_interval_config_id": "string",
                                    },
                                    "notify_channel": {
                                        "targets": [{
                                            "id": "string",
                                            "type": "string",
                                            "urgency": "string",
                                            "schedule_mode": "string",
                                        }],
                                        "time_to_ack_interval_condition": "string",
                                        "time_to_ack_seconds": float(0),
                                        "time_to_ack_weekday_interval_config_id": "string",
                                    },
                                    "repeat": {
                                        "repeat_times": float(0),
                                        "to_node": "string",
                                    },
                                }],
                            },
                            "level": {
                                "targets": [{
                                    "id": "string",
                                    "type": "string",
                                    "urgency": "string",
                                    "schedule_mode": "string",
                                }],
                                "ack_mode": "string",
                                "round_robin_config": {
                                    "enabled": False,
                                    "rotate_after_seconds": float(0),
                                },
                                "time_to_ack_interval_condition": "string",
                                "time_to_ack_seconds": float(0),
                                "time_to_ack_weekday_interval_config_id": "string",
                            },
                            "notify_channel": {
                                "targets": [{
                                    "id": "string",
                                    "type": "string",
                                    "urgency": "string",
                                    "schedule_mode": "string",
                                }],
                                "time_to_ack_interval_condition": "string",
                                "time_to_ack_seconds": float(0),
                                "time_to_ack_weekday_interval_config_id": "string",
                            },
                            "repeat": {
                                "repeat_times": float(0),
                                "to_node": "string",
                            },
                        }],
                        "else_paths": [{
                            "type": "string",
                            "delay": {
                                "delay_interval_condition": "string",
                                "delay_seconds": float(0),
                                "delay_weekday_interval_config_id": "string",
                            },
                            "id": "string",
                            "if_else": {
                                "conditions": [{
                                    "operation": "string",
                                    "param_bindings": [{
                                        "array_values": [{
                                            "literal": "string",
                                            "reference": "string",
                                        }],
                                        "value": {
                                            "literal": "string",
                                            "reference": "string",
                                        },
                                    }],
                                    "subject": "string",
                                }],
                                "then_paths": [{
                                    "type": "string",
                                    "delay": {
                                        "delay_interval_condition": "string",
                                        "delay_seconds": float(0),
                                        "delay_weekday_interval_config_id": "string",
                                    },
                                    "id": "string",
                                    "if_else": {
                                        "conditions": [{
                                            "operation": "string",
                                            "param_bindings": [{
                                                "array_values": [{
                                                    "literal": "string",
                                                    "reference": "string",
                                                }],
                                                "value": {
                                                    "literal": "string",
                                                    "reference": "string",
                                                },
                                            }],
                                            "subject": "string",
                                        }],
                                        "then_paths": [{
                                            "type": "string",
                                            "delay": {
                                                "delay_interval_condition": "string",
                                                "delay_seconds": float(0),
                                                "delay_weekday_interval_config_id": "string",
                                            },
                                            "id": "string",
                                            "if_else": {
                                                "conditions": [{
                                                    "operation": "string",
                                                    "param_bindings": [{
                                                        "array_values": [{
                                                            "literal": "string",
                                                            "reference": "string",
                                                        }],
                                                        "value": {
                                                            "literal": "string",
                                                            "reference": "string",
                                                        },
                                                    }],
                                                    "subject": "string",
                                                }],
                                                "then_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                                "else_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                            },
                                            "level": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "ack_mode": "string",
                                                "round_robin_config": {
                                                    "enabled": False,
                                                    "rotate_after_seconds": float(0),
                                                },
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "notify_channel": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "repeat": {
                                                "repeat_times": float(0),
                                                "to_node": "string",
                                            },
                                        }],
                                        "else_paths": [{
                                            "type": "string",
                                            "delay": {
                                                "delay_interval_condition": "string",
                                                "delay_seconds": float(0),
                                                "delay_weekday_interval_config_id": "string",
                                            },
                                            "id": "string",
                                            "if_else": {
                                                "conditions": [{
                                                    "operation": "string",
                                                    "param_bindings": [{
                                                        "array_values": [{
                                                            "literal": "string",
                                                            "reference": "string",
                                                        }],
                                                        "value": {
                                                            "literal": "string",
                                                            "reference": "string",
                                                        },
                                                    }],
                                                    "subject": "string",
                                                }],
                                                "then_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                                "else_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                            },
                                            "level": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "ack_mode": "string",
                                                "round_robin_config": {
                                                    "enabled": False,
                                                    "rotate_after_seconds": float(0),
                                                },
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "notify_channel": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "repeat": {
                                                "repeat_times": float(0),
                                                "to_node": "string",
                                            },
                                        }],
                                    },
                                    "level": {
                                        "targets": [{
                                            "id": "string",
                                            "type": "string",
                                            "urgency": "string",
                                            "schedule_mode": "string",
                                        }],
                                        "ack_mode": "string",
                                        "round_robin_config": {
                                            "enabled": False,
                                            "rotate_after_seconds": float(0),
                                        },
                                        "time_to_ack_interval_condition": "string",
                                        "time_to_ack_seconds": float(0),
                                        "time_to_ack_weekday_interval_config_id": "string",
                                    },
                                    "notify_channel": {
                                        "targets": [{
                                            "id": "string",
                                            "type": "string",
                                            "urgency": "string",
                                            "schedule_mode": "string",
                                        }],
                                        "time_to_ack_interval_condition": "string",
                                        "time_to_ack_seconds": float(0),
                                        "time_to_ack_weekday_interval_config_id": "string",
                                    },
                                    "repeat": {
                                        "repeat_times": float(0),
                                        "to_node": "string",
                                    },
                                }],
                                "else_paths": [{
                                    "type": "string",
                                    "delay": {
                                        "delay_interval_condition": "string",
                                        "delay_seconds": float(0),
                                        "delay_weekday_interval_config_id": "string",
                                    },
                                    "id": "string",
                                    "if_else": {
                                        "conditions": [{
                                            "operation": "string",
                                            "param_bindings": [{
                                                "array_values": [{
                                                    "literal": "string",
                                                    "reference": "string",
                                                }],
                                                "value": {
                                                    "literal": "string",
                                                    "reference": "string",
                                                },
                                            }],
                                            "subject": "string",
                                        }],
                                        "then_paths": [{
                                            "type": "string",
                                            "delay": {
                                                "delay_interval_condition": "string",
                                                "delay_seconds": float(0),
                                                "delay_weekday_interval_config_id": "string",
                                            },
                                            "id": "string",
                                            "if_else": {
                                                "conditions": [{
                                                    "operation": "string",
                                                    "param_bindings": [{
                                                        "array_values": [{
                                                            "literal": "string",
                                                            "reference": "string",
                                                        }],
                                                        "value": {
                                                            "literal": "string",
                                                            "reference": "string",
                                                        },
                                                    }],
                                                    "subject": "string",
                                                }],
                                                "then_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                                "else_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                            },
                                            "level": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "ack_mode": "string",
                                                "round_robin_config": {
                                                    "enabled": False,
                                                    "rotate_after_seconds": float(0),
                                                },
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "notify_channel": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "repeat": {
                                                "repeat_times": float(0),
                                                "to_node": "string",
                                            },
                                        }],
                                        "else_paths": [{
                                            "type": "string",
                                            "delay": {
                                                "delay_interval_condition": "string",
                                                "delay_seconds": float(0),
                                                "delay_weekday_interval_config_id": "string",
                                            },
                                            "id": "string",
                                            "if_else": {
                                                "conditions": [{
                                                    "operation": "string",
                                                    "param_bindings": [{
                                                        "array_values": [{
                                                            "literal": "string",
                                                            "reference": "string",
                                                        }],
                                                        "value": {
                                                            "literal": "string",
                                                            "reference": "string",
                                                        },
                                                    }],
                                                    "subject": "string",
                                                }],
                                                "then_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                                "else_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                            },
                                            "level": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "ack_mode": "string",
                                                "round_robin_config": {
                                                    "enabled": False,
                                                    "rotate_after_seconds": float(0),
                                                },
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "notify_channel": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "repeat": {
                                                "repeat_times": float(0),
                                                "to_node": "string",
                                            },
                                        }],
                                    },
                                    "level": {
                                        "targets": [{
                                            "id": "string",
                                            "type": "string",
                                            "urgency": "string",
                                            "schedule_mode": "string",
                                        }],
                                        "ack_mode": "string",
                                        "round_robin_config": {
                                            "enabled": False,
                                            "rotate_after_seconds": float(0),
                                        },
                                        "time_to_ack_interval_condition": "string",
                                        "time_to_ack_seconds": float(0),
                                        "time_to_ack_weekday_interval_config_id": "string",
                                    },
                                    "notify_channel": {
                                        "targets": [{
                                            "id": "string",
                                            "type": "string",
                                            "urgency": "string",
                                            "schedule_mode": "string",
                                        }],
                                        "time_to_ack_interval_condition": "string",
                                        "time_to_ack_seconds": float(0),
                                        "time_to_ack_weekday_interval_config_id": "string",
                                    },
                                    "repeat": {
                                        "repeat_times": float(0),
                                        "to_node": "string",
                                    },
                                }],
                            },
                            "level": {
                                "targets": [{
                                    "id": "string",
                                    "type": "string",
                                    "urgency": "string",
                                    "schedule_mode": "string",
                                }],
                                "ack_mode": "string",
                                "round_robin_config": {
                                    "enabled": False,
                                    "rotate_after_seconds": float(0),
                                },
                                "time_to_ack_interval_condition": "string",
                                "time_to_ack_seconds": float(0),
                                "time_to_ack_weekday_interval_config_id": "string",
                            },
                            "notify_channel": {
                                "targets": [{
                                    "id": "string",
                                    "type": "string",
                                    "urgency": "string",
                                    "schedule_mode": "string",
                                }],
                                "time_to_ack_interval_condition": "string",
                                "time_to_ack_seconds": float(0),
                                "time_to_ack_weekday_interval_config_id": "string",
                            },
                            "repeat": {
                                "repeat_times": float(0),
                                "to_node": "string",
                            },
                        }],
                    },
                    "level": {
                        "targets": [{
                            "id": "string",
                            "type": "string",
                            "urgency": "string",
                            "schedule_mode": "string",
                        }],
                        "ack_mode": "string",
                        "round_robin_config": {
                            "enabled": False,
                            "rotate_after_seconds": float(0),
                        },
                        "time_to_ack_interval_condition": "string",
                        "time_to_ack_seconds": float(0),
                        "time_to_ack_weekday_interval_config_id": "string",
                    },
                    "notify_channel": {
                        "targets": [{
                            "id": "string",
                            "type": "string",
                            "urgency": "string",
                            "schedule_mode": "string",
                        }],
                        "time_to_ack_interval_condition": "string",
                        "time_to_ack_seconds": float(0),
                        "time_to_ack_weekday_interval_config_id": "string",
                    },
                    "repeat": {
                        "repeat_times": float(0),
                        "to_node": "string",
                    },
                }],
                "else_paths": [{
                    "type": "string",
                    "delay": {
                        "delay_interval_condition": "string",
                        "delay_seconds": float(0),
                        "delay_weekday_interval_config_id": "string",
                    },
                    "id": "string",
                    "if_else": {
                        "conditions": [{
                            "operation": "string",
                            "param_bindings": [{
                                "array_values": [{
                                    "literal": "string",
                                    "reference": "string",
                                }],
                                "value": {
                                    "literal": "string",
                                    "reference": "string",
                                },
                            }],
                            "subject": "string",
                        }],
                        "then_paths": [{
                            "type": "string",
                            "delay": {
                                "delay_interval_condition": "string",
                                "delay_seconds": float(0),
                                "delay_weekday_interval_config_id": "string",
                            },
                            "id": "string",
                            "if_else": {
                                "conditions": [{
                                    "operation": "string",
                                    "param_bindings": [{
                                        "array_values": [{
                                            "literal": "string",
                                            "reference": "string",
                                        }],
                                        "value": {
                                            "literal": "string",
                                            "reference": "string",
                                        },
                                    }],
                                    "subject": "string",
                                }],
                                "then_paths": [{
                                    "type": "string",
                                    "delay": {
                                        "delay_interval_condition": "string",
                                        "delay_seconds": float(0),
                                        "delay_weekday_interval_config_id": "string",
                                    },
                                    "id": "string",
                                    "if_else": {
                                        "conditions": [{
                                            "operation": "string",
                                            "param_bindings": [{
                                                "array_values": [{
                                                    "literal": "string",
                                                    "reference": "string",
                                                }],
                                                "value": {
                                                    "literal": "string",
                                                    "reference": "string",
                                                },
                                            }],
                                            "subject": "string",
                                        }],
                                        "then_paths": [{
                                            "type": "string",
                                            "delay": {
                                                "delay_interval_condition": "string",
                                                "delay_seconds": float(0),
                                                "delay_weekday_interval_config_id": "string",
                                            },
                                            "id": "string",
                                            "if_else": {
                                                "conditions": [{
                                                    "operation": "string",
                                                    "param_bindings": [{
                                                        "array_values": [{
                                                            "literal": "string",
                                                            "reference": "string",
                                                        }],
                                                        "value": {
                                                            "literal": "string",
                                                            "reference": "string",
                                                        },
                                                    }],
                                                    "subject": "string",
                                                }],
                                                "then_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                                "else_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                            },
                                            "level": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "ack_mode": "string",
                                                "round_robin_config": {
                                                    "enabled": False,
                                                    "rotate_after_seconds": float(0),
                                                },
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "notify_channel": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "repeat": {
                                                "repeat_times": float(0),
                                                "to_node": "string",
                                            },
                                        }],
                                        "else_paths": [{
                                            "type": "string",
                                            "delay": {
                                                "delay_interval_condition": "string",
                                                "delay_seconds": float(0),
                                                "delay_weekday_interval_config_id": "string",
                                            },
                                            "id": "string",
                                            "if_else": {
                                                "conditions": [{
                                                    "operation": "string",
                                                    "param_bindings": [{
                                                        "array_values": [{
                                                            "literal": "string",
                                                            "reference": "string",
                                                        }],
                                                        "value": {
                                                            "literal": "string",
                                                            "reference": "string",
                                                        },
                                                    }],
                                                    "subject": "string",
                                                }],
                                                "then_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                                "else_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                            },
                                            "level": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "ack_mode": "string",
                                                "round_robin_config": {
                                                    "enabled": False,
                                                    "rotate_after_seconds": float(0),
                                                },
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "notify_channel": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "repeat": {
                                                "repeat_times": float(0),
                                                "to_node": "string",
                                            },
                                        }],
                                    },
                                    "level": {
                                        "targets": [{
                                            "id": "string",
                                            "type": "string",
                                            "urgency": "string",
                                            "schedule_mode": "string",
                                        }],
                                        "ack_mode": "string",
                                        "round_robin_config": {
                                            "enabled": False,
                                            "rotate_after_seconds": float(0),
                                        },
                                        "time_to_ack_interval_condition": "string",
                                        "time_to_ack_seconds": float(0),
                                        "time_to_ack_weekday_interval_config_id": "string",
                                    },
                                    "notify_channel": {
                                        "targets": [{
                                            "id": "string",
                                            "type": "string",
                                            "urgency": "string",
                                            "schedule_mode": "string",
                                        }],
                                        "time_to_ack_interval_condition": "string",
                                        "time_to_ack_seconds": float(0),
                                        "time_to_ack_weekday_interval_config_id": "string",
                                    },
                                    "repeat": {
                                        "repeat_times": float(0),
                                        "to_node": "string",
                                    },
                                }],
                                "else_paths": [{
                                    "type": "string",
                                    "delay": {
                                        "delay_interval_condition": "string",
                                        "delay_seconds": float(0),
                                        "delay_weekday_interval_config_id": "string",
                                    },
                                    "id": "string",
                                    "if_else": {
                                        "conditions": [{
                                            "operation": "string",
                                            "param_bindings": [{
                                                "array_values": [{
                                                    "literal": "string",
                                                    "reference": "string",
                                                }],
                                                "value": {
                                                    "literal": "string",
                                                    "reference": "string",
                                                },
                                            }],
                                            "subject": "string",
                                        }],
                                        "then_paths": [{
                                            "type": "string",
                                            "delay": {
                                                "delay_interval_condition": "string",
                                                "delay_seconds": float(0),
                                                "delay_weekday_interval_config_id": "string",
                                            },
                                            "id": "string",
                                            "if_else": {
                                                "conditions": [{
                                                    "operation": "string",
                                                    "param_bindings": [{
                                                        "array_values": [{
                                                            "literal": "string",
                                                            "reference": "string",
                                                        }],
                                                        "value": {
                                                            "literal": "string",
                                                            "reference": "string",
                                                        },
                                                    }],
                                                    "subject": "string",
                                                }],
                                                "then_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                                "else_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                            },
                                            "level": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "ack_mode": "string",
                                                "round_robin_config": {
                                                    "enabled": False,
                                                    "rotate_after_seconds": float(0),
                                                },
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "notify_channel": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "repeat": {
                                                "repeat_times": float(0),
                                                "to_node": "string",
                                            },
                                        }],
                                        "else_paths": [{
                                            "type": "string",
                                            "delay": {
                                                "delay_interval_condition": "string",
                                                "delay_seconds": float(0),
                                                "delay_weekday_interval_config_id": "string",
                                            },
                                            "id": "string",
                                            "if_else": {
                                                "conditions": [{
                                                    "operation": "string",
                                                    "param_bindings": [{
                                                        "array_values": [{
                                                            "literal": "string",
                                                            "reference": "string",
                                                        }],
                                                        "value": {
                                                            "literal": "string",
                                                            "reference": "string",
                                                        },
                                                    }],
                                                    "subject": "string",
                                                }],
                                                "then_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                                "else_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                            },
                                            "level": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "ack_mode": "string",
                                                "round_robin_config": {
                                                    "enabled": False,
                                                    "rotate_after_seconds": float(0),
                                                },
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "notify_channel": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "repeat": {
                                                "repeat_times": float(0),
                                                "to_node": "string",
                                            },
                                        }],
                                    },
                                    "level": {
                                        "targets": [{
                                            "id": "string",
                                            "type": "string",
                                            "urgency": "string",
                                            "schedule_mode": "string",
                                        }],
                                        "ack_mode": "string",
                                        "round_robin_config": {
                                            "enabled": False,
                                            "rotate_after_seconds": float(0),
                                        },
                                        "time_to_ack_interval_condition": "string",
                                        "time_to_ack_seconds": float(0),
                                        "time_to_ack_weekday_interval_config_id": "string",
                                    },
                                    "notify_channel": {
                                        "targets": [{
                                            "id": "string",
                                            "type": "string",
                                            "urgency": "string",
                                            "schedule_mode": "string",
                                        }],
                                        "time_to_ack_interval_condition": "string",
                                        "time_to_ack_seconds": float(0),
                                        "time_to_ack_weekday_interval_config_id": "string",
                                    },
                                    "repeat": {
                                        "repeat_times": float(0),
                                        "to_node": "string",
                                    },
                                }],
                            },
                            "level": {
                                "targets": [{
                                    "id": "string",
                                    "type": "string",
                                    "urgency": "string",
                                    "schedule_mode": "string",
                                }],
                                "ack_mode": "string",
                                "round_robin_config": {
                                    "enabled": False,
                                    "rotate_after_seconds": float(0),
                                },
                                "time_to_ack_interval_condition": "string",
                                "time_to_ack_seconds": float(0),
                                "time_to_ack_weekday_interval_config_id": "string",
                            },
                            "notify_channel": {
                                "targets": [{
                                    "id": "string",
                                    "type": "string",
                                    "urgency": "string",
                                    "schedule_mode": "string",
                                }],
                                "time_to_ack_interval_condition": "string",
                                "time_to_ack_seconds": float(0),
                                "time_to_ack_weekday_interval_config_id": "string",
                            },
                            "repeat": {
                                "repeat_times": float(0),
                                "to_node": "string",
                            },
                        }],
                        "else_paths": [{
                            "type": "string",
                            "delay": {
                                "delay_interval_condition": "string",
                                "delay_seconds": float(0),
                                "delay_weekday_interval_config_id": "string",
                            },
                            "id": "string",
                            "if_else": {
                                "conditions": [{
                                    "operation": "string",
                                    "param_bindings": [{
                                        "array_values": [{
                                            "literal": "string",
                                            "reference": "string",
                                        }],
                                        "value": {
                                            "literal": "string",
                                            "reference": "string",
                                        },
                                    }],
                                    "subject": "string",
                                }],
                                "then_paths": [{
                                    "type": "string",
                                    "delay": {
                                        "delay_interval_condition": "string",
                                        "delay_seconds": float(0),
                                        "delay_weekday_interval_config_id": "string",
                                    },
                                    "id": "string",
                                    "if_else": {
                                        "conditions": [{
                                            "operation": "string",
                                            "param_bindings": [{
                                                "array_values": [{
                                                    "literal": "string",
                                                    "reference": "string",
                                                }],
                                                "value": {
                                                    "literal": "string",
                                                    "reference": "string",
                                                },
                                            }],
                                            "subject": "string",
                                        }],
                                        "then_paths": [{
                                            "type": "string",
                                            "delay": {
                                                "delay_interval_condition": "string",
                                                "delay_seconds": float(0),
                                                "delay_weekday_interval_config_id": "string",
                                            },
                                            "id": "string",
                                            "if_else": {
                                                "conditions": [{
                                                    "operation": "string",
                                                    "param_bindings": [{
                                                        "array_values": [{
                                                            "literal": "string",
                                                            "reference": "string",
                                                        }],
                                                        "value": {
                                                            "literal": "string",
                                                            "reference": "string",
                                                        },
                                                    }],
                                                    "subject": "string",
                                                }],
                                                "then_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                                "else_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                            },
                                            "level": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "ack_mode": "string",
                                                "round_robin_config": {
                                                    "enabled": False,
                                                    "rotate_after_seconds": float(0),
                                                },
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "notify_channel": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "repeat": {
                                                "repeat_times": float(0),
                                                "to_node": "string",
                                            },
                                        }],
                                        "else_paths": [{
                                            "type": "string",
                                            "delay": {
                                                "delay_interval_condition": "string",
                                                "delay_seconds": float(0),
                                                "delay_weekday_interval_config_id": "string",
                                            },
                                            "id": "string",
                                            "if_else": {
                                                "conditions": [{
                                                    "operation": "string",
                                                    "param_bindings": [{
                                                        "array_values": [{
                                                            "literal": "string",
                                                            "reference": "string",
                                                        }],
                                                        "value": {
                                                            "literal": "string",
                                                            "reference": "string",
                                                        },
                                                    }],
                                                    "subject": "string",
                                                }],
                                                "then_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                                "else_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                            },
                                            "level": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "ack_mode": "string",
                                                "round_robin_config": {
                                                    "enabled": False,
                                                    "rotate_after_seconds": float(0),
                                                },
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "notify_channel": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "repeat": {
                                                "repeat_times": float(0),
                                                "to_node": "string",
                                            },
                                        }],
                                    },
                                    "level": {
                                        "targets": [{
                                            "id": "string",
                                            "type": "string",
                                            "urgency": "string",
                                            "schedule_mode": "string",
                                        }],
                                        "ack_mode": "string",
                                        "round_robin_config": {
                                            "enabled": False,
                                            "rotate_after_seconds": float(0),
                                        },
                                        "time_to_ack_interval_condition": "string",
                                        "time_to_ack_seconds": float(0),
                                        "time_to_ack_weekday_interval_config_id": "string",
                                    },
                                    "notify_channel": {
                                        "targets": [{
                                            "id": "string",
                                            "type": "string",
                                            "urgency": "string",
                                            "schedule_mode": "string",
                                        }],
                                        "time_to_ack_interval_condition": "string",
                                        "time_to_ack_seconds": float(0),
                                        "time_to_ack_weekday_interval_config_id": "string",
                                    },
                                    "repeat": {
                                        "repeat_times": float(0),
                                        "to_node": "string",
                                    },
                                }],
                                "else_paths": [{
                                    "type": "string",
                                    "delay": {
                                        "delay_interval_condition": "string",
                                        "delay_seconds": float(0),
                                        "delay_weekday_interval_config_id": "string",
                                    },
                                    "id": "string",
                                    "if_else": {
                                        "conditions": [{
                                            "operation": "string",
                                            "param_bindings": [{
                                                "array_values": [{
                                                    "literal": "string",
                                                    "reference": "string",
                                                }],
                                                "value": {
                                                    "literal": "string",
                                                    "reference": "string",
                                                },
                                            }],
                                            "subject": "string",
                                        }],
                                        "then_paths": [{
                                            "type": "string",
                                            "delay": {
                                                "delay_interval_condition": "string",
                                                "delay_seconds": float(0),
                                                "delay_weekday_interval_config_id": "string",
                                            },
                                            "id": "string",
                                            "if_else": {
                                                "conditions": [{
                                                    "operation": "string",
                                                    "param_bindings": [{
                                                        "array_values": [{
                                                            "literal": "string",
                                                            "reference": "string",
                                                        }],
                                                        "value": {
                                                            "literal": "string",
                                                            "reference": "string",
                                                        },
                                                    }],
                                                    "subject": "string",
                                                }],
                                                "then_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                                "else_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                            },
                                            "level": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "ack_mode": "string",
                                                "round_robin_config": {
                                                    "enabled": False,
                                                    "rotate_after_seconds": float(0),
                                                },
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "notify_channel": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "repeat": {
                                                "repeat_times": float(0),
                                                "to_node": "string",
                                            },
                                        }],
                                        "else_paths": [{
                                            "type": "string",
                                            "delay": {
                                                "delay_interval_condition": "string",
                                                "delay_seconds": float(0),
                                                "delay_weekday_interval_config_id": "string",
                                            },
                                            "id": "string",
                                            "if_else": {
                                                "conditions": [{
                                                    "operation": "string",
                                                    "param_bindings": [{
                                                        "array_values": [{
                                                            "literal": "string",
                                                            "reference": "string",
                                                        }],
                                                        "value": {
                                                            "literal": "string",
                                                            "reference": "string",
                                                        },
                                                    }],
                                                    "subject": "string",
                                                }],
                                                "then_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                                "else_paths": [{
                                                    "type": "string",
                                                    "delay": {
                                                        "delay_interval_condition": "string",
                                                        "delay_seconds": float(0),
                                                        "delay_weekday_interval_config_id": "string",
                                                    },
                                                    "id": "string",
                                                    "level": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "ack_mode": "string",
                                                        "round_robin_config": {
                                                            "enabled": False,
                                                            "rotate_after_seconds": float(0),
                                                        },
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "notify_channel": {
                                                        "targets": [{
                                                            "id": "string",
                                                            "type": "string",
                                                            "urgency": "string",
                                                            "schedule_mode": "string",
                                                        }],
                                                        "time_to_ack_interval_condition": "string",
                                                        "time_to_ack_seconds": float(0),
                                                        "time_to_ack_weekday_interval_config_id": "string",
                                                    },
                                                    "repeat": {
                                                        "repeat_times": float(0),
                                                        "to_node": "string",
                                                    },
                                                }],
                                            },
                                            "level": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "ack_mode": "string",
                                                "round_robin_config": {
                                                    "enabled": False,
                                                    "rotate_after_seconds": float(0),
                                                },
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "notify_channel": {
                                                "targets": [{
                                                    "id": "string",
                                                    "type": "string",
                                                    "urgency": "string",
                                                    "schedule_mode": "string",
                                                }],
                                                "time_to_ack_interval_condition": "string",
                                                "time_to_ack_seconds": float(0),
                                                "time_to_ack_weekday_interval_config_id": "string",
                                            },
                                            "repeat": {
                                                "repeat_times": float(0),
                                                "to_node": "string",
                                            },
                                        }],
                                    },
                                    "level": {
                                        "targets": [{
                                            "id": "string",
                                            "type": "string",
                                            "urgency": "string",
                                            "schedule_mode": "string",
                                        }],
                                        "ack_mode": "string",
                                        "round_robin_config": {
                                            "enabled": False,
                                            "rotate_after_seconds": float(0),
                                        },
                                        "time_to_ack_interval_condition": "string",
                                        "time_to_ack_seconds": float(0),
                                        "time_to_ack_weekday_interval_config_id": "string",
                                    },
                                    "notify_channel": {
                                        "targets": [{
                                            "id": "string",
                                            "type": "string",
                                            "urgency": "string",
                                            "schedule_mode": "string",
                                        }],
                                        "time_to_ack_interval_condition": "string",
                                        "time_to_ack_seconds": float(0),
                                        "time_to_ack_weekday_interval_config_id": "string",
                                    },
                                    "repeat": {
                                        "repeat_times": float(0),
                                        "to_node": "string",
                                    },
                                }],
                            },
                            "level": {
                                "targets": [{
                                    "id": "string",
                                    "type": "string",
                                    "urgency": "string",
                                    "schedule_mode": "string",
                                }],
                                "ack_mode": "string",
                                "round_robin_config": {
                                    "enabled": False,
                                    "rotate_after_seconds": float(0),
                                },
                                "time_to_ack_interval_condition": "string",
                                "time_to_ack_seconds": float(0),
                                "time_to_ack_weekday_interval_config_id": "string",
                            },
                            "notify_channel": {
                                "targets": [{
                                    "id": "string",
                                    "type": "string",
                                    "urgency": "string",
                                    "schedule_mode": "string",
                                }],
                                "time_to_ack_interval_condition": "string",
                                "time_to_ack_seconds": float(0),
                                "time_to_ack_weekday_interval_config_id": "string",
                            },
                            "repeat": {
                                "repeat_times": float(0),
                                "to_node": "string",
                            },
                        }],
                    },
                    "level": {
                        "targets": [{
                            "id": "string",
                            "type": "string",
                            "urgency": "string",
                            "schedule_mode": "string",
                        }],
                        "ack_mode": "string",
                        "round_robin_config": {
                            "enabled": False,
                            "rotate_after_seconds": float(0),
                        },
                        "time_to_ack_interval_condition": "string",
                        "time_to_ack_seconds": float(0),
                        "time_to_ack_weekday_interval_config_id": "string",
                    },
                    "notify_channel": {
                        "targets": [{
                            "id": "string",
                            "type": "string",
                            "urgency": "string",
                            "schedule_mode": "string",
                        }],
                        "time_to_ack_interval_condition": "string",
                        "time_to_ack_seconds": float(0),
                        "time_to_ack_weekday_interval_config_id": "string",
                    },
                    "repeat": {
                        "repeat_times": float(0),
                        "to_node": "string",
                    },
                }],
            },
            "level": {
                "targets": [{
                    "id": "string",
                    "type": "string",
                    "urgency": "string",
                    "schedule_mode": "string",
                }],
                "ack_mode": "string",
                "round_robin_config": {
                    "enabled": False,
                    "rotate_after_seconds": float(0),
                },
                "time_to_ack_interval_condition": "string",
                "time_to_ack_seconds": float(0),
                "time_to_ack_weekday_interval_config_id": "string",
            },
            "notify_channel": {
                "targets": [{
                    "id": "string",
                    "type": "string",
                    "urgency": "string",
                    "schedule_mode": "string",
                }],
                "time_to_ack_interval_condition": "string",
                "time_to_ack_seconds": float(0),
                "time_to_ack_weekday_interval_config_id": "string",
            },
            "repeat": {
                "repeat_times": float(0),
                "to_node": "string",
            },
        }],
        name="string",
        repeat_config={
            "delay_repeat_on_activity": False,
            "repeat_after_seconds": float(0),
        },
        team_ids=["string"],
        working_hours=[{
            "id": "string",
            "name": "string",
            "timezone": "string",
            "weekday_intervals": [{
                "end_time": "string",
                "start_time": "string",
                "weekday": "string",
            }],
        }])
    
    const escalationPathResource = new incident.EscalationPath("escalationPathResource", {
        paths: [{
            type: "string",
            delay: {
                delayIntervalCondition: "string",
                delaySeconds: 0,
                delayWeekdayIntervalConfigId: "string",
            },
            id: "string",
            ifElse: {
                conditions: [{
                    operation: "string",
                    paramBindings: [{
                        arrayValues: [{
                            literal: "string",
                            reference: "string",
                        }],
                        value: {
                            literal: "string",
                            reference: "string",
                        },
                    }],
                    subject: "string",
                }],
                thenPaths: [{
                    type: "string",
                    delay: {
                        delayIntervalCondition: "string",
                        delaySeconds: 0,
                        delayWeekdayIntervalConfigId: "string",
                    },
                    id: "string",
                    ifElse: {
                        conditions: [{
                            operation: "string",
                            paramBindings: [{
                                arrayValues: [{
                                    literal: "string",
                                    reference: "string",
                                }],
                                value: {
                                    literal: "string",
                                    reference: "string",
                                },
                            }],
                            subject: "string",
                        }],
                        thenPaths: [{
                            type: "string",
                            delay: {
                                delayIntervalCondition: "string",
                                delaySeconds: 0,
                                delayWeekdayIntervalConfigId: "string",
                            },
                            id: "string",
                            ifElse: {
                                conditions: [{
                                    operation: "string",
                                    paramBindings: [{
                                        arrayValues: [{
                                            literal: "string",
                                            reference: "string",
                                        }],
                                        value: {
                                            literal: "string",
                                            reference: "string",
                                        },
                                    }],
                                    subject: "string",
                                }],
                                thenPaths: [{
                                    type: "string",
                                    delay: {
                                        delayIntervalCondition: "string",
                                        delaySeconds: 0,
                                        delayWeekdayIntervalConfigId: "string",
                                    },
                                    id: "string",
                                    ifElse: {
                                        conditions: [{
                                            operation: "string",
                                            paramBindings: [{
                                                arrayValues: [{
                                                    literal: "string",
                                                    reference: "string",
                                                }],
                                                value: {
                                                    literal: "string",
                                                    reference: "string",
                                                },
                                            }],
                                            subject: "string",
                                        }],
                                        thenPaths: [{
                                            type: "string",
                                            delay: {
                                                delayIntervalCondition: "string",
                                                delaySeconds: 0,
                                                delayWeekdayIntervalConfigId: "string",
                                            },
                                            id: "string",
                                            ifElse: {
                                                conditions: [{
                                                    operation: "string",
                                                    paramBindings: [{
                                                        arrayValues: [{
                                                            literal: "string",
                                                            reference: "string",
                                                        }],
                                                        value: {
                                                            literal: "string",
                                                            reference: "string",
                                                        },
                                                    }],
                                                    subject: "string",
                                                }],
                                                thenPaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                                elsePaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                            },
                                            level: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                ackMode: "string",
                                                roundRobinConfig: {
                                                    enabled: false,
                                                    rotateAfterSeconds: 0,
                                                },
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            notifyChannel: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            repeat: {
                                                repeatTimes: 0,
                                                toNode: "string",
                                            },
                                        }],
                                        elsePaths: [{
                                            type: "string",
                                            delay: {
                                                delayIntervalCondition: "string",
                                                delaySeconds: 0,
                                                delayWeekdayIntervalConfigId: "string",
                                            },
                                            id: "string",
                                            ifElse: {
                                                conditions: [{
                                                    operation: "string",
                                                    paramBindings: [{
                                                        arrayValues: [{
                                                            literal: "string",
                                                            reference: "string",
                                                        }],
                                                        value: {
                                                            literal: "string",
                                                            reference: "string",
                                                        },
                                                    }],
                                                    subject: "string",
                                                }],
                                                thenPaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                                elsePaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                            },
                                            level: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                ackMode: "string",
                                                roundRobinConfig: {
                                                    enabled: false,
                                                    rotateAfterSeconds: 0,
                                                },
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            notifyChannel: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            repeat: {
                                                repeatTimes: 0,
                                                toNode: "string",
                                            },
                                        }],
                                    },
                                    level: {
                                        targets: [{
                                            id: "string",
                                            type: "string",
                                            urgency: "string",
                                            scheduleMode: "string",
                                        }],
                                        ackMode: "string",
                                        roundRobinConfig: {
                                            enabled: false,
                                            rotateAfterSeconds: 0,
                                        },
                                        timeToAckIntervalCondition: "string",
                                        timeToAckSeconds: 0,
                                        timeToAckWeekdayIntervalConfigId: "string",
                                    },
                                    notifyChannel: {
                                        targets: [{
                                            id: "string",
                                            type: "string",
                                            urgency: "string",
                                            scheduleMode: "string",
                                        }],
                                        timeToAckIntervalCondition: "string",
                                        timeToAckSeconds: 0,
                                        timeToAckWeekdayIntervalConfigId: "string",
                                    },
                                    repeat: {
                                        repeatTimes: 0,
                                        toNode: "string",
                                    },
                                }],
                                elsePaths: [{
                                    type: "string",
                                    delay: {
                                        delayIntervalCondition: "string",
                                        delaySeconds: 0,
                                        delayWeekdayIntervalConfigId: "string",
                                    },
                                    id: "string",
                                    ifElse: {
                                        conditions: [{
                                            operation: "string",
                                            paramBindings: [{
                                                arrayValues: [{
                                                    literal: "string",
                                                    reference: "string",
                                                }],
                                                value: {
                                                    literal: "string",
                                                    reference: "string",
                                                },
                                            }],
                                            subject: "string",
                                        }],
                                        thenPaths: [{
                                            type: "string",
                                            delay: {
                                                delayIntervalCondition: "string",
                                                delaySeconds: 0,
                                                delayWeekdayIntervalConfigId: "string",
                                            },
                                            id: "string",
                                            ifElse: {
                                                conditions: [{
                                                    operation: "string",
                                                    paramBindings: [{
                                                        arrayValues: [{
                                                            literal: "string",
                                                            reference: "string",
                                                        }],
                                                        value: {
                                                            literal: "string",
                                                            reference: "string",
                                                        },
                                                    }],
                                                    subject: "string",
                                                }],
                                                thenPaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                                elsePaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                            },
                                            level: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                ackMode: "string",
                                                roundRobinConfig: {
                                                    enabled: false,
                                                    rotateAfterSeconds: 0,
                                                },
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            notifyChannel: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            repeat: {
                                                repeatTimes: 0,
                                                toNode: "string",
                                            },
                                        }],
                                        elsePaths: [{
                                            type: "string",
                                            delay: {
                                                delayIntervalCondition: "string",
                                                delaySeconds: 0,
                                                delayWeekdayIntervalConfigId: "string",
                                            },
                                            id: "string",
                                            ifElse: {
                                                conditions: [{
                                                    operation: "string",
                                                    paramBindings: [{
                                                        arrayValues: [{
                                                            literal: "string",
                                                            reference: "string",
                                                        }],
                                                        value: {
                                                            literal: "string",
                                                            reference: "string",
                                                        },
                                                    }],
                                                    subject: "string",
                                                }],
                                                thenPaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                                elsePaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                            },
                                            level: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                ackMode: "string",
                                                roundRobinConfig: {
                                                    enabled: false,
                                                    rotateAfterSeconds: 0,
                                                },
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            notifyChannel: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            repeat: {
                                                repeatTimes: 0,
                                                toNode: "string",
                                            },
                                        }],
                                    },
                                    level: {
                                        targets: [{
                                            id: "string",
                                            type: "string",
                                            urgency: "string",
                                            scheduleMode: "string",
                                        }],
                                        ackMode: "string",
                                        roundRobinConfig: {
                                            enabled: false,
                                            rotateAfterSeconds: 0,
                                        },
                                        timeToAckIntervalCondition: "string",
                                        timeToAckSeconds: 0,
                                        timeToAckWeekdayIntervalConfigId: "string",
                                    },
                                    notifyChannel: {
                                        targets: [{
                                            id: "string",
                                            type: "string",
                                            urgency: "string",
                                            scheduleMode: "string",
                                        }],
                                        timeToAckIntervalCondition: "string",
                                        timeToAckSeconds: 0,
                                        timeToAckWeekdayIntervalConfigId: "string",
                                    },
                                    repeat: {
                                        repeatTimes: 0,
                                        toNode: "string",
                                    },
                                }],
                            },
                            level: {
                                targets: [{
                                    id: "string",
                                    type: "string",
                                    urgency: "string",
                                    scheduleMode: "string",
                                }],
                                ackMode: "string",
                                roundRobinConfig: {
                                    enabled: false,
                                    rotateAfterSeconds: 0,
                                },
                                timeToAckIntervalCondition: "string",
                                timeToAckSeconds: 0,
                                timeToAckWeekdayIntervalConfigId: "string",
                            },
                            notifyChannel: {
                                targets: [{
                                    id: "string",
                                    type: "string",
                                    urgency: "string",
                                    scheduleMode: "string",
                                }],
                                timeToAckIntervalCondition: "string",
                                timeToAckSeconds: 0,
                                timeToAckWeekdayIntervalConfigId: "string",
                            },
                            repeat: {
                                repeatTimes: 0,
                                toNode: "string",
                            },
                        }],
                        elsePaths: [{
                            type: "string",
                            delay: {
                                delayIntervalCondition: "string",
                                delaySeconds: 0,
                                delayWeekdayIntervalConfigId: "string",
                            },
                            id: "string",
                            ifElse: {
                                conditions: [{
                                    operation: "string",
                                    paramBindings: [{
                                        arrayValues: [{
                                            literal: "string",
                                            reference: "string",
                                        }],
                                        value: {
                                            literal: "string",
                                            reference: "string",
                                        },
                                    }],
                                    subject: "string",
                                }],
                                thenPaths: [{
                                    type: "string",
                                    delay: {
                                        delayIntervalCondition: "string",
                                        delaySeconds: 0,
                                        delayWeekdayIntervalConfigId: "string",
                                    },
                                    id: "string",
                                    ifElse: {
                                        conditions: [{
                                            operation: "string",
                                            paramBindings: [{
                                                arrayValues: [{
                                                    literal: "string",
                                                    reference: "string",
                                                }],
                                                value: {
                                                    literal: "string",
                                                    reference: "string",
                                                },
                                            }],
                                            subject: "string",
                                        }],
                                        thenPaths: [{
                                            type: "string",
                                            delay: {
                                                delayIntervalCondition: "string",
                                                delaySeconds: 0,
                                                delayWeekdayIntervalConfigId: "string",
                                            },
                                            id: "string",
                                            ifElse: {
                                                conditions: [{
                                                    operation: "string",
                                                    paramBindings: [{
                                                        arrayValues: [{
                                                            literal: "string",
                                                            reference: "string",
                                                        }],
                                                        value: {
                                                            literal: "string",
                                                            reference: "string",
                                                        },
                                                    }],
                                                    subject: "string",
                                                }],
                                                thenPaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                                elsePaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                            },
                                            level: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                ackMode: "string",
                                                roundRobinConfig: {
                                                    enabled: false,
                                                    rotateAfterSeconds: 0,
                                                },
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            notifyChannel: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            repeat: {
                                                repeatTimes: 0,
                                                toNode: "string",
                                            },
                                        }],
                                        elsePaths: [{
                                            type: "string",
                                            delay: {
                                                delayIntervalCondition: "string",
                                                delaySeconds: 0,
                                                delayWeekdayIntervalConfigId: "string",
                                            },
                                            id: "string",
                                            ifElse: {
                                                conditions: [{
                                                    operation: "string",
                                                    paramBindings: [{
                                                        arrayValues: [{
                                                            literal: "string",
                                                            reference: "string",
                                                        }],
                                                        value: {
                                                            literal: "string",
                                                            reference: "string",
                                                        },
                                                    }],
                                                    subject: "string",
                                                }],
                                                thenPaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                                elsePaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                            },
                                            level: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                ackMode: "string",
                                                roundRobinConfig: {
                                                    enabled: false,
                                                    rotateAfterSeconds: 0,
                                                },
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            notifyChannel: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            repeat: {
                                                repeatTimes: 0,
                                                toNode: "string",
                                            },
                                        }],
                                    },
                                    level: {
                                        targets: [{
                                            id: "string",
                                            type: "string",
                                            urgency: "string",
                                            scheduleMode: "string",
                                        }],
                                        ackMode: "string",
                                        roundRobinConfig: {
                                            enabled: false,
                                            rotateAfterSeconds: 0,
                                        },
                                        timeToAckIntervalCondition: "string",
                                        timeToAckSeconds: 0,
                                        timeToAckWeekdayIntervalConfigId: "string",
                                    },
                                    notifyChannel: {
                                        targets: [{
                                            id: "string",
                                            type: "string",
                                            urgency: "string",
                                            scheduleMode: "string",
                                        }],
                                        timeToAckIntervalCondition: "string",
                                        timeToAckSeconds: 0,
                                        timeToAckWeekdayIntervalConfigId: "string",
                                    },
                                    repeat: {
                                        repeatTimes: 0,
                                        toNode: "string",
                                    },
                                }],
                                elsePaths: [{
                                    type: "string",
                                    delay: {
                                        delayIntervalCondition: "string",
                                        delaySeconds: 0,
                                        delayWeekdayIntervalConfigId: "string",
                                    },
                                    id: "string",
                                    ifElse: {
                                        conditions: [{
                                            operation: "string",
                                            paramBindings: [{
                                                arrayValues: [{
                                                    literal: "string",
                                                    reference: "string",
                                                }],
                                                value: {
                                                    literal: "string",
                                                    reference: "string",
                                                },
                                            }],
                                            subject: "string",
                                        }],
                                        thenPaths: [{
                                            type: "string",
                                            delay: {
                                                delayIntervalCondition: "string",
                                                delaySeconds: 0,
                                                delayWeekdayIntervalConfigId: "string",
                                            },
                                            id: "string",
                                            ifElse: {
                                                conditions: [{
                                                    operation: "string",
                                                    paramBindings: [{
                                                        arrayValues: [{
                                                            literal: "string",
                                                            reference: "string",
                                                        }],
                                                        value: {
                                                            literal: "string",
                                                            reference: "string",
                                                        },
                                                    }],
                                                    subject: "string",
                                                }],
                                                thenPaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                                elsePaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                            },
                                            level: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                ackMode: "string",
                                                roundRobinConfig: {
                                                    enabled: false,
                                                    rotateAfterSeconds: 0,
                                                },
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            notifyChannel: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            repeat: {
                                                repeatTimes: 0,
                                                toNode: "string",
                                            },
                                        }],
                                        elsePaths: [{
                                            type: "string",
                                            delay: {
                                                delayIntervalCondition: "string",
                                                delaySeconds: 0,
                                                delayWeekdayIntervalConfigId: "string",
                                            },
                                            id: "string",
                                            ifElse: {
                                                conditions: [{
                                                    operation: "string",
                                                    paramBindings: [{
                                                        arrayValues: [{
                                                            literal: "string",
                                                            reference: "string",
                                                        }],
                                                        value: {
                                                            literal: "string",
                                                            reference: "string",
                                                        },
                                                    }],
                                                    subject: "string",
                                                }],
                                                thenPaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                                elsePaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                            },
                                            level: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                ackMode: "string",
                                                roundRobinConfig: {
                                                    enabled: false,
                                                    rotateAfterSeconds: 0,
                                                },
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            notifyChannel: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            repeat: {
                                                repeatTimes: 0,
                                                toNode: "string",
                                            },
                                        }],
                                    },
                                    level: {
                                        targets: [{
                                            id: "string",
                                            type: "string",
                                            urgency: "string",
                                            scheduleMode: "string",
                                        }],
                                        ackMode: "string",
                                        roundRobinConfig: {
                                            enabled: false,
                                            rotateAfterSeconds: 0,
                                        },
                                        timeToAckIntervalCondition: "string",
                                        timeToAckSeconds: 0,
                                        timeToAckWeekdayIntervalConfigId: "string",
                                    },
                                    notifyChannel: {
                                        targets: [{
                                            id: "string",
                                            type: "string",
                                            urgency: "string",
                                            scheduleMode: "string",
                                        }],
                                        timeToAckIntervalCondition: "string",
                                        timeToAckSeconds: 0,
                                        timeToAckWeekdayIntervalConfigId: "string",
                                    },
                                    repeat: {
                                        repeatTimes: 0,
                                        toNode: "string",
                                    },
                                }],
                            },
                            level: {
                                targets: [{
                                    id: "string",
                                    type: "string",
                                    urgency: "string",
                                    scheduleMode: "string",
                                }],
                                ackMode: "string",
                                roundRobinConfig: {
                                    enabled: false,
                                    rotateAfterSeconds: 0,
                                },
                                timeToAckIntervalCondition: "string",
                                timeToAckSeconds: 0,
                                timeToAckWeekdayIntervalConfigId: "string",
                            },
                            notifyChannel: {
                                targets: [{
                                    id: "string",
                                    type: "string",
                                    urgency: "string",
                                    scheduleMode: "string",
                                }],
                                timeToAckIntervalCondition: "string",
                                timeToAckSeconds: 0,
                                timeToAckWeekdayIntervalConfigId: "string",
                            },
                            repeat: {
                                repeatTimes: 0,
                                toNode: "string",
                            },
                        }],
                    },
                    level: {
                        targets: [{
                            id: "string",
                            type: "string",
                            urgency: "string",
                            scheduleMode: "string",
                        }],
                        ackMode: "string",
                        roundRobinConfig: {
                            enabled: false,
                            rotateAfterSeconds: 0,
                        },
                        timeToAckIntervalCondition: "string",
                        timeToAckSeconds: 0,
                        timeToAckWeekdayIntervalConfigId: "string",
                    },
                    notifyChannel: {
                        targets: [{
                            id: "string",
                            type: "string",
                            urgency: "string",
                            scheduleMode: "string",
                        }],
                        timeToAckIntervalCondition: "string",
                        timeToAckSeconds: 0,
                        timeToAckWeekdayIntervalConfigId: "string",
                    },
                    repeat: {
                        repeatTimes: 0,
                        toNode: "string",
                    },
                }],
                elsePaths: [{
                    type: "string",
                    delay: {
                        delayIntervalCondition: "string",
                        delaySeconds: 0,
                        delayWeekdayIntervalConfigId: "string",
                    },
                    id: "string",
                    ifElse: {
                        conditions: [{
                            operation: "string",
                            paramBindings: [{
                                arrayValues: [{
                                    literal: "string",
                                    reference: "string",
                                }],
                                value: {
                                    literal: "string",
                                    reference: "string",
                                },
                            }],
                            subject: "string",
                        }],
                        thenPaths: [{
                            type: "string",
                            delay: {
                                delayIntervalCondition: "string",
                                delaySeconds: 0,
                                delayWeekdayIntervalConfigId: "string",
                            },
                            id: "string",
                            ifElse: {
                                conditions: [{
                                    operation: "string",
                                    paramBindings: [{
                                        arrayValues: [{
                                            literal: "string",
                                            reference: "string",
                                        }],
                                        value: {
                                            literal: "string",
                                            reference: "string",
                                        },
                                    }],
                                    subject: "string",
                                }],
                                thenPaths: [{
                                    type: "string",
                                    delay: {
                                        delayIntervalCondition: "string",
                                        delaySeconds: 0,
                                        delayWeekdayIntervalConfigId: "string",
                                    },
                                    id: "string",
                                    ifElse: {
                                        conditions: [{
                                            operation: "string",
                                            paramBindings: [{
                                                arrayValues: [{
                                                    literal: "string",
                                                    reference: "string",
                                                }],
                                                value: {
                                                    literal: "string",
                                                    reference: "string",
                                                },
                                            }],
                                            subject: "string",
                                        }],
                                        thenPaths: [{
                                            type: "string",
                                            delay: {
                                                delayIntervalCondition: "string",
                                                delaySeconds: 0,
                                                delayWeekdayIntervalConfigId: "string",
                                            },
                                            id: "string",
                                            ifElse: {
                                                conditions: [{
                                                    operation: "string",
                                                    paramBindings: [{
                                                        arrayValues: [{
                                                            literal: "string",
                                                            reference: "string",
                                                        }],
                                                        value: {
                                                            literal: "string",
                                                            reference: "string",
                                                        },
                                                    }],
                                                    subject: "string",
                                                }],
                                                thenPaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                                elsePaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                            },
                                            level: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                ackMode: "string",
                                                roundRobinConfig: {
                                                    enabled: false,
                                                    rotateAfterSeconds: 0,
                                                },
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            notifyChannel: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            repeat: {
                                                repeatTimes: 0,
                                                toNode: "string",
                                            },
                                        }],
                                        elsePaths: [{
                                            type: "string",
                                            delay: {
                                                delayIntervalCondition: "string",
                                                delaySeconds: 0,
                                                delayWeekdayIntervalConfigId: "string",
                                            },
                                            id: "string",
                                            ifElse: {
                                                conditions: [{
                                                    operation: "string",
                                                    paramBindings: [{
                                                        arrayValues: [{
                                                            literal: "string",
                                                            reference: "string",
                                                        }],
                                                        value: {
                                                            literal: "string",
                                                            reference: "string",
                                                        },
                                                    }],
                                                    subject: "string",
                                                }],
                                                thenPaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                                elsePaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                            },
                                            level: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                ackMode: "string",
                                                roundRobinConfig: {
                                                    enabled: false,
                                                    rotateAfterSeconds: 0,
                                                },
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            notifyChannel: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            repeat: {
                                                repeatTimes: 0,
                                                toNode: "string",
                                            },
                                        }],
                                    },
                                    level: {
                                        targets: [{
                                            id: "string",
                                            type: "string",
                                            urgency: "string",
                                            scheduleMode: "string",
                                        }],
                                        ackMode: "string",
                                        roundRobinConfig: {
                                            enabled: false,
                                            rotateAfterSeconds: 0,
                                        },
                                        timeToAckIntervalCondition: "string",
                                        timeToAckSeconds: 0,
                                        timeToAckWeekdayIntervalConfigId: "string",
                                    },
                                    notifyChannel: {
                                        targets: [{
                                            id: "string",
                                            type: "string",
                                            urgency: "string",
                                            scheduleMode: "string",
                                        }],
                                        timeToAckIntervalCondition: "string",
                                        timeToAckSeconds: 0,
                                        timeToAckWeekdayIntervalConfigId: "string",
                                    },
                                    repeat: {
                                        repeatTimes: 0,
                                        toNode: "string",
                                    },
                                }],
                                elsePaths: [{
                                    type: "string",
                                    delay: {
                                        delayIntervalCondition: "string",
                                        delaySeconds: 0,
                                        delayWeekdayIntervalConfigId: "string",
                                    },
                                    id: "string",
                                    ifElse: {
                                        conditions: [{
                                            operation: "string",
                                            paramBindings: [{
                                                arrayValues: [{
                                                    literal: "string",
                                                    reference: "string",
                                                }],
                                                value: {
                                                    literal: "string",
                                                    reference: "string",
                                                },
                                            }],
                                            subject: "string",
                                        }],
                                        thenPaths: [{
                                            type: "string",
                                            delay: {
                                                delayIntervalCondition: "string",
                                                delaySeconds: 0,
                                                delayWeekdayIntervalConfigId: "string",
                                            },
                                            id: "string",
                                            ifElse: {
                                                conditions: [{
                                                    operation: "string",
                                                    paramBindings: [{
                                                        arrayValues: [{
                                                            literal: "string",
                                                            reference: "string",
                                                        }],
                                                        value: {
                                                            literal: "string",
                                                            reference: "string",
                                                        },
                                                    }],
                                                    subject: "string",
                                                }],
                                                thenPaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                                elsePaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                            },
                                            level: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                ackMode: "string",
                                                roundRobinConfig: {
                                                    enabled: false,
                                                    rotateAfterSeconds: 0,
                                                },
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            notifyChannel: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            repeat: {
                                                repeatTimes: 0,
                                                toNode: "string",
                                            },
                                        }],
                                        elsePaths: [{
                                            type: "string",
                                            delay: {
                                                delayIntervalCondition: "string",
                                                delaySeconds: 0,
                                                delayWeekdayIntervalConfigId: "string",
                                            },
                                            id: "string",
                                            ifElse: {
                                                conditions: [{
                                                    operation: "string",
                                                    paramBindings: [{
                                                        arrayValues: [{
                                                            literal: "string",
                                                            reference: "string",
                                                        }],
                                                        value: {
                                                            literal: "string",
                                                            reference: "string",
                                                        },
                                                    }],
                                                    subject: "string",
                                                }],
                                                thenPaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                                elsePaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                            },
                                            level: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                ackMode: "string",
                                                roundRobinConfig: {
                                                    enabled: false,
                                                    rotateAfterSeconds: 0,
                                                },
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            notifyChannel: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            repeat: {
                                                repeatTimes: 0,
                                                toNode: "string",
                                            },
                                        }],
                                    },
                                    level: {
                                        targets: [{
                                            id: "string",
                                            type: "string",
                                            urgency: "string",
                                            scheduleMode: "string",
                                        }],
                                        ackMode: "string",
                                        roundRobinConfig: {
                                            enabled: false,
                                            rotateAfterSeconds: 0,
                                        },
                                        timeToAckIntervalCondition: "string",
                                        timeToAckSeconds: 0,
                                        timeToAckWeekdayIntervalConfigId: "string",
                                    },
                                    notifyChannel: {
                                        targets: [{
                                            id: "string",
                                            type: "string",
                                            urgency: "string",
                                            scheduleMode: "string",
                                        }],
                                        timeToAckIntervalCondition: "string",
                                        timeToAckSeconds: 0,
                                        timeToAckWeekdayIntervalConfigId: "string",
                                    },
                                    repeat: {
                                        repeatTimes: 0,
                                        toNode: "string",
                                    },
                                }],
                            },
                            level: {
                                targets: [{
                                    id: "string",
                                    type: "string",
                                    urgency: "string",
                                    scheduleMode: "string",
                                }],
                                ackMode: "string",
                                roundRobinConfig: {
                                    enabled: false,
                                    rotateAfterSeconds: 0,
                                },
                                timeToAckIntervalCondition: "string",
                                timeToAckSeconds: 0,
                                timeToAckWeekdayIntervalConfigId: "string",
                            },
                            notifyChannel: {
                                targets: [{
                                    id: "string",
                                    type: "string",
                                    urgency: "string",
                                    scheduleMode: "string",
                                }],
                                timeToAckIntervalCondition: "string",
                                timeToAckSeconds: 0,
                                timeToAckWeekdayIntervalConfigId: "string",
                            },
                            repeat: {
                                repeatTimes: 0,
                                toNode: "string",
                            },
                        }],
                        elsePaths: [{
                            type: "string",
                            delay: {
                                delayIntervalCondition: "string",
                                delaySeconds: 0,
                                delayWeekdayIntervalConfigId: "string",
                            },
                            id: "string",
                            ifElse: {
                                conditions: [{
                                    operation: "string",
                                    paramBindings: [{
                                        arrayValues: [{
                                            literal: "string",
                                            reference: "string",
                                        }],
                                        value: {
                                            literal: "string",
                                            reference: "string",
                                        },
                                    }],
                                    subject: "string",
                                }],
                                thenPaths: [{
                                    type: "string",
                                    delay: {
                                        delayIntervalCondition: "string",
                                        delaySeconds: 0,
                                        delayWeekdayIntervalConfigId: "string",
                                    },
                                    id: "string",
                                    ifElse: {
                                        conditions: [{
                                            operation: "string",
                                            paramBindings: [{
                                                arrayValues: [{
                                                    literal: "string",
                                                    reference: "string",
                                                }],
                                                value: {
                                                    literal: "string",
                                                    reference: "string",
                                                },
                                            }],
                                            subject: "string",
                                        }],
                                        thenPaths: [{
                                            type: "string",
                                            delay: {
                                                delayIntervalCondition: "string",
                                                delaySeconds: 0,
                                                delayWeekdayIntervalConfigId: "string",
                                            },
                                            id: "string",
                                            ifElse: {
                                                conditions: [{
                                                    operation: "string",
                                                    paramBindings: [{
                                                        arrayValues: [{
                                                            literal: "string",
                                                            reference: "string",
                                                        }],
                                                        value: {
                                                            literal: "string",
                                                            reference: "string",
                                                        },
                                                    }],
                                                    subject: "string",
                                                }],
                                                thenPaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                                elsePaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                            },
                                            level: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                ackMode: "string",
                                                roundRobinConfig: {
                                                    enabled: false,
                                                    rotateAfterSeconds: 0,
                                                },
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            notifyChannel: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            repeat: {
                                                repeatTimes: 0,
                                                toNode: "string",
                                            },
                                        }],
                                        elsePaths: [{
                                            type: "string",
                                            delay: {
                                                delayIntervalCondition: "string",
                                                delaySeconds: 0,
                                                delayWeekdayIntervalConfigId: "string",
                                            },
                                            id: "string",
                                            ifElse: {
                                                conditions: [{
                                                    operation: "string",
                                                    paramBindings: [{
                                                        arrayValues: [{
                                                            literal: "string",
                                                            reference: "string",
                                                        }],
                                                        value: {
                                                            literal: "string",
                                                            reference: "string",
                                                        },
                                                    }],
                                                    subject: "string",
                                                }],
                                                thenPaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                                elsePaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                            },
                                            level: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                ackMode: "string",
                                                roundRobinConfig: {
                                                    enabled: false,
                                                    rotateAfterSeconds: 0,
                                                },
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            notifyChannel: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            repeat: {
                                                repeatTimes: 0,
                                                toNode: "string",
                                            },
                                        }],
                                    },
                                    level: {
                                        targets: [{
                                            id: "string",
                                            type: "string",
                                            urgency: "string",
                                            scheduleMode: "string",
                                        }],
                                        ackMode: "string",
                                        roundRobinConfig: {
                                            enabled: false,
                                            rotateAfterSeconds: 0,
                                        },
                                        timeToAckIntervalCondition: "string",
                                        timeToAckSeconds: 0,
                                        timeToAckWeekdayIntervalConfigId: "string",
                                    },
                                    notifyChannel: {
                                        targets: [{
                                            id: "string",
                                            type: "string",
                                            urgency: "string",
                                            scheduleMode: "string",
                                        }],
                                        timeToAckIntervalCondition: "string",
                                        timeToAckSeconds: 0,
                                        timeToAckWeekdayIntervalConfigId: "string",
                                    },
                                    repeat: {
                                        repeatTimes: 0,
                                        toNode: "string",
                                    },
                                }],
                                elsePaths: [{
                                    type: "string",
                                    delay: {
                                        delayIntervalCondition: "string",
                                        delaySeconds: 0,
                                        delayWeekdayIntervalConfigId: "string",
                                    },
                                    id: "string",
                                    ifElse: {
                                        conditions: [{
                                            operation: "string",
                                            paramBindings: [{
                                                arrayValues: [{
                                                    literal: "string",
                                                    reference: "string",
                                                }],
                                                value: {
                                                    literal: "string",
                                                    reference: "string",
                                                },
                                            }],
                                            subject: "string",
                                        }],
                                        thenPaths: [{
                                            type: "string",
                                            delay: {
                                                delayIntervalCondition: "string",
                                                delaySeconds: 0,
                                                delayWeekdayIntervalConfigId: "string",
                                            },
                                            id: "string",
                                            ifElse: {
                                                conditions: [{
                                                    operation: "string",
                                                    paramBindings: [{
                                                        arrayValues: [{
                                                            literal: "string",
                                                            reference: "string",
                                                        }],
                                                        value: {
                                                            literal: "string",
                                                            reference: "string",
                                                        },
                                                    }],
                                                    subject: "string",
                                                }],
                                                thenPaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                                elsePaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                            },
                                            level: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                ackMode: "string",
                                                roundRobinConfig: {
                                                    enabled: false,
                                                    rotateAfterSeconds: 0,
                                                },
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            notifyChannel: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            repeat: {
                                                repeatTimes: 0,
                                                toNode: "string",
                                            },
                                        }],
                                        elsePaths: [{
                                            type: "string",
                                            delay: {
                                                delayIntervalCondition: "string",
                                                delaySeconds: 0,
                                                delayWeekdayIntervalConfigId: "string",
                                            },
                                            id: "string",
                                            ifElse: {
                                                conditions: [{
                                                    operation: "string",
                                                    paramBindings: [{
                                                        arrayValues: [{
                                                            literal: "string",
                                                            reference: "string",
                                                        }],
                                                        value: {
                                                            literal: "string",
                                                            reference: "string",
                                                        },
                                                    }],
                                                    subject: "string",
                                                }],
                                                thenPaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                                elsePaths: [{
                                                    type: "string",
                                                    delay: {
                                                        delayIntervalCondition: "string",
                                                        delaySeconds: 0,
                                                        delayWeekdayIntervalConfigId: "string",
                                                    },
                                                    id: "string",
                                                    level: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        ackMode: "string",
                                                        roundRobinConfig: {
                                                            enabled: false,
                                                            rotateAfterSeconds: 0,
                                                        },
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    notifyChannel: {
                                                        targets: [{
                                                            id: "string",
                                                            type: "string",
                                                            urgency: "string",
                                                            scheduleMode: "string",
                                                        }],
                                                        timeToAckIntervalCondition: "string",
                                                        timeToAckSeconds: 0,
                                                        timeToAckWeekdayIntervalConfigId: "string",
                                                    },
                                                    repeat: {
                                                        repeatTimes: 0,
                                                        toNode: "string",
                                                    },
                                                }],
                                            },
                                            level: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                ackMode: "string",
                                                roundRobinConfig: {
                                                    enabled: false,
                                                    rotateAfterSeconds: 0,
                                                },
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            notifyChannel: {
                                                targets: [{
                                                    id: "string",
                                                    type: "string",
                                                    urgency: "string",
                                                    scheduleMode: "string",
                                                }],
                                                timeToAckIntervalCondition: "string",
                                                timeToAckSeconds: 0,
                                                timeToAckWeekdayIntervalConfigId: "string",
                                            },
                                            repeat: {
                                                repeatTimes: 0,
                                                toNode: "string",
                                            },
                                        }],
                                    },
                                    level: {
                                        targets: [{
                                            id: "string",
                                            type: "string",
                                            urgency: "string",
                                            scheduleMode: "string",
                                        }],
                                        ackMode: "string",
                                        roundRobinConfig: {
                                            enabled: false,
                                            rotateAfterSeconds: 0,
                                        },
                                        timeToAckIntervalCondition: "string",
                                        timeToAckSeconds: 0,
                                        timeToAckWeekdayIntervalConfigId: "string",
                                    },
                                    notifyChannel: {
                                        targets: [{
                                            id: "string",
                                            type: "string",
                                            urgency: "string",
                                            scheduleMode: "string",
                                        }],
                                        timeToAckIntervalCondition: "string",
                                        timeToAckSeconds: 0,
                                        timeToAckWeekdayIntervalConfigId: "string",
                                    },
                                    repeat: {
                                        repeatTimes: 0,
                                        toNode: "string",
                                    },
                                }],
                            },
                            level: {
                                targets: [{
                                    id: "string",
                                    type: "string",
                                    urgency: "string",
                                    scheduleMode: "string",
                                }],
                                ackMode: "string",
                                roundRobinConfig: {
                                    enabled: false,
                                    rotateAfterSeconds: 0,
                                },
                                timeToAckIntervalCondition: "string",
                                timeToAckSeconds: 0,
                                timeToAckWeekdayIntervalConfigId: "string",
                            },
                            notifyChannel: {
                                targets: [{
                                    id: "string",
                                    type: "string",
                                    urgency: "string",
                                    scheduleMode: "string",
                                }],
                                timeToAckIntervalCondition: "string",
                                timeToAckSeconds: 0,
                                timeToAckWeekdayIntervalConfigId: "string",
                            },
                            repeat: {
                                repeatTimes: 0,
                                toNode: "string",
                            },
                        }],
                    },
                    level: {
                        targets: [{
                            id: "string",
                            type: "string",
                            urgency: "string",
                            scheduleMode: "string",
                        }],
                        ackMode: "string",
                        roundRobinConfig: {
                            enabled: false,
                            rotateAfterSeconds: 0,
                        },
                        timeToAckIntervalCondition: "string",
                        timeToAckSeconds: 0,
                        timeToAckWeekdayIntervalConfigId: "string",
                    },
                    notifyChannel: {
                        targets: [{
                            id: "string",
                            type: "string",
                            urgency: "string",
                            scheduleMode: "string",
                        }],
                        timeToAckIntervalCondition: "string",
                        timeToAckSeconds: 0,
                        timeToAckWeekdayIntervalConfigId: "string",
                    },
                    repeat: {
                        repeatTimes: 0,
                        toNode: "string",
                    },
                }],
            },
            level: {
                targets: [{
                    id: "string",
                    type: "string",
                    urgency: "string",
                    scheduleMode: "string",
                }],
                ackMode: "string",
                roundRobinConfig: {
                    enabled: false,
                    rotateAfterSeconds: 0,
                },
                timeToAckIntervalCondition: "string",
                timeToAckSeconds: 0,
                timeToAckWeekdayIntervalConfigId: "string",
            },
            notifyChannel: {
                targets: [{
                    id: "string",
                    type: "string",
                    urgency: "string",
                    scheduleMode: "string",
                }],
                timeToAckIntervalCondition: "string",
                timeToAckSeconds: 0,
                timeToAckWeekdayIntervalConfigId: "string",
            },
            repeat: {
                repeatTimes: 0,
                toNode: "string",
            },
        }],
        name: "string",
        repeatConfig: {
            delayRepeatOnActivity: false,
            repeatAfterSeconds: 0,
        },
        teamIds: ["string"],
        workingHours: [{
            id: "string",
            name: "string",
            timezone: "string",
            weekdayIntervals: [{
                endTime: "string",
                startTime: "string",
                weekday: "string",
            }],
        }],
    });
    
    type: incident:EscalationPath
    properties:
        name: string
        paths:
            - delay:
                delayIntervalCondition: string
                delaySeconds: 0
                delayWeekdayIntervalConfigId: string
              id: string
              ifElse:
                conditions:
                    - operation: string
                      paramBindings:
                        - arrayValues:
                            - literal: string
                              reference: string
                          value:
                            literal: string
                            reference: string
                      subject: string
                elsePaths:
                    - delay:
                        delayIntervalCondition: string
                        delaySeconds: 0
                        delayWeekdayIntervalConfigId: string
                      id: string
                      ifElse:
                        conditions:
                            - operation: string
                              paramBindings:
                                - arrayValues:
                                    - literal: string
                                      reference: string
                                  value:
                                    literal: string
                                    reference: string
                              subject: string
                        elsePaths:
                            - delay:
                                delayIntervalCondition: string
                                delaySeconds: 0
                                delayWeekdayIntervalConfigId: string
                              id: string
                              ifElse:
                                conditions:
                                    - operation: string
                                      paramBindings:
                                        - arrayValues:
                                            - literal: string
                                              reference: string
                                          value:
                                            literal: string
                                            reference: string
                                      subject: string
                                elsePaths:
                                    - delay:
                                        delayIntervalCondition: string
                                        delaySeconds: 0
                                        delayWeekdayIntervalConfigId: string
                                      id: string
                                      ifElse:
                                        conditions:
                                            - operation: string
                                              paramBindings:
                                                - arrayValues:
                                                    - literal: string
                                                      reference: string
                                                  value:
                                                    literal: string
                                                    reference: string
                                              subject: string
                                        elsePaths:
                                            - delay:
                                                delayIntervalCondition: string
                                                delaySeconds: 0
                                                delayWeekdayIntervalConfigId: string
                                              id: string
                                              ifElse:
                                                conditions:
                                                    - operation: string
                                                      paramBindings:
                                                        - arrayValues:
                                                            - literal: string
                                                              reference: string
                                                          value:
                                                            literal: string
                                                            reference: string
                                                      subject: string
                                                elsePaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                                thenPaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                              level:
                                                ackMode: string
                                                roundRobinConfig:
                                                    enabled: false
                                                    rotateAfterSeconds: 0
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              notifyChannel:
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              repeat:
                                                repeatTimes: 0
                                                toNode: string
                                              type: string
                                        thenPaths:
                                            - delay:
                                                delayIntervalCondition: string
                                                delaySeconds: 0
                                                delayWeekdayIntervalConfigId: string
                                              id: string
                                              ifElse:
                                                conditions:
                                                    - operation: string
                                                      paramBindings:
                                                        - arrayValues:
                                                            - literal: string
                                                              reference: string
                                                          value:
                                                            literal: string
                                                            reference: string
                                                      subject: string
                                                elsePaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                                thenPaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                              level:
                                                ackMode: string
                                                roundRobinConfig:
                                                    enabled: false
                                                    rotateAfterSeconds: 0
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              notifyChannel:
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              repeat:
                                                repeatTimes: 0
                                                toNode: string
                                              type: string
                                      level:
                                        ackMode: string
                                        roundRobinConfig:
                                            enabled: false
                                            rotateAfterSeconds: 0
                                        targets:
                                            - id: string
                                              scheduleMode: string
                                              type: string
                                              urgency: string
                                        timeToAckIntervalCondition: string
                                        timeToAckSeconds: 0
                                        timeToAckWeekdayIntervalConfigId: string
                                      notifyChannel:
                                        targets:
                                            - id: string
                                              scheduleMode: string
                                              type: string
                                              urgency: string
                                        timeToAckIntervalCondition: string
                                        timeToAckSeconds: 0
                                        timeToAckWeekdayIntervalConfigId: string
                                      repeat:
                                        repeatTimes: 0
                                        toNode: string
                                      type: string
                                thenPaths:
                                    - delay:
                                        delayIntervalCondition: string
                                        delaySeconds: 0
                                        delayWeekdayIntervalConfigId: string
                                      id: string
                                      ifElse:
                                        conditions:
                                            - operation: string
                                              paramBindings:
                                                - arrayValues:
                                                    - literal: string
                                                      reference: string
                                                  value:
                                                    literal: string
                                                    reference: string
                                              subject: string
                                        elsePaths:
                                            - delay:
                                                delayIntervalCondition: string
                                                delaySeconds: 0
                                                delayWeekdayIntervalConfigId: string
                                              id: string
                                              ifElse:
                                                conditions:
                                                    - operation: string
                                                      paramBindings:
                                                        - arrayValues:
                                                            - literal: string
                                                              reference: string
                                                          value:
                                                            literal: string
                                                            reference: string
                                                      subject: string
                                                elsePaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                                thenPaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                              level:
                                                ackMode: string
                                                roundRobinConfig:
                                                    enabled: false
                                                    rotateAfterSeconds: 0
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              notifyChannel:
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              repeat:
                                                repeatTimes: 0
                                                toNode: string
                                              type: string
                                        thenPaths:
                                            - delay:
                                                delayIntervalCondition: string
                                                delaySeconds: 0
                                                delayWeekdayIntervalConfigId: string
                                              id: string
                                              ifElse:
                                                conditions:
                                                    - operation: string
                                                      paramBindings:
                                                        - arrayValues:
                                                            - literal: string
                                                              reference: string
                                                          value:
                                                            literal: string
                                                            reference: string
                                                      subject: string
                                                elsePaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                                thenPaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                              level:
                                                ackMode: string
                                                roundRobinConfig:
                                                    enabled: false
                                                    rotateAfterSeconds: 0
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              notifyChannel:
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              repeat:
                                                repeatTimes: 0
                                                toNode: string
                                              type: string
                                      level:
                                        ackMode: string
                                        roundRobinConfig:
                                            enabled: false
                                            rotateAfterSeconds: 0
                                        targets:
                                            - id: string
                                              scheduleMode: string
                                              type: string
                                              urgency: string
                                        timeToAckIntervalCondition: string
                                        timeToAckSeconds: 0
                                        timeToAckWeekdayIntervalConfigId: string
                                      notifyChannel:
                                        targets:
                                            - id: string
                                              scheduleMode: string
                                              type: string
                                              urgency: string
                                        timeToAckIntervalCondition: string
                                        timeToAckSeconds: 0
                                        timeToAckWeekdayIntervalConfigId: string
                                      repeat:
                                        repeatTimes: 0
                                        toNode: string
                                      type: string
                              level:
                                ackMode: string
                                roundRobinConfig:
                                    enabled: false
                                    rotateAfterSeconds: 0
                                targets:
                                    - id: string
                                      scheduleMode: string
                                      type: string
                                      urgency: string
                                timeToAckIntervalCondition: string
                                timeToAckSeconds: 0
                                timeToAckWeekdayIntervalConfigId: string
                              notifyChannel:
                                targets:
                                    - id: string
                                      scheduleMode: string
                                      type: string
                                      urgency: string
                                timeToAckIntervalCondition: string
                                timeToAckSeconds: 0
                                timeToAckWeekdayIntervalConfigId: string
                              repeat:
                                repeatTimes: 0
                                toNode: string
                              type: string
                        thenPaths:
                            - delay:
                                delayIntervalCondition: string
                                delaySeconds: 0
                                delayWeekdayIntervalConfigId: string
                              id: string
                              ifElse:
                                conditions:
                                    - operation: string
                                      paramBindings:
                                        - arrayValues:
                                            - literal: string
                                              reference: string
                                          value:
                                            literal: string
                                            reference: string
                                      subject: string
                                elsePaths:
                                    - delay:
                                        delayIntervalCondition: string
                                        delaySeconds: 0
                                        delayWeekdayIntervalConfigId: string
                                      id: string
                                      ifElse:
                                        conditions:
                                            - operation: string
                                              paramBindings:
                                                - arrayValues:
                                                    - literal: string
                                                      reference: string
                                                  value:
                                                    literal: string
                                                    reference: string
                                              subject: string
                                        elsePaths:
                                            - delay:
                                                delayIntervalCondition: string
                                                delaySeconds: 0
                                                delayWeekdayIntervalConfigId: string
                                              id: string
                                              ifElse:
                                                conditions:
                                                    - operation: string
                                                      paramBindings:
                                                        - arrayValues:
                                                            - literal: string
                                                              reference: string
                                                          value:
                                                            literal: string
                                                            reference: string
                                                      subject: string
                                                elsePaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                                thenPaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                              level:
                                                ackMode: string
                                                roundRobinConfig:
                                                    enabled: false
                                                    rotateAfterSeconds: 0
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              notifyChannel:
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              repeat:
                                                repeatTimes: 0
                                                toNode: string
                                              type: string
                                        thenPaths:
                                            - delay:
                                                delayIntervalCondition: string
                                                delaySeconds: 0
                                                delayWeekdayIntervalConfigId: string
                                              id: string
                                              ifElse:
                                                conditions:
                                                    - operation: string
                                                      paramBindings:
                                                        - arrayValues:
                                                            - literal: string
                                                              reference: string
                                                          value:
                                                            literal: string
                                                            reference: string
                                                      subject: string
                                                elsePaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                                thenPaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                              level:
                                                ackMode: string
                                                roundRobinConfig:
                                                    enabled: false
                                                    rotateAfterSeconds: 0
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              notifyChannel:
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              repeat:
                                                repeatTimes: 0
                                                toNode: string
                                              type: string
                                      level:
                                        ackMode: string
                                        roundRobinConfig:
                                            enabled: false
                                            rotateAfterSeconds: 0
                                        targets:
                                            - id: string
                                              scheduleMode: string
                                              type: string
                                              urgency: string
                                        timeToAckIntervalCondition: string
                                        timeToAckSeconds: 0
                                        timeToAckWeekdayIntervalConfigId: string
                                      notifyChannel:
                                        targets:
                                            - id: string
                                              scheduleMode: string
                                              type: string
                                              urgency: string
                                        timeToAckIntervalCondition: string
                                        timeToAckSeconds: 0
                                        timeToAckWeekdayIntervalConfigId: string
                                      repeat:
                                        repeatTimes: 0
                                        toNode: string
                                      type: string
                                thenPaths:
                                    - delay:
                                        delayIntervalCondition: string
                                        delaySeconds: 0
                                        delayWeekdayIntervalConfigId: string
                                      id: string
                                      ifElse:
                                        conditions:
                                            - operation: string
                                              paramBindings:
                                                - arrayValues:
                                                    - literal: string
                                                      reference: string
                                                  value:
                                                    literal: string
                                                    reference: string
                                              subject: string
                                        elsePaths:
                                            - delay:
                                                delayIntervalCondition: string
                                                delaySeconds: 0
                                                delayWeekdayIntervalConfigId: string
                                              id: string
                                              ifElse:
                                                conditions:
                                                    - operation: string
                                                      paramBindings:
                                                        - arrayValues:
                                                            - literal: string
                                                              reference: string
                                                          value:
                                                            literal: string
                                                            reference: string
                                                      subject: string
                                                elsePaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                                thenPaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                              level:
                                                ackMode: string
                                                roundRobinConfig:
                                                    enabled: false
                                                    rotateAfterSeconds: 0
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              notifyChannel:
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              repeat:
                                                repeatTimes: 0
                                                toNode: string
                                              type: string
                                        thenPaths:
                                            - delay:
                                                delayIntervalCondition: string
                                                delaySeconds: 0
                                                delayWeekdayIntervalConfigId: string
                                              id: string
                                              ifElse:
                                                conditions:
                                                    - operation: string
                                                      paramBindings:
                                                        - arrayValues:
                                                            - literal: string
                                                              reference: string
                                                          value:
                                                            literal: string
                                                            reference: string
                                                      subject: string
                                                elsePaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                                thenPaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                              level:
                                                ackMode: string
                                                roundRobinConfig:
                                                    enabled: false
                                                    rotateAfterSeconds: 0
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              notifyChannel:
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              repeat:
                                                repeatTimes: 0
                                                toNode: string
                                              type: string
                                      level:
                                        ackMode: string
                                        roundRobinConfig:
                                            enabled: false
                                            rotateAfterSeconds: 0
                                        targets:
                                            - id: string
                                              scheduleMode: string
                                              type: string
                                              urgency: string
                                        timeToAckIntervalCondition: string
                                        timeToAckSeconds: 0
                                        timeToAckWeekdayIntervalConfigId: string
                                      notifyChannel:
                                        targets:
                                            - id: string
                                              scheduleMode: string
                                              type: string
                                              urgency: string
                                        timeToAckIntervalCondition: string
                                        timeToAckSeconds: 0
                                        timeToAckWeekdayIntervalConfigId: string
                                      repeat:
                                        repeatTimes: 0
                                        toNode: string
                                      type: string
                              level:
                                ackMode: string
                                roundRobinConfig:
                                    enabled: false
                                    rotateAfterSeconds: 0
                                targets:
                                    - id: string
                                      scheduleMode: string
                                      type: string
                                      urgency: string
                                timeToAckIntervalCondition: string
                                timeToAckSeconds: 0
                                timeToAckWeekdayIntervalConfigId: string
                              notifyChannel:
                                targets:
                                    - id: string
                                      scheduleMode: string
                                      type: string
                                      urgency: string
                                timeToAckIntervalCondition: string
                                timeToAckSeconds: 0
                                timeToAckWeekdayIntervalConfigId: string
                              repeat:
                                repeatTimes: 0
                                toNode: string
                              type: string
                      level:
                        ackMode: string
                        roundRobinConfig:
                            enabled: false
                            rotateAfterSeconds: 0
                        targets:
                            - id: string
                              scheduleMode: string
                              type: string
                              urgency: string
                        timeToAckIntervalCondition: string
                        timeToAckSeconds: 0
                        timeToAckWeekdayIntervalConfigId: string
                      notifyChannel:
                        targets:
                            - id: string
                              scheduleMode: string
                              type: string
                              urgency: string
                        timeToAckIntervalCondition: string
                        timeToAckSeconds: 0
                        timeToAckWeekdayIntervalConfigId: string
                      repeat:
                        repeatTimes: 0
                        toNode: string
                      type: string
                thenPaths:
                    - delay:
                        delayIntervalCondition: string
                        delaySeconds: 0
                        delayWeekdayIntervalConfigId: string
                      id: string
                      ifElse:
                        conditions:
                            - operation: string
                              paramBindings:
                                - arrayValues:
                                    - literal: string
                                      reference: string
                                  value:
                                    literal: string
                                    reference: string
                              subject: string
                        elsePaths:
                            - delay:
                                delayIntervalCondition: string
                                delaySeconds: 0
                                delayWeekdayIntervalConfigId: string
                              id: string
                              ifElse:
                                conditions:
                                    - operation: string
                                      paramBindings:
                                        - arrayValues:
                                            - literal: string
                                              reference: string
                                          value:
                                            literal: string
                                            reference: string
                                      subject: string
                                elsePaths:
                                    - delay:
                                        delayIntervalCondition: string
                                        delaySeconds: 0
                                        delayWeekdayIntervalConfigId: string
                                      id: string
                                      ifElse:
                                        conditions:
                                            - operation: string
                                              paramBindings:
                                                - arrayValues:
                                                    - literal: string
                                                      reference: string
                                                  value:
                                                    literal: string
                                                    reference: string
                                              subject: string
                                        elsePaths:
                                            - delay:
                                                delayIntervalCondition: string
                                                delaySeconds: 0
                                                delayWeekdayIntervalConfigId: string
                                              id: string
                                              ifElse:
                                                conditions:
                                                    - operation: string
                                                      paramBindings:
                                                        - arrayValues:
                                                            - literal: string
                                                              reference: string
                                                          value:
                                                            literal: string
                                                            reference: string
                                                      subject: string
                                                elsePaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                                thenPaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                              level:
                                                ackMode: string
                                                roundRobinConfig:
                                                    enabled: false
                                                    rotateAfterSeconds: 0
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              notifyChannel:
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              repeat:
                                                repeatTimes: 0
                                                toNode: string
                                              type: string
                                        thenPaths:
                                            - delay:
                                                delayIntervalCondition: string
                                                delaySeconds: 0
                                                delayWeekdayIntervalConfigId: string
                                              id: string
                                              ifElse:
                                                conditions:
                                                    - operation: string
                                                      paramBindings:
                                                        - arrayValues:
                                                            - literal: string
                                                              reference: string
                                                          value:
                                                            literal: string
                                                            reference: string
                                                      subject: string
                                                elsePaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                                thenPaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                              level:
                                                ackMode: string
                                                roundRobinConfig:
                                                    enabled: false
                                                    rotateAfterSeconds: 0
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              notifyChannel:
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              repeat:
                                                repeatTimes: 0
                                                toNode: string
                                              type: string
                                      level:
                                        ackMode: string
                                        roundRobinConfig:
                                            enabled: false
                                            rotateAfterSeconds: 0
                                        targets:
                                            - id: string
                                              scheduleMode: string
                                              type: string
                                              urgency: string
                                        timeToAckIntervalCondition: string
                                        timeToAckSeconds: 0
                                        timeToAckWeekdayIntervalConfigId: string
                                      notifyChannel:
                                        targets:
                                            - id: string
                                              scheduleMode: string
                                              type: string
                                              urgency: string
                                        timeToAckIntervalCondition: string
                                        timeToAckSeconds: 0
                                        timeToAckWeekdayIntervalConfigId: string
                                      repeat:
                                        repeatTimes: 0
                                        toNode: string
                                      type: string
                                thenPaths:
                                    - delay:
                                        delayIntervalCondition: string
                                        delaySeconds: 0
                                        delayWeekdayIntervalConfigId: string
                                      id: string
                                      ifElse:
                                        conditions:
                                            - operation: string
                                              paramBindings:
                                                - arrayValues:
                                                    - literal: string
                                                      reference: string
                                                  value:
                                                    literal: string
                                                    reference: string
                                              subject: string
                                        elsePaths:
                                            - delay:
                                                delayIntervalCondition: string
                                                delaySeconds: 0
                                                delayWeekdayIntervalConfigId: string
                                              id: string
                                              ifElse:
                                                conditions:
                                                    - operation: string
                                                      paramBindings:
                                                        - arrayValues:
                                                            - literal: string
                                                              reference: string
                                                          value:
                                                            literal: string
                                                            reference: string
                                                      subject: string
                                                elsePaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                                thenPaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                              level:
                                                ackMode: string
                                                roundRobinConfig:
                                                    enabled: false
                                                    rotateAfterSeconds: 0
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              notifyChannel:
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              repeat:
                                                repeatTimes: 0
                                                toNode: string
                                              type: string
                                        thenPaths:
                                            - delay:
                                                delayIntervalCondition: string
                                                delaySeconds: 0
                                                delayWeekdayIntervalConfigId: string
                                              id: string
                                              ifElse:
                                                conditions:
                                                    - operation: string
                                                      paramBindings:
                                                        - arrayValues:
                                                            - literal: string
                                                              reference: string
                                                          value:
                                                            literal: string
                                                            reference: string
                                                      subject: string
                                                elsePaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                                thenPaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                              level:
                                                ackMode: string
                                                roundRobinConfig:
                                                    enabled: false
                                                    rotateAfterSeconds: 0
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              notifyChannel:
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              repeat:
                                                repeatTimes: 0
                                                toNode: string
                                              type: string
                                      level:
                                        ackMode: string
                                        roundRobinConfig:
                                            enabled: false
                                            rotateAfterSeconds: 0
                                        targets:
                                            - id: string
                                              scheduleMode: string
                                              type: string
                                              urgency: string
                                        timeToAckIntervalCondition: string
                                        timeToAckSeconds: 0
                                        timeToAckWeekdayIntervalConfigId: string
                                      notifyChannel:
                                        targets:
                                            - id: string
                                              scheduleMode: string
                                              type: string
                                              urgency: string
                                        timeToAckIntervalCondition: string
                                        timeToAckSeconds: 0
                                        timeToAckWeekdayIntervalConfigId: string
                                      repeat:
                                        repeatTimes: 0
                                        toNode: string
                                      type: string
                              level:
                                ackMode: string
                                roundRobinConfig:
                                    enabled: false
                                    rotateAfterSeconds: 0
                                targets:
                                    - id: string
                                      scheduleMode: string
                                      type: string
                                      urgency: string
                                timeToAckIntervalCondition: string
                                timeToAckSeconds: 0
                                timeToAckWeekdayIntervalConfigId: string
                              notifyChannel:
                                targets:
                                    - id: string
                                      scheduleMode: string
                                      type: string
                                      urgency: string
                                timeToAckIntervalCondition: string
                                timeToAckSeconds: 0
                                timeToAckWeekdayIntervalConfigId: string
                              repeat:
                                repeatTimes: 0
                                toNode: string
                              type: string
                        thenPaths:
                            - delay:
                                delayIntervalCondition: string
                                delaySeconds: 0
                                delayWeekdayIntervalConfigId: string
                              id: string
                              ifElse:
                                conditions:
                                    - operation: string
                                      paramBindings:
                                        - arrayValues:
                                            - literal: string
                                              reference: string
                                          value:
                                            literal: string
                                            reference: string
                                      subject: string
                                elsePaths:
                                    - delay:
                                        delayIntervalCondition: string
                                        delaySeconds: 0
                                        delayWeekdayIntervalConfigId: string
                                      id: string
                                      ifElse:
                                        conditions:
                                            - operation: string
                                              paramBindings:
                                                - arrayValues:
                                                    - literal: string
                                                      reference: string
                                                  value:
                                                    literal: string
                                                    reference: string
                                              subject: string
                                        elsePaths:
                                            - delay:
                                                delayIntervalCondition: string
                                                delaySeconds: 0
                                                delayWeekdayIntervalConfigId: string
                                              id: string
                                              ifElse:
                                                conditions:
                                                    - operation: string
                                                      paramBindings:
                                                        - arrayValues:
                                                            - literal: string
                                                              reference: string
                                                          value:
                                                            literal: string
                                                            reference: string
                                                      subject: string
                                                elsePaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                                thenPaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                              level:
                                                ackMode: string
                                                roundRobinConfig:
                                                    enabled: false
                                                    rotateAfterSeconds: 0
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              notifyChannel:
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              repeat:
                                                repeatTimes: 0
                                                toNode: string
                                              type: string
                                        thenPaths:
                                            - delay:
                                                delayIntervalCondition: string
                                                delaySeconds: 0
                                                delayWeekdayIntervalConfigId: string
                                              id: string
                                              ifElse:
                                                conditions:
                                                    - operation: string
                                                      paramBindings:
                                                        - arrayValues:
                                                            - literal: string
                                                              reference: string
                                                          value:
                                                            literal: string
                                                            reference: string
                                                      subject: string
                                                elsePaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                                thenPaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                              level:
                                                ackMode: string
                                                roundRobinConfig:
                                                    enabled: false
                                                    rotateAfterSeconds: 0
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              notifyChannel:
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              repeat:
                                                repeatTimes: 0
                                                toNode: string
                                              type: string
                                      level:
                                        ackMode: string
                                        roundRobinConfig:
                                            enabled: false
                                            rotateAfterSeconds: 0
                                        targets:
                                            - id: string
                                              scheduleMode: string
                                              type: string
                                              urgency: string
                                        timeToAckIntervalCondition: string
                                        timeToAckSeconds: 0
                                        timeToAckWeekdayIntervalConfigId: string
                                      notifyChannel:
                                        targets:
                                            - id: string
                                              scheduleMode: string
                                              type: string
                                              urgency: string
                                        timeToAckIntervalCondition: string
                                        timeToAckSeconds: 0
                                        timeToAckWeekdayIntervalConfigId: string
                                      repeat:
                                        repeatTimes: 0
                                        toNode: string
                                      type: string
                                thenPaths:
                                    - delay:
                                        delayIntervalCondition: string
                                        delaySeconds: 0
                                        delayWeekdayIntervalConfigId: string
                                      id: string
                                      ifElse:
                                        conditions:
                                            - operation: string
                                              paramBindings:
                                                - arrayValues:
                                                    - literal: string
                                                      reference: string
                                                  value:
                                                    literal: string
                                                    reference: string
                                              subject: string
                                        elsePaths:
                                            - delay:
                                                delayIntervalCondition: string
                                                delaySeconds: 0
                                                delayWeekdayIntervalConfigId: string
                                              id: string
                                              ifElse:
                                                conditions:
                                                    - operation: string
                                                      paramBindings:
                                                        - arrayValues:
                                                            - literal: string
                                                              reference: string
                                                          value:
                                                            literal: string
                                                            reference: string
                                                      subject: string
                                                elsePaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                                thenPaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                              level:
                                                ackMode: string
                                                roundRobinConfig:
                                                    enabled: false
                                                    rotateAfterSeconds: 0
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              notifyChannel:
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              repeat:
                                                repeatTimes: 0
                                                toNode: string
                                              type: string
                                        thenPaths:
                                            - delay:
                                                delayIntervalCondition: string
                                                delaySeconds: 0
                                                delayWeekdayIntervalConfigId: string
                                              id: string
                                              ifElse:
                                                conditions:
                                                    - operation: string
                                                      paramBindings:
                                                        - arrayValues:
                                                            - literal: string
                                                              reference: string
                                                          value:
                                                            literal: string
                                                            reference: string
                                                      subject: string
                                                elsePaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                                thenPaths:
                                                    - delay:
                                                        delayIntervalCondition: string
                                                        delaySeconds: 0
                                                        delayWeekdayIntervalConfigId: string
                                                      id: string
                                                      level:
                                                        ackMode: string
                                                        roundRobinConfig:
                                                            enabled: false
                                                            rotateAfterSeconds: 0
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      notifyChannel:
                                                        targets:
                                                            - id: string
                                                              scheduleMode: string
                                                              type: string
                                                              urgency: string
                                                        timeToAckIntervalCondition: string
                                                        timeToAckSeconds: 0
                                                        timeToAckWeekdayIntervalConfigId: string
                                                      repeat:
                                                        repeatTimes: 0
                                                        toNode: string
                                                      type: string
                                              level:
                                                ackMode: string
                                                roundRobinConfig:
                                                    enabled: false
                                                    rotateAfterSeconds: 0
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              notifyChannel:
                                                targets:
                                                    - id: string
                                                      scheduleMode: string
                                                      type: string
                                                      urgency: string
                                                timeToAckIntervalCondition: string
                                                timeToAckSeconds: 0
                                                timeToAckWeekdayIntervalConfigId: string
                                              repeat:
                                                repeatTimes: 0
                                                toNode: string
                                              type: string
                                      level:
                                        ackMode: string
                                        roundRobinConfig:
                                            enabled: false
                                            rotateAfterSeconds: 0
                                        targets:
                                            - id: string
                                              scheduleMode: string
                                              type: string
                                              urgency: string
                                        timeToAckIntervalCondition: string
                                        timeToAckSeconds: 0
                                        timeToAckWeekdayIntervalConfigId: string
                                      notifyChannel:
                                        targets:
                                            - id: string
                                              scheduleMode: string
                                              type: string
                                              urgency: string
                                        timeToAckIntervalCondition: string
                                        timeToAckSeconds: 0
                                        timeToAckWeekdayIntervalConfigId: string
                                      repeat:
                                        repeatTimes: 0
                                        toNode: string
                                      type: string
                              level:
                                ackMode: string
                                roundRobinConfig:
                                    enabled: false
                                    rotateAfterSeconds: 0
                                targets:
                                    - id: string
                                      scheduleMode: string
                                      type: string
                                      urgency: string
                                timeToAckIntervalCondition: string
                                timeToAckSeconds: 0
                                timeToAckWeekdayIntervalConfigId: string
                              notifyChannel:
                                targets:
                                    - id: string
                                      scheduleMode: string
                                      type: string
                                      urgency: string
                                timeToAckIntervalCondition: string
                                timeToAckSeconds: 0
                                timeToAckWeekdayIntervalConfigId: string
                              repeat:
                                repeatTimes: 0
                                toNode: string
                              type: string
                      level:
                        ackMode: string
                        roundRobinConfig:
                            enabled: false
                            rotateAfterSeconds: 0
                        targets:
                            - id: string
                              scheduleMode: string
                              type: string
                              urgency: string
                        timeToAckIntervalCondition: string
                        timeToAckSeconds: 0
                        timeToAckWeekdayIntervalConfigId: string
                      notifyChannel:
                        targets:
                            - id: string
                              scheduleMode: string
                              type: string
                              urgency: string
                        timeToAckIntervalCondition: string
                        timeToAckSeconds: 0
                        timeToAckWeekdayIntervalConfigId: string
                      repeat:
                        repeatTimes: 0
                        toNode: string
                      type: string
              level:
                ackMode: string
                roundRobinConfig:
                    enabled: false
                    rotateAfterSeconds: 0
                targets:
                    - id: string
                      scheduleMode: string
                      type: string
                      urgency: string
                timeToAckIntervalCondition: string
                timeToAckSeconds: 0
                timeToAckWeekdayIntervalConfigId: string
              notifyChannel:
                targets:
                    - id: string
                      scheduleMode: string
                      type: string
                      urgency: string
                timeToAckIntervalCondition: string
                timeToAckSeconds: 0
                timeToAckWeekdayIntervalConfigId: string
              repeat:
                repeatTimes: 0
                toNode: string
              type: string
        repeatConfig:
            delayRepeatOnActivity: false
            repeatAfterSeconds: 0
        teamIds:
            - string
        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:

    Paths List<EscalationPathPath>

    The nodes that form the levels and branches of this escalation path.

    -->Note Although the if_else block is recursive, currently a maximum of 4 levels are supported. Attempting to configure more than 4 levels of nesting will result in a schema error.

    Name string
    The name of this escalation path, for the user's reference.
    RepeatConfig EscalationPathRepeatConfig
    Controls if an escalation will repeat after acknowledgement, when the alert is unresolved. When configured, it will repeat after the specified delay.
    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.
    WorkingHours List<EscalationPathWorkingHour>
    The working hours for this escalation path.
    Paths []EscalationPathPathArgs

    The nodes that form the levels and branches of this escalation path.

    -->Note Although the if_else block is recursive, currently a maximum of 4 levels are supported. Attempting to configure more than 4 levels of nesting will result in a schema error.

    Name string
    The name of this escalation path, for the user's reference.
    RepeatConfig EscalationPathRepeatConfigArgs
    Controls if an escalation will repeat after acknowledgement, when the alert is unresolved. When configured, it will repeat after the specified delay.
    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.
    WorkingHours []EscalationPathWorkingHourArgs
    The working hours for this escalation path.
    paths List<EscalationPathPath>

    The nodes that form the levels and branches of this escalation path.

    -->Note Although the if_else block is recursive, currently a maximum of 4 levels are supported. Attempting to configure more than 4 levels of nesting will result in a schema error.

    name String
    The name of this escalation path, for the user's reference.
    repeatConfig EscalationPathRepeatConfig
    Controls if an escalation will repeat after acknowledgement, when the alert is unresolved. When configured, it will repeat after the specified delay.
    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.
    workingHours List<EscalationPathWorkingHour>
    The working hours for this escalation path.
    paths EscalationPathPath[]

    The nodes that form the levels and branches of this escalation path.

    -->Note Although the if_else block is recursive, currently a maximum of 4 levels are supported. Attempting to configure more than 4 levels of nesting will result in a schema error.

    name string
    The name of this escalation path, for the user's reference.
    repeatConfig EscalationPathRepeatConfig
    Controls if an escalation will repeat after acknowledgement, when the alert is unresolved. When configured, it will repeat after the specified delay.
    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.
    workingHours EscalationPathWorkingHour[]
    The working hours for this escalation path.
    paths Sequence[EscalationPathPathArgs]

    The nodes that form the levels and branches of this escalation path.

    -->Note Although the if_else block is recursive, currently a maximum of 4 levels are supported. Attempting to configure more than 4 levels of nesting will result in a schema error.

    name str
    The name of this escalation path, for the user's reference.
    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.
    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.
    working_hours Sequence[EscalationPathWorkingHourArgs]
    The working hours for this escalation path.
    paths List<Property Map>

    The nodes that form the levels and branches of this escalation path.

    -->Note Although the if_else block is recursive, currently a maximum of 4 levels are supported. Attempting to configure more than 4 levels of nesting will result in a schema error.

    name String
    The name of this escalation path, for the user's reference.
    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.
    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.
    workingHours List<Property Map>
    The working hours for this escalation path.

    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 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,
            name: Optional[str] = None,
            paths: Optional[Sequence[EscalationPathPathArgs]] = None,
            repeat_config: Optional[EscalationPathRepeatConfigArgs] = None,
            team_ids: Optional[Sequence[str]] = 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}
    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:
    Name string
    The name of this escalation path, for the user's reference.
    Paths List<EscalationPathPath>

    The nodes that form the levels and branches of this escalation path.

    -->Note Although the if_else block is recursive, currently a maximum of 4 levels are supported. Attempting to configure more than 4 levels of nesting will result in a schema error.

    RepeatConfig EscalationPathRepeatConfig
    Controls if an escalation will repeat after acknowledgement, when the alert is unresolved. When configured, it will repeat after the specified delay.
    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.
    WorkingHours List<EscalationPathWorkingHour>
    The working hours for this escalation path.
    Name string
    The name of this escalation path, for the user's reference.
    Paths []EscalationPathPathArgs

    The nodes that form the levels and branches of this escalation path.

    -->Note Although the if_else block is recursive, currently a maximum of 4 levels are supported. Attempting to configure more than 4 levels of nesting will result in a schema error.

    RepeatConfig EscalationPathRepeatConfigArgs
    Controls if an escalation will repeat after acknowledgement, when the alert is unresolved. When configured, it will repeat after the specified delay.
    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.
    WorkingHours []EscalationPathWorkingHourArgs
    The working hours for this escalation path.
    name String
    The name of this escalation path, for the user's reference.
    paths List<EscalationPathPath>

    The nodes that form the levels and branches of this escalation path.

    -->Note Although the if_else block is recursive, currently a maximum of 4 levels are supported. Attempting to configure more than 4 levels of nesting will result in a schema error.

    repeatConfig EscalationPathRepeatConfig
    Controls if an escalation will repeat after acknowledgement, when the alert is unresolved. When configured, it will repeat after the specified delay.
    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.
    workingHours List<EscalationPathWorkingHour>
    The working hours for this escalation path.
    name string
    The name of this escalation path, for the user's reference.
    paths EscalationPathPath[]

    The nodes that form the levels and branches of this escalation path.

    -->Note Although the if_else block is recursive, currently a maximum of 4 levels are supported. Attempting to configure more than 4 levels of nesting will result in a schema error.

    repeatConfig EscalationPathRepeatConfig
    Controls if an escalation will repeat after acknowledgement, when the alert is unresolved. When configured, it will repeat after the specified delay.
    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.
    workingHours EscalationPathWorkingHour[]
    The working hours for this escalation path.
    name str
    The name of this escalation path, for the user's reference.
    paths Sequence[EscalationPathPathArgs]

    The nodes that form the levels and branches of this escalation path.

    -->Note Although the if_else block is recursive, currently a maximum of 4 levels are supported. Attempting to configure more than 4 levels of nesting will result in a schema error.

    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.
    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.
    working_hours Sequence[EscalationPathWorkingHourArgs]
    The working hours for this escalation path.
    name String
    The name of this escalation path, for the user's reference.
    paths List<Property Map>

    The nodes that form the levels and branches of this escalation path.

    -->Note Although the if_else block is recursive, currently a maximum of 4 levels are supported. Attempting to configure more than 4 levels of nesting will result in a schema error.

    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.
    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.
    workingHours List<Property Map>
    The working hours for this escalation path.

    Supporting Types

    EscalationPathPath, EscalationPathPathArgs

    Type string
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    Delay EscalationPathPathDelay
    Id string

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    IfElse EscalationPathPathIfElse
    Level EscalationPathPathLevel
    NotifyChannel EscalationPathPathNotifyChannel
    Repeat EscalationPathPathRepeat
    Type string
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    Delay EscalationPathPathDelay
    Id string

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    IfElse EscalationPathPathIfElse
    Level EscalationPathPathLevel
    NotifyChannel EscalationPathPathNotifyChannel
    Repeat EscalationPathPathRepeat
    type String
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay EscalationPathPathDelay
    id String

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    ifElse EscalationPathPathIfElse
    level EscalationPathPathLevel
    notifyChannel EscalationPathPathNotifyChannel
    repeat EscalationPathPathRepeat
    type string
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay EscalationPathPathDelay
    id string

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    ifElse EscalationPathPathIfElse
    level EscalationPathPathLevel
    notifyChannel EscalationPathPathNotifyChannel
    repeat EscalationPathPathRepeat
    type str
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay EscalationPathPathDelay
    id str

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    if_else EscalationPathPathIfElse
    level EscalationPathPathLevel
    notify_channel EscalationPathPathNotifyChannel
    repeat EscalationPathPathRepeat
    type String
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay Property Map
    id String

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    ifElse Property Map
    level Property Map
    notifyChannel Property Map
    repeat Property Map

    EscalationPathPathDelay, EscalationPathPathDelayArgs

    DelayIntervalCondition string
    If the delay is relative to a time window, this defines whether we advance when the window is active or inactive
    DelaySeconds double
    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
    DelaySeconds float64
    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
    delaySeconds Double
    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
    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
    delay_seconds float
    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
    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

    EscalationPathPathIfElse, EscalationPathPathIfElseArgs

    Conditions List<EscalationPathPathIfElseCondition>
    The prerequisite conditions that must all be satisfied
    ThenPaths List<EscalationPathPathIfElseThenPath>
    Then path nodes
    ElsePaths List<EscalationPathPathIfElseElsePath>
    The nodes that form the levels if our condition is not met
    Conditions []EscalationPathPathIfElseCondition
    The prerequisite conditions that must all be satisfied
    ThenPaths []EscalationPathPathIfElseThenPath
    Then path nodes
    ElsePaths []EscalationPathPathIfElseElsePath
    The nodes that form the levels if our condition is not met
    conditions List<EscalationPathPathIfElseCondition>
    The prerequisite conditions that must all be satisfied
    thenPaths List<EscalationPathPathIfElseThenPath>
    Then path nodes
    elsePaths List<EscalationPathPathIfElseElsePath>
    The nodes that form the levels if our condition is not met
    conditions EscalationPathPathIfElseCondition[]
    The prerequisite conditions that must all be satisfied
    thenPaths EscalationPathPathIfElseThenPath[]
    Then path nodes
    elsePaths EscalationPathPathIfElseElsePath[]
    The nodes that form the levels if our condition is not met
    conditions Sequence[EscalationPathPathIfElseCondition]
    The prerequisite conditions that must all be satisfied
    then_paths Sequence[EscalationPathPathIfElseThenPath]
    Then path nodes
    else_paths Sequence[EscalationPathPathIfElseElsePath]
    The nodes that form the levels if our condition is not met
    conditions List<Property Map>
    The prerequisite conditions that must all be satisfied
    thenPaths List<Property Map>
    Then path nodes
    elsePaths List<Property Map>
    The nodes that form the levels if our condition is not met

    EscalationPathPathIfElseCondition, EscalationPathPathIfElseConditionArgs

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

    EscalationPathPathIfElseConditionParamBinding, EscalationPathPathIfElseConditionParamBindingArgs

    ArrayValues List<EscalationPathPathIfElseConditionParamBindingArrayValue>
    The array of literal or reference parameter values
    Value EscalationPathPathIfElseConditionParamBindingValue
    The literal or reference parameter value
    ArrayValues []EscalationPathPathIfElseConditionParamBindingArrayValue
    The array of literal or reference parameter values
    Value EscalationPathPathIfElseConditionParamBindingValue
    The literal or reference parameter value
    arrayValues List<EscalationPathPathIfElseConditionParamBindingArrayValue>
    The array of literal or reference parameter values
    value EscalationPathPathIfElseConditionParamBindingValue
    The literal or reference parameter value
    arrayValues EscalationPathPathIfElseConditionParamBindingArrayValue[]
    The array of literal or reference parameter values
    value EscalationPathPathIfElseConditionParamBindingValue
    The literal or reference parameter value
    array_values Sequence[EscalationPathPathIfElseConditionParamBindingArrayValue]
    The array of literal or reference parameter values
    value EscalationPathPathIfElseConditionParamBindingValue
    The literal or reference parameter value
    arrayValues List<Property Map>
    The array of literal or reference parameter values
    value Property Map
    The literal or reference parameter value

    EscalationPathPathIfElseConditionParamBindingArrayValue, EscalationPathPathIfElseConditionParamBindingArrayValueArgs

    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

    EscalationPathPathIfElseConditionParamBindingValue, EscalationPathPathIfElseConditionParamBindingValueArgs

    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

    EscalationPathPathIfElseElsePath, EscalationPathPathIfElseElsePathArgs

    Type string
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    Delay EscalationPathPathIfElseElsePathDelay
    Id string

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    IfElse EscalationPathPathIfElseElsePathIfElse
    Level EscalationPathPathIfElseElsePathLevel
    NotifyChannel EscalationPathPathIfElseElsePathNotifyChannel
    Repeat EscalationPathPathIfElseElsePathRepeat
    Type string
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    Delay EscalationPathPathIfElseElsePathDelay
    Id string

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    IfElse EscalationPathPathIfElseElsePathIfElse
    Level EscalationPathPathIfElseElsePathLevel
    NotifyChannel EscalationPathPathIfElseElsePathNotifyChannel
    Repeat EscalationPathPathIfElseElsePathRepeat
    type String
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay EscalationPathPathIfElseElsePathDelay
    id String

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    ifElse EscalationPathPathIfElseElsePathIfElse
    level EscalationPathPathIfElseElsePathLevel
    notifyChannel EscalationPathPathIfElseElsePathNotifyChannel
    repeat EscalationPathPathIfElseElsePathRepeat
    type string
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay EscalationPathPathIfElseElsePathDelay
    id string

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    ifElse EscalationPathPathIfElseElsePathIfElse
    level EscalationPathPathIfElseElsePathLevel
    notifyChannel EscalationPathPathIfElseElsePathNotifyChannel
    repeat EscalationPathPathIfElseElsePathRepeat
    type str
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay EscalationPathPathIfElseElsePathDelay
    id str

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    if_else EscalationPathPathIfElseElsePathIfElse
    level EscalationPathPathIfElseElsePathLevel
    notify_channel EscalationPathPathIfElseElsePathNotifyChannel
    repeat EscalationPathPathIfElseElsePathRepeat
    type String
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay Property Map
    id String

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    ifElse Property Map
    level Property Map
    notifyChannel Property Map
    repeat Property Map

    EscalationPathPathIfElseElsePathDelay, EscalationPathPathIfElseElsePathDelayArgs

    DelayIntervalCondition string
    If the delay is relative to a time window, this defines whether we advance when the window is active or inactive
    DelaySeconds double
    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
    DelaySeconds float64
    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
    delaySeconds Double
    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
    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
    delay_seconds float
    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
    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

    EscalationPathPathIfElseElsePathIfElse, EscalationPathPathIfElseElsePathIfElseArgs

    Conditions List<EscalationPathPathIfElseElsePathIfElseCondition>
    The prerequisite conditions that must all be satisfied
    ThenPaths List<EscalationPathPathIfElseElsePathIfElseThenPath>
    Then path nodes
    ElsePaths List<EscalationPathPathIfElseElsePathIfElseElsePath>
    The nodes that form the levels if our condition is not met
    Conditions []EscalationPathPathIfElseElsePathIfElseCondition
    The prerequisite conditions that must all be satisfied
    ThenPaths []EscalationPathPathIfElseElsePathIfElseThenPath
    Then path nodes
    ElsePaths []EscalationPathPathIfElseElsePathIfElseElsePath
    The nodes that form the levels if our condition is not met
    conditions List<EscalationPathPathIfElseElsePathIfElseCondition>
    The prerequisite conditions that must all be satisfied
    thenPaths List<EscalationPathPathIfElseElsePathIfElseThenPath>
    Then path nodes
    elsePaths List<EscalationPathPathIfElseElsePathIfElseElsePath>
    The nodes that form the levels if our condition is not met
    conditions EscalationPathPathIfElseElsePathIfElseCondition[]
    The prerequisite conditions that must all be satisfied
    thenPaths EscalationPathPathIfElseElsePathIfElseThenPath[]
    Then path nodes
    elsePaths EscalationPathPathIfElseElsePathIfElseElsePath[]
    The nodes that form the levels if our condition is not met
    conditions List<Property Map>
    The prerequisite conditions that must all be satisfied
    thenPaths List<Property Map>
    Then path nodes
    elsePaths List<Property Map>
    The nodes that form the levels if our condition is not met

    EscalationPathPathIfElseElsePathIfElseCondition, EscalationPathPathIfElseElsePathIfElseConditionArgs

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

    EscalationPathPathIfElseElsePathIfElseConditionParamBinding, EscalationPathPathIfElseElsePathIfElseConditionParamBindingArgs

    arrayValues List<Property Map>
    The array of literal or reference parameter values
    value Property Map
    The literal or reference parameter value

    EscalationPathPathIfElseElsePathIfElseConditionParamBindingArrayValue, EscalationPathPathIfElseElsePathIfElseConditionParamBindingArrayValueArgs

    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

    EscalationPathPathIfElseElsePathIfElseConditionParamBindingValue, EscalationPathPathIfElseElsePathIfElseConditionParamBindingValueArgs

    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

    EscalationPathPathIfElseElsePathIfElseElsePath, EscalationPathPathIfElseElsePathIfElseElsePathArgs

    Type string
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    Delay EscalationPathPathIfElseElsePathIfElseElsePathDelay
    Id string

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    IfElse EscalationPathPathIfElseElsePathIfElseElsePathIfElse
    Level EscalationPathPathIfElseElsePathIfElseElsePathLevel
    NotifyChannel EscalationPathPathIfElseElsePathIfElseElsePathNotifyChannel
    Repeat EscalationPathPathIfElseElsePathIfElseElsePathRepeat
    Type string
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    Delay EscalationPathPathIfElseElsePathIfElseElsePathDelay
    Id string

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    IfElse EscalationPathPathIfElseElsePathIfElseElsePathIfElse
    Level EscalationPathPathIfElseElsePathIfElseElsePathLevel
    NotifyChannel EscalationPathPathIfElseElsePathIfElseElsePathNotifyChannel
    Repeat EscalationPathPathIfElseElsePathIfElseElsePathRepeat
    type String
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay EscalationPathPathIfElseElsePathIfElseElsePathDelay
    id String

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    ifElse EscalationPathPathIfElseElsePathIfElseElsePathIfElse
    level EscalationPathPathIfElseElsePathIfElseElsePathLevel
    notifyChannel EscalationPathPathIfElseElsePathIfElseElsePathNotifyChannel
    repeat EscalationPathPathIfElseElsePathIfElseElsePathRepeat
    type string
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay EscalationPathPathIfElseElsePathIfElseElsePathDelay
    id string

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    ifElse EscalationPathPathIfElseElsePathIfElseElsePathIfElse
    level EscalationPathPathIfElseElsePathIfElseElsePathLevel
    notifyChannel EscalationPathPathIfElseElsePathIfElseElsePathNotifyChannel
    repeat EscalationPathPathIfElseElsePathIfElseElsePathRepeat
    type str
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay EscalationPathPathIfElseElsePathIfElseElsePathDelay
    id str

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    if_else EscalationPathPathIfElseElsePathIfElseElsePathIfElse
    level EscalationPathPathIfElseElsePathIfElseElsePathLevel
    notify_channel EscalationPathPathIfElseElsePathIfElseElsePathNotifyChannel
    repeat EscalationPathPathIfElseElsePathIfElseElsePathRepeat
    type String
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay Property Map
    id String

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    ifElse Property Map
    level Property Map
    notifyChannel Property Map
    repeat Property Map

    EscalationPathPathIfElseElsePathIfElseElsePathDelay, EscalationPathPathIfElseElsePathIfElseElsePathDelayArgs

    DelayIntervalCondition string
    If the delay is relative to a time window, this defines whether we advance when the window is active or inactive
    DelaySeconds double
    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
    DelaySeconds float64
    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
    delaySeconds Double
    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
    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
    delay_seconds float
    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
    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

    EscalationPathPathIfElseElsePathIfElseElsePathIfElse, EscalationPathPathIfElseElsePathIfElseElsePathIfElseArgs

    conditions List<Property Map>
    The prerequisite conditions that must all be satisfied
    thenPaths List<Property Map>
    Then path nodes
    elsePaths List<Property Map>
    The nodes that form the levels if our condition is not met

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseCondition, EscalationPathPathIfElseElsePathIfElseElsePathIfElseConditionArgs

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

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseConditionParamBinding, EscalationPathPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs

    arrayValues List<Property Map>
    The array of literal or reference parameter values
    value Property Map
    The literal or reference parameter value

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValue, EscalationPathPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs

    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

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValue, EscalationPathPathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs

    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

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePath, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathArgs

    Type string
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    Delay EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathDelay
    Id string

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    IfElse EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElse
    Level EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathLevel
    NotifyChannel EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannel
    Repeat EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathRepeat
    Type string
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    Delay EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathDelay
    Id string

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    IfElse EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElse
    Level EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathLevel
    NotifyChannel EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannel
    Repeat EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathRepeat
    type String
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathDelay
    id String

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    ifElse EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElse
    level EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathLevel
    notifyChannel EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannel
    repeat EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathRepeat
    type string
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathDelay
    id string

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    ifElse EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElse
    level EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathLevel
    notifyChannel EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannel
    repeat EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathRepeat
    type str
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathDelay
    id str

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    if_else EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElse
    level EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathLevel
    notify_channel EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannel
    repeat EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathRepeat
    type String
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay Property Map
    id String

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    ifElse Property Map
    level Property Map
    notifyChannel Property Map
    repeat Property Map

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathDelay, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs

    DelayIntervalCondition string
    If the delay is relative to a time window, this defines whether we advance when the window is active or inactive
    DelaySeconds double
    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
    DelaySeconds float64
    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
    delaySeconds Double
    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
    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
    delay_seconds float
    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
    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

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElse, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseArgs

    conditions List<Property Map>
    The prerequisite conditions that must all be satisfied
    thenPaths List<Property Map>
    Then path nodes
    elsePaths List<Property Map>
    The nodes that form the levels if our condition is not met

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseCondition, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionArgs

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

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBinding, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs

    arrayValues List<Property Map>
    The array of literal or reference parameter values
    value Property Map
    The literal or reference parameter value

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValue, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs

    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

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValue, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs

    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

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePath, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathArgs

    Type string
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    Delay EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathDelay
    Id string

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    IfElse EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElse
    Level EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevel
    NotifyChannel EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannel
    Repeat EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathRepeat
    Type string
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    Delay EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathDelay
    Id string

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    IfElse EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElse
    Level EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevel
    NotifyChannel EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannel
    Repeat EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathRepeat
    type String
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathDelay
    id String

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    ifElse EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElse
    level EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevel
    notifyChannel EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannel
    repeat EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathRepeat
    type string
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathDelay
    id string

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    ifElse EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElse
    level EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevel
    notifyChannel EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannel
    repeat EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathRepeat
    type str
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathDelay
    id str

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    if_else EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElse
    level EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevel
    notify_channel EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannel
    repeat EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathRepeat
    type String
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay Property Map
    id String

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    ifElse Property Map
    level Property Map
    notifyChannel Property Map
    repeat Property Map

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathDelay, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs

    DelayIntervalCondition string
    If the delay is relative to a time window, this defines whether we advance when the window is active or inactive
    DelaySeconds double
    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
    DelaySeconds float64
    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
    delaySeconds Double
    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
    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
    delay_seconds float
    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
    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

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElse, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseArgs

    conditions List<Property Map>
    The prerequisite conditions that must all be satisfied
    thenPaths List<Property Map>
    Then path nodes
    elsePaths List<Property Map>
    The nodes that form the levels if our condition is not met

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseCondition, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionArgs

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

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBinding, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArgs

    arrayValues List<Property Map>
    The array of literal or reference parameter values
    value Property Map
    The literal or reference parameter value

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValue, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingArrayValueArgs

    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

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValue, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseConditionParamBindingValueArgs

    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

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePath, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathArgs

    Type string
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    Delay EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathDelay
    Id string

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    Level EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevel
    NotifyChannel EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannel
    Repeat EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathRepeat
    Type string
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    Delay EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathDelay
    Id string

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    Level EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevel
    NotifyChannel EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannel
    Repeat EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathRepeat
    type String
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathDelay
    id String

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    level EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevel
    notifyChannel EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannel
    repeat EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathRepeat
    type string
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathDelay
    id string

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    level EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevel
    notifyChannel EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannel
    repeat EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathRepeat
    type str
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathDelay
    id str

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    level EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevel
    notify_channel EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannel
    repeat EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathRepeat
    type String
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay Property Map
    id String

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    level Property Map
    notifyChannel Property Map
    repeat Property Map

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathDelay, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathDelayArgs

    DelayIntervalCondition string
    If the delay is relative to a time window, this defines whether we advance when the window is active or inactive
    DelaySeconds double
    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
    DelaySeconds float64
    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
    delaySeconds Double
    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
    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
    delay_seconds float
    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
    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

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevel, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelArgs

    Targets List<EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelTarget>
    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
    RoundRobinConfig EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfig
    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
    TimeToAckSeconds double
    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 []EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelTarget
    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
    RoundRobinConfig EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfig
    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
    TimeToAckSeconds float64
    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<EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelTarget>
    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
    roundRobinConfig EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfig
    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
    timeToAckSeconds Double
    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 EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelTarget[]
    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
    roundRobinConfig EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfig
    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
    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[EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelTarget]
    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
    round_robin_config EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfig
    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
    time_to_ack_seconds float
    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
    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
    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

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfig, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelRoundRobinConfigArgs

    Enabled bool
    Whether round robin is enabled for this level
    RotateAfterSeconds double
    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 float64
    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 Double
    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 float
    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.

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelTarget, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathLevelTargetArgs

    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, slack_channel, msteams_channel.
    Urgency string
    The urgency of this escalation path target. Possible values are: high, low.
    ScheduleMode string
    Only set for schedule targets, and either currently_on_call, all_users or all_users_for_rota and specifies which users to fetch from the schedule
    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, slack_channel, msteams_channel.
    Urgency string
    The urgency of this escalation path target. Possible values are: high, low.
    ScheduleMode string
    Only set for schedule targets, and either currently_on_call, all_users or all_users_for_rota and specifies which users to fetch from the schedule
    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, slack_channel, msteams_channel.
    urgency String
    The urgency of this escalation path target. Possible values are: high, low.
    scheduleMode String
    Only set for schedule targets, and either currently_on_call, all_users or all_users_for_rota and specifies which users to fetch from the schedule
    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, slack_channel, msteams_channel.
    urgency string
    The urgency of this escalation path target. Possible values are: high, low.
    scheduleMode string
    Only set for schedule targets, and either currently_on_call, all_users or all_users_for_rota and specifies which users to fetch from the schedule
    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, slack_channel, msteams_channel.
    urgency str
    The urgency of this escalation path target. Possible values are: high, low.
    schedule_mode str
    Only set for schedule targets, and either currently_on_call, all_users or all_users_for_rota and specifies which users to fetch from the schedule
    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, slack_channel, msteams_channel.
    urgency String
    The urgency of this escalation path target. Possible values are: high, low.
    scheduleMode String
    Only set for schedule targets, and either currently_on_call, all_users or all_users_for_rota and specifies which users to fetch from the schedule

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannel, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelArgs

    Targets List<EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTarget>
    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
    TimeToAckSeconds double
    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 []EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTarget
    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
    TimeToAckSeconds float64
    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<EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTarget>
    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
    timeToAckSeconds Double
    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 EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTarget[]
    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
    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[EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTarget]
    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
    time_to_ack_seconds float
    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
    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

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTarget, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathNotifyChannelTargetArgs

    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, slack_channel, msteams_channel.
    Urgency string
    The urgency of this escalation path target. Possible values are: high, low.
    ScheduleMode string
    Only set for schedule targets, and either currently_on_call, all_users or all_users_for_rota and specifies which users to fetch from the schedule
    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, slack_channel, msteams_channel.
    Urgency string
    The urgency of this escalation path target. Possible values are: high, low.
    ScheduleMode string
    Only set for schedule targets, and either currently_on_call, all_users or all_users_for_rota and specifies which users to fetch from the schedule
    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, slack_channel, msteams_channel.
    urgency String
    The urgency of this escalation path target. Possible values are: high, low.
    scheduleMode String
    Only set for schedule targets, and either currently_on_call, all_users or all_users_for_rota and specifies which users to fetch from the schedule
    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, slack_channel, msteams_channel.
    urgency string
    The urgency of this escalation path target. Possible values are: high, low.
    scheduleMode string
    Only set for schedule targets, and either currently_on_call, all_users or all_users_for_rota and specifies which users to fetch from the schedule
    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, slack_channel, msteams_channel.
    urgency str
    The urgency of this escalation path target. Possible values are: high, low.
    schedule_mode str
    Only set for schedule targets, and either currently_on_call, all_users or all_users_for_rota and specifies which users to fetch from the schedule
    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, slack_channel, msteams_channel.
    urgency String
    The urgency of this escalation path target. Possible values are: high, low.
    scheduleMode String
    Only set for schedule targets, and either currently_on_call, all_users or all_users_for_rota and specifies which users to fetch from the schedule

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathRepeat, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathRepeatArgs

    RepeatTimes double
    How many times to repeat these nodes
    ToNode string
    Which node ID we begin repeating from.
    RepeatTimes float64
    How many times to repeat these nodes
    ToNode string
    Which node ID we begin repeating from.
    repeatTimes Double
    How many times to repeat these nodes
    toNode String
    Which node ID we begin repeating from.
    repeatTimes number
    How many times to repeat these nodes
    toNode string
    Which node ID we begin repeating from.
    repeat_times float
    How many times to repeat these nodes
    to_node str
    Which node ID we begin repeating from.
    repeatTimes Number
    How many times to repeat these nodes
    toNode String
    Which node ID we begin repeating from.

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPath, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathArgs

    Type string
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    Delay EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathDelay
    Id string

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    Level EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevel
    NotifyChannel EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannel
    Repeat EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathRepeat
    Type string
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    Delay EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathDelay
    Id string

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    Level EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevel
    NotifyChannel EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannel
    Repeat EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathRepeat
    type String
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathDelay
    id String

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    level EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevel
    notifyChannel EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannel
    repeat EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathRepeat
    type string
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathDelay
    id string

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    level EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevel
    notifyChannel EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannel
    repeat EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathRepeat
    type str
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathDelay
    id str

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    level EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevel
    notify_channel EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannel
    repeat EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathRepeat
    type String
    The type of this node. Available types are:

    • level: A set of targets (users or schedules) that should be paged, either all at once, or with a round-robin configuration.
    • notify_channel: Send the escalation to a Slack channel, where it can be acked by anyone in the channel.
    • if_else: Branch the escalation based on a set of conditions.
    • repeat: Go back to a previous node and repeat the logic from there.
    • delay: Pause the escalation for a configured duration before advancing to the next node.
    delay Property Map
    id String

    An ID for this node, unique within the escalation path.

    This allows you to reference the node in other nodes, such as when configuring a 'repeat' node.

    level Property Map
    notifyChannel Property Map
    repeat Property Map

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathDelay, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathDelayArgs

    DelayIntervalCondition string
    If the delay is relative to a time window, this defines whether we advance when the window is active or inactive
    DelaySeconds double
    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
    DelaySeconds float64
    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
    delaySeconds Double
    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
    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
    delay_seconds float
    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
    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

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevel, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelArgs

    Targets List<EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelTarget>
    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
    RoundRobinConfig EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfig
    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
    TimeToAckSeconds double
    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 []EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelTarget
    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
    RoundRobinConfig EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfig
    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
    TimeToAckSeconds float64
    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<EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelTarget>
    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
    roundRobinConfig EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfig
    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
    timeToAckSeconds Double
    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 EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelTarget[]
    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
    roundRobinConfig EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfig
    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
    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[EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelTarget]
    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
    round_robin_config EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfig
    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
    time_to_ack_seconds float
    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
    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
    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

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfig, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelRoundRobinConfigArgs

    Enabled bool
    Whether round robin is enabled for this level
    RotateAfterSeconds double
    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 float64
    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 Double
    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 float
    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.

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelTarget, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathLevelTargetArgs

    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, slack_channel, msteams_channel.
    Urgency string
    The urgency of this escalation path target. Possible values are: high, low.
    ScheduleMode string
    Only set for schedule targets, and either currently_on_call, all_users or all_users_for_rota and specifies which users to fetch from the schedule
    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, slack_channel, msteams_channel.
    Urgency string
    The urgency of this escalation path target. Possible values are: high, low.
    ScheduleMode string
    Only set for schedule targets, and either currently_on_call, all_users or all_users_for_rota and specifies which users to fetch from the schedule
    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, slack_channel, msteams_channel.
    urgency String
    The urgency of this escalation path target. Possible values are: high, low.
    scheduleMode String
    Only set for schedule targets, and either currently_on_call, all_users or all_users_for_rota and specifies which users to fetch from the schedule
    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, slack_channel, msteams_channel.
    urgency string
    The urgency of this escalation path target. Possible values are: high, low.
    scheduleMode string
    Only set for schedule targets, and either currently_on_call, all_users or all_users_for_rota and specifies which users to fetch from the schedule
    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, slack_channel, msteams_channel.
    urgency str
    The urgency of this escalation path target. Possible values are: high, low.
    schedule_mode str
    Only set for schedule targets, and either currently_on_call, all_users or all_users_for_rota and specifies which users to fetch from the schedule
    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, slack_channel, msteams_channel.
    urgency String
    The urgency of this escalation path target. Possible values are: high, low.
    scheduleMode String
    Only set for schedule targets, and either currently_on_call, all_users or all_users_for_rota and specifies which users to fetch from the schedule

    EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannel, EscalationPathPathIfElseElsePathIfElseElsePathIfElseElsePathIfElseElsePathIfElseThenPathNotifyChannelArgs