pagerduty.EventOrchestrationGlobal

import * as pulumi from "@pulumi/pulumi";
import * as pagerduty from "@pulumi/pagerduty";

const databaseTeam = new pagerduty.Team("database_team", {name: "Database Team"});
const eventOrchestration = new pagerduty.EventOrchestration("event_orchestration", {
    name: "Example Orchestration",
    team: databaseTeam.id,
});
const p1 = pagerduty.getPriority({
    name: "P1",
});
const sreEscPolicy = pagerduty.getEscalationPolicy({
    name: "SRE Escalation Policy",
});
const global = new pagerduty.EventOrchestrationGlobal("global", {
    eventOrchestration: eventOrchestration.id,
    sets: [
        {
            id: "start",
            rules: [{
                label: "Always annotate a note to all events",
                actions: {
                    annotate: "This incident was created by the Database Team via a Global Orchestration",
                    routeTo: "step-two",
                },
            }],
        },
        {
            id: "step-two",
            rules: [
                {
                    label: "Drop events that are marked as no-op",
                    conditions: [{
                        expression: "event.summary matches 'no-op'",
                    }],
                    actions: {
                        dropEvent: true,
                    },
                },
                {
                    label: "If the DB host is running out of space, then page the SRE team",
                    conditions: [{
                        expression: "event.summary matches part 'running out of space'",
                    }],
                    actions: {
                        escalationPolicy: sreEscPolicy.then(sreEscPolicy => sreEscPolicy.id),
                    },
                },
                {
                    label: "If there's something wrong on the replica, then mark the alert as a warning",
                    conditions: [{
                        expression: "event.custom_details.hostname matches part 'replica'",
                    }],
                    actions: {
                        severity: "warning",
                    },
                },
                {
                    label: "Otherwise, set the incident to P1 and run a diagnostic",
                    actions: {
                        priority: p1.then(p1 => p1.id),
                        automationAction: {
                            name: "db-diagnostic",
                            url: "https://example.com/run-diagnostic",
                            autoSend: true,
                        },
                    },
                },
            ],
        },
    ],
    catchAll: {
        actions: {},
    },
});

import pulumi
import pulumi_pagerduty as pagerduty

database_team = pagerduty.Team("database_team", name="Database Team")
event_orchestration = pagerduty.EventOrchestration("event_orchestration",
    name="Example Orchestration",
    team=database_team.id)
p1 = pagerduty.get_priority(name="P1")
sre_esc_policy = pagerduty.get_escalation_policy(name="SRE Escalation Policy")
global_ = pagerduty.EventOrchestrationGlobal("global",
    event_orchestration=event_orchestration.id,
    sets=[
        {
            "id": "start",
            "rules": [{
                "label": "Always annotate a note to all events",
                "actions": {
                    "annotate": "This incident was created by the Database Team via a Global Orchestration",
                    "route_to": "step-two",
                },
            }],
        },
        {
            "id": "step-two",
            "rules": [
                {
                    "label": "Drop events that are marked as no-op",
                    "conditions": [{
                        "expression": "event.summary matches 'no-op'",
                    }],
                    "actions": {
                        "drop_event": True,
                    },
                },
                {
                    "label": "If the DB host is running out of space, then page the SRE team",
                    "conditions": [{
                        "expression": "event.summary matches part 'running out of space'",
                    }],
                    "actions": {
                        "escalation_policy": sre_esc_policy.id,
                    },
                },
                {
                    "label": "If there's something wrong on the replica, then mark the alert as a warning",
                    "conditions": [{
                        "expression": "event.custom_details.hostname matches part 'replica'",
                    }],
                    "actions": {
                        "severity": "warning",
                    },
                },
                {
                    "label": "Otherwise, set the incident to P1 and run a diagnostic",
                    "actions": {
                        "priority": p1.id,
                        "automation_action": {
                            "name": "db-diagnostic",
                            "url": "https://example.com/run-diagnostic",
                            "auto_send": True,
                        },
                    },
                },
            ],
        },
    ],
    catch_all={
        "actions": {},
    })

package main

import (
	"github.com/pulumi/pulumi-pagerduty/sdk/v4/go/pagerduty"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		databaseTeam, err := pagerduty.NewTeam(ctx, "database_team", &pagerduty.TeamArgs{
			Name: pulumi.String("Database Team"),
		})
		if err != nil {
			return err
		}
		eventOrchestration, err := pagerduty.NewEventOrchestration(ctx, "event_orchestration", &pagerduty.EventOrchestrationArgs{
			Name: pulumi.String("Example Orchestration"),
			Team: databaseTeam.ID(),
		})
		if err != nil {
			return err
		}
		p1, err := pagerduty.GetPriority(ctx, &pagerduty.GetPriorityArgs{
			Name: "P1",
		}, nil)
		if err != nil {
			return err
		}
		sreEscPolicy, err := pagerduty.LookupEscalationPolicy(ctx, &pagerduty.LookupEscalationPolicyArgs{
			Name: "SRE Escalation Policy",
		}, nil)
		if err != nil {
			return err
		}
		_, err = pagerduty.NewEventOrchestrationGlobal(ctx, "global", &pagerduty.EventOrchestrationGlobalArgs{
			EventOrchestration: eventOrchestration.ID(),
			Sets: pagerduty.EventOrchestrationGlobalSetArray{
				&pagerduty.EventOrchestrationGlobalSetArgs{
					Id: pulumi.String("start"),
					Rules: pagerduty.EventOrchestrationGlobalSetRuleArray{
						&pagerduty.EventOrchestrationGlobalSetRuleArgs{
							Label: pulumi.String("Always annotate a note to all events"),
							Actions: &pagerduty.EventOrchestrationGlobalSetRuleActionsArgs{
								Annotate: pulumi.String("This incident was created by the Database Team via a Global Orchestration"),
								RouteTo:  pulumi.String("step-two"),
							},
						},
					},
				},
				&pagerduty.EventOrchestrationGlobalSetArgs{
					Id: pulumi.String("step-two"),
					Rules: pagerduty.EventOrchestrationGlobalSetRuleArray{
						&pagerduty.EventOrchestrationGlobalSetRuleArgs{
							Label: pulumi.String("Drop events that are marked as no-op"),
							Conditions: pagerduty.EventOrchestrationGlobalSetRuleConditionArray{
								&pagerduty.EventOrchestrationGlobalSetRuleConditionArgs{
									Expression: pulumi.String("event.summary matches 'no-op'"),
								},
							},
							Actions: &pagerduty.EventOrchestrationGlobalSetRuleActionsArgs{
								DropEvent: pulumi.Bool(true),
							},
						},
						&pagerduty.EventOrchestrationGlobalSetRuleArgs{
							Label: pulumi.String("If the DB host is running out of space, then page the SRE team"),
							Conditions: pagerduty.EventOrchestrationGlobalSetRuleConditionArray{
								&pagerduty.EventOrchestrationGlobalSetRuleConditionArgs{
									Expression: pulumi.String("event.summary matches part 'running out of space'"),
								},
							},
							Actions: &pagerduty.EventOrchestrationGlobalSetRuleActionsArgs{
								EscalationPolicy: pulumi.String(sreEscPolicy.Id),
							},
						},
						&pagerduty.EventOrchestrationGlobalSetRuleArgs{
							Label: pulumi.String("If there's something wrong on the replica, then mark the alert as a warning"),
							Conditions: pagerduty.EventOrchestrationGlobalSetRuleConditionArray{
								&pagerduty.EventOrchestrationGlobalSetRuleConditionArgs{
									Expression: pulumi.String("event.custom_details.hostname matches part 'replica'"),
								},
							},
							Actions: &pagerduty.EventOrchestrationGlobalSetRuleActionsArgs{
								Severity: pulumi.String("warning"),
							},
						},
						&pagerduty.EventOrchestrationGlobalSetRuleArgs{
							Label: pulumi.String("Otherwise, set the incident to P1 and run a diagnostic"),
							Actions: &pagerduty.EventOrchestrationGlobalSetRuleActionsArgs{
								Priority: pulumi.String(p1.Id),
								AutomationAction: &pagerduty.EventOrchestrationGlobalSetRuleActionsAutomationActionArgs{
									Name:     pulumi.String("db-diagnostic"),
									Url:      pulumi.String("https://example.com/run-diagnostic"),
									AutoSend: pulumi.Bool(true),
								},
							},
						},
					},
				},
			},
			CatchAll: &pagerduty.EventOrchestrationGlobalCatchAllArgs{
				Actions: &pagerduty.EventOrchestrationGlobalCatchAllActionsArgs{},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var databaseTeam = new Pagerduty.Team("database_team", new()
    {
        Name = "Database Team",
    });

    var eventOrchestration = new Pagerduty.EventOrchestration("event_orchestration", new()
    {
        Name = "Example Orchestration",
        Team = databaseTeam.Id,
    });

    var p1 = Pagerduty.GetPriority.Invoke(new()
    {
        Name = "P1",
    });

    var sreEscPolicy = Pagerduty.GetEscalationPolicy.Invoke(new()
    {
        Name = "SRE Escalation Policy",
    });

    var @global = new Pagerduty.EventOrchestrationGlobal("global", new()
    {
        EventOrchestration = eventOrchestration.Id,
        Sets = new[]
        {
            new Pagerduty.Inputs.EventOrchestrationGlobalSetArgs
            {
                Id = "start",
                Rules = new[]
                {
                    new Pagerduty.Inputs.EventOrchestrationGlobalSetRuleArgs
                    {
                        Label = "Always annotate a note to all events",
                        Actions = new Pagerduty.Inputs.EventOrchestrationGlobalSetRuleActionsArgs
                        {
                            Annotate = "This incident was created by the Database Team via a Global Orchestration",
                            RouteTo = "step-two",
                        },
                    },
                },
            },
            new Pagerduty.Inputs.EventOrchestrationGlobalSetArgs
            {
                Id = "step-two",
                Rules = new[]
                {
                    new Pagerduty.Inputs.EventOrchestrationGlobalSetRuleArgs
                    {
                        Label = "Drop events that are marked as no-op",
                        Conditions = new[]
                        {
                            new Pagerduty.Inputs.EventOrchestrationGlobalSetRuleConditionArgs
                            {
                                Expression = "event.summary matches 'no-op'",
                            },
                        },
                        Actions = new Pagerduty.Inputs.EventOrchestrationGlobalSetRuleActionsArgs
                        {
                            DropEvent = true,
                        },
                    },
                    new Pagerduty.Inputs.EventOrchestrationGlobalSetRuleArgs
                    {
                        Label = "If the DB host is running out of space, then page the SRE team",
                        Conditions = new[]
                        {
                            new Pagerduty.Inputs.EventOrchestrationGlobalSetRuleConditionArgs
                            {
                                Expression = "event.summary matches part 'running out of space'",
                            },
                        },
                        Actions = new Pagerduty.Inputs.EventOrchestrationGlobalSetRuleActionsArgs
                        {
                            EscalationPolicy = sreEscPolicy.Apply(getEscalationPolicyResult => getEscalationPolicyResult.Id),
                        },
                    },
                    new Pagerduty.Inputs.EventOrchestrationGlobalSetRuleArgs
                    {
                        Label = "If there's something wrong on the replica, then mark the alert as a warning",
                        Conditions = new[]
                        {
                            new Pagerduty.Inputs.EventOrchestrationGlobalSetRuleConditionArgs
                            {
                                Expression = "event.custom_details.hostname matches part 'replica'",
                            },
                        },
                        Actions = new Pagerduty.Inputs.EventOrchestrationGlobalSetRuleActionsArgs
                        {
                            Severity = "warning",
                        },
                    },
                    new Pagerduty.Inputs.EventOrchestrationGlobalSetRuleArgs
                    {
                        Label = "Otherwise, set the incident to P1 and run a diagnostic",
                        Actions = new Pagerduty.Inputs.EventOrchestrationGlobalSetRuleActionsArgs
                        {
                            Priority = p1.Apply(getPriorityResult => getPriorityResult.Id),
                            AutomationAction = new Pagerduty.Inputs.EventOrchestrationGlobalSetRuleActionsAutomationActionArgs
                            {
                                Name = "db-diagnostic",
                                Url = "https://example.com/run-diagnostic",
                                AutoSend = true,
                            },
                        },
                    },
                },
            },
        },
        CatchAll = new Pagerduty.Inputs.EventOrchestrationGlobalCatchAllArgs
        {
            Actions = null,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.pagerduty.Team;
import com.pulumi.pagerduty.TeamArgs;
import com.pulumi.pagerduty.EventOrchestration;
import com.pulumi.pagerduty.EventOrchestrationArgs;
import com.pulumi.pagerduty.PagerdutyFunctions;
import com.pulumi.pagerduty.inputs.GetPriorityArgs;
import com.pulumi.pagerduty.inputs.GetEscalationPolicyArgs;
import com.pulumi.pagerduty.EventOrchestrationGlobal;
import com.pulumi.pagerduty.EventOrchestrationGlobalArgs;
import com.pulumi.pagerduty.inputs.EventOrchestrationGlobalSetArgs;
import com.pulumi.pagerduty.inputs.EventOrchestrationGlobalCatchAllArgs;
import com.pulumi.pagerduty.inputs.EventOrchestrationGlobalCatchAllActionsArgs;
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) {
        var databaseTeam = new Team("databaseTeam", TeamArgs.builder()
            .name("Database Team")
            .build());

        var eventOrchestration = new EventOrchestration("eventOrchestration", EventOrchestrationArgs.builder()
            .name("Example Orchestration")
            .team(databaseTeam.id())
            .build());

        final var p1 = PagerdutyFunctions.getPriority(GetPriorityArgs.builder()
            .name("P1")
            .build());

        final var sreEscPolicy = PagerdutyFunctions.getEscalationPolicy(GetEscalationPolicyArgs.builder()
            .name("SRE Escalation Policy")
            .build());

        var global = new EventOrchestrationGlobal("global", EventOrchestrationGlobalArgs.builder()
            .eventOrchestration(eventOrchestration.id())
            .sets(            
                EventOrchestrationGlobalSetArgs.builder()
                    .id("start")
                    .rules(EventOrchestrationGlobalSetRuleArgs.builder()
                        .label("Always annotate a note to all events")
                        .actions(EventOrchestrationGlobalSetRuleActionsArgs.builder()
                            .annotate("This incident was created by the Database Team via a Global Orchestration")
                            .routeTo("step-two")
                            .build())
                        .build())
                    .build(),
                EventOrchestrationGlobalSetArgs.builder()
                    .id("step-two")
                    .rules(                    
                        EventOrchestrationGlobalSetRuleArgs.builder()
                            .label("Drop events that are marked as no-op")
                            .conditions(EventOrchestrationGlobalSetRuleConditionArgs.builder()
                                .expression("event.summary matches 'no-op'")
                                .build())
                            .actions(EventOrchestrationGlobalSetRuleActionsArgs.builder()
                                .dropEvent(true)
                                .build())
                            .build(),
                        EventOrchestrationGlobalSetRuleArgs.builder()
                            .label("If the DB host is running out of space, then page the SRE team")
                            .conditions(EventOrchestrationGlobalSetRuleConditionArgs.builder()
                                .expression("event.summary matches part 'running out of space'")
                                .build())
                            .actions(EventOrchestrationGlobalSetRuleActionsArgs.builder()
                                .escalationPolicy(sreEscPolicy.applyValue(getEscalationPolicyResult -> getEscalationPolicyResult.id()))
                                .build())
                            .build(),
                        EventOrchestrationGlobalSetRuleArgs.builder()
                            .label("If there's something wrong on the replica, then mark the alert as a warning")
                            .conditions(EventOrchestrationGlobalSetRuleConditionArgs.builder()
                                .expression("event.custom_details.hostname matches part 'replica'")
                                .build())
                            .actions(EventOrchestrationGlobalSetRuleActionsArgs.builder()
                                .severity("warning")
                                .build())
                            .build(),
                        EventOrchestrationGlobalSetRuleArgs.builder()
                            .label("Otherwise, set the incident to P1 and run a diagnostic")
                            .actions(EventOrchestrationGlobalSetRuleActionsArgs.builder()
                                .priority(p1.applyValue(getPriorityResult -> getPriorityResult.id()))
                                .automationAction(EventOrchestrationGlobalSetRuleActionsAutomationActionArgs.builder()
                                    .name("db-diagnostic")
                                    .url("https://example.com/run-diagnostic")
                                    .autoSend(true)
                                    .build())
                                .build())
                            .build())
                    .build())
            .catchAll(EventOrchestrationGlobalCatchAllArgs.builder()
                .actions()
                .build())
            .build());

    }
}

resources:
  databaseTeam:
    type: pagerduty:Team
    name: database_team
    properties:
      name: Database Team
  eventOrchestration:
    type: pagerduty:EventOrchestration
    name: event_orchestration
    properties:
      name: Example Orchestration
      team: ${databaseTeam.id}
  global:
    type: pagerduty:EventOrchestrationGlobal
    properties:
      eventOrchestration: ${eventOrchestration.id}
      sets:
        - id: start
          rules:
            - label: Always annotate a note to all events
              actions:
                annotate: This incident was created by the Database Team via a Global Orchestration
                routeTo: step-two
        - id: step-two
          rules:
            - label: Drop events that are marked as no-op
              conditions:
                - expression: event.summary matches 'no-op'
              actions:
                dropEvent: true
            - label: If the DB host is running out of space, then page the SRE team
              conditions:
                - expression: event.summary matches part 'running out of space'
              actions:
                escalationPolicy: ${sreEscPolicy.id}
            - label: If there's something wrong on the replica, then mark the alert as a warning
              conditions:
                - expression: event.custom_details.hostname matches part 'replica'
              actions:
                severity: warning
            - label: Otherwise, set the incident to P1 and run a diagnostic
              actions:
                priority: ${p1.id}
                automationAction:
                  name: db-diagnostic
                  url: https://example.com/run-diagnostic
                  autoSend: true
      catchAll:
        actions: {}
variables:
  p1:
    fn::invoke:
      Function: pagerduty:getPriority
      Arguments:
        name: P1
  sreEscPolicy:
    fn::invoke:
      Function: pagerduty:getEscalationPolicy
      Arguments:
        name: SRE Escalation Policy

var eventOrchestrationGlobalResource = new Pagerduty.EventOrchestrationGlobal("eventOrchestrationGlobalResource", new()
{
    CatchAll = new Pagerduty.Inputs.EventOrchestrationGlobalCatchAllArgs
    {
        Actions = new Pagerduty.Inputs.EventOrchestrationGlobalCatchAllActionsArgs
        {
            Annotate = "string",
            AutomationAction = new Pagerduty.Inputs.EventOrchestrationGlobalCatchAllActionsAutomationActionArgs
            {
                Name = "string",
                Url = "string",
                AutoSend = false,
                Headers = new[]
                {
                    new Pagerduty.Inputs.EventOrchestrationGlobalCatchAllActionsAutomationActionHeaderArgs
                    {
                        Key = "string",
                        Value = "string",
                    },
                },
                Parameters = new[]
                {
                    new Pagerduty.Inputs.EventOrchestrationGlobalCatchAllActionsAutomationActionParameterArgs
                    {
                        Key = "string",
                        Value = "string",
                    },
                },
            },
            DropEvent = false,
            EscalationPolicy = "string",
            EventAction = "string",
            Extractions = new[]
            {
                new Pagerduty.Inputs.EventOrchestrationGlobalCatchAllActionsExtractionArgs
                {
                    Target = "string",
                    Regex = "string",
                    Source = "string",
                    Template = "string",
                },
            },
            IncidentCustomFieldUpdates = new[]
            {
                new Pagerduty.Inputs.EventOrchestrationGlobalCatchAllActionsIncidentCustomFieldUpdateArgs
                {
                    Id = "string",
                    Value = "string",
                },
            },
            Priority = "string",
            RouteTo = "string",
            Severity = "string",
            Suppress = false,
            Suspend = 0,
            Variables = new[]
            {
                new Pagerduty.Inputs.EventOrchestrationGlobalCatchAllActionsVariableArgs
                {
                    Name = "string",
                    Path = "string",
                    Type = "string",
                    Value = "string",
                },
            },
        },
    },
    EventOrchestration = "string",
    Sets = new[]
    {
        new Pagerduty.Inputs.EventOrchestrationGlobalSetArgs
        {
            Id = "string",
            Rules = new[]
            {
                new Pagerduty.Inputs.EventOrchestrationGlobalSetRuleArgs
                {
                    Actions = new Pagerduty.Inputs.EventOrchestrationGlobalSetRuleActionsArgs
                    {
                        Annotate = "string",
                        AutomationAction = new Pagerduty.Inputs.EventOrchestrationGlobalSetRuleActionsAutomationActionArgs
                        {
                            Name = "string",
                            Url = "string",
                            AutoSend = false,
                            Headers = new[]
                            {
                                new Pagerduty.Inputs.EventOrchestrationGlobalSetRuleActionsAutomationActionHeaderArgs
                                {
                                    Key = "string",
                                    Value = "string",
                                },
                            },
                            Parameters = new[]
                            {
                                new Pagerduty.Inputs.EventOrchestrationGlobalSetRuleActionsAutomationActionParameterArgs
                                {
                                    Key = "string",
                                    Value = "string",
                                },
                            },
                        },
                        DropEvent = false,
                        EscalationPolicy = "string",
                        EventAction = "string",
                        Extractions = new[]
                        {
                            new Pagerduty.Inputs.EventOrchestrationGlobalSetRuleActionsExtractionArgs
                            {
                                Target = "string",
                                Regex = "string",
                                Source = "string",
                                Template = "string",
                            },
                        },
                        IncidentCustomFieldUpdates = new[]
                        {
                            new Pagerduty.Inputs.EventOrchestrationGlobalSetRuleActionsIncidentCustomFieldUpdateArgs
                            {
                                Id = "string",
                                Value = "string",
                            },
                        },
                        Priority = "string",
                        RouteTo = "string",
                        Severity = "string",
                        Suppress = false,
                        Suspend = 0,
                        Variables = new[]
                        {
                            new Pagerduty.Inputs.EventOrchestrationGlobalSetRuleActionsVariableArgs
                            {
                                Name = "string",
                                Path = "string",
                                Type = "string",
                                Value = "string",
                            },
                        },
                    },
                    Conditions = new[]
                    {
                        new Pagerduty.Inputs.EventOrchestrationGlobalSetRuleConditionArgs
                        {
                            Expression = "string",
                        },
                    },
                    Disabled = false,
                    Id = "string",
                    Label = "string",
                },
            },
        },
    },
});

example, err := pagerduty.NewEventOrchestrationGlobal(ctx, "eventOrchestrationGlobalResource", &pagerduty.EventOrchestrationGlobalArgs{
	CatchAll: &pagerduty.EventOrchestrationGlobalCatchAllArgs{
		Actions: &pagerduty.EventOrchestrationGlobalCatchAllActionsArgs{
			Annotate: pulumi.String("string"),
			AutomationAction: &pagerduty.EventOrchestrationGlobalCatchAllActionsAutomationActionArgs{
				Name:     pulumi.String("string"),
				Url:      pulumi.String("string"),
				AutoSend: pulumi.Bool(false),
				Headers: pagerduty.EventOrchestrationGlobalCatchAllActionsAutomationActionHeaderArray{
					&pagerduty.EventOrchestrationGlobalCatchAllActionsAutomationActionHeaderArgs{
						Key:   pulumi.String("string"),
						Value: pulumi.String("string"),
					},
				},
				Parameters: pagerduty.EventOrchestrationGlobalCatchAllActionsAutomationActionParameterArray{
					&pagerduty.EventOrchestrationGlobalCatchAllActionsAutomationActionParameterArgs{
						Key:   pulumi.String("string"),
						Value: pulumi.String("string"),
					},
				},
			},
			DropEvent:        pulumi.Bool(false),
			EscalationPolicy: pulumi.String("string"),
			EventAction:      pulumi.String("string"),
			Extractions: pagerduty.EventOrchestrationGlobalCatchAllActionsExtractionArray{
				&pagerduty.EventOrchestrationGlobalCatchAllActionsExtractionArgs{
					Target:   pulumi.String("string"),
					Regex:    pulumi.String("string"),
					Source:   pulumi.String("string"),
					Template: pulumi.String("string"),
				},
			},
			IncidentCustomFieldUpdates: pagerduty.EventOrchestrationGlobalCatchAllActionsIncidentCustomFieldUpdateArray{
				&pagerduty.EventOrchestrationGlobalCatchAllActionsIncidentCustomFieldUpdateArgs{
					Id:    pulumi.String("string"),
					Value: pulumi.String("string"),
				},
			},
			Priority: pulumi.String("string"),
			RouteTo:  pulumi.String("string"),
			Severity: pulumi.String("string"),
			Suppress: pulumi.Bool(false),
			Suspend:  pulumi.Int(0),
			Variables: pagerduty.EventOrchestrationGlobalCatchAllActionsVariableArray{
				&pagerduty.EventOrchestrationGlobalCatchAllActionsVariableArgs{
					Name:  pulumi.String("string"),
					Path:  pulumi.String("string"),
					Type:  pulumi.String("string"),
					Value: pulumi.String("string"),
				},
			},
		},
	},
	EventOrchestration: pulumi.String("string"),
	Sets: pagerduty.EventOrchestrationGlobalSetArray{
		&pagerduty.EventOrchestrationGlobalSetArgs{
			Id: pulumi.String("string"),
			Rules: pagerduty.EventOrchestrationGlobalSetRuleArray{
				&pagerduty.EventOrchestrationGlobalSetRuleArgs{
					Actions: &pagerduty.EventOrchestrationGlobalSetRuleActionsArgs{
						Annotate: pulumi.String("string"),
						AutomationAction: &pagerduty.EventOrchestrationGlobalSetRuleActionsAutomationActionArgs{
							Name:     pulumi.String("string"),
							Url:      pulumi.String("string"),
							AutoSend: pulumi.Bool(false),
							Headers: pagerduty.EventOrchestrationGlobalSetRuleActionsAutomationActionHeaderArray{
								&pagerduty.EventOrchestrationGlobalSetRuleActionsAutomationActionHeaderArgs{
									Key:   pulumi.String("string"),
									Value: pulumi.String("string"),
								},
							},
							Parameters: pagerduty.EventOrchestrationGlobalSetRuleActionsAutomationActionParameterArray{
								&pagerduty.EventOrchestrationGlobalSetRuleActionsAutomationActionParameterArgs{
									Key:   pulumi.String("string"),
									Value: pulumi.String("string"),
								},
							},
						},
						DropEvent:        pulumi.Bool(false),
						EscalationPolicy: pulumi.String("string"),
						EventAction:      pulumi.String("string"),
						Extractions: pagerduty.EventOrchestrationGlobalSetRuleActionsExtractionArray{
							&pagerduty.EventOrchestrationGlobalSetRuleActionsExtractionArgs{
								Target:   pulumi.String("string"),
								Regex:    pulumi.String("string"),
								Source:   pulumi.String("string"),
								Template: pulumi.String("string"),
							},
						},
						IncidentCustomFieldUpdates: pagerduty.EventOrchestrationGlobalSetRuleActionsIncidentCustomFieldUpdateArray{
							&pagerduty.EventOrchestrationGlobalSetRuleActionsIncidentCustomFieldUpdateArgs{
								Id:    pulumi.String("string"),
								Value: pulumi.String("string"),
							},
						},
						Priority: pulumi.String("string"),
						RouteTo:  pulumi.String("string"),
						Severity: pulumi.String("string"),
						Suppress: pulumi.Bool(false),
						Suspend:  pulumi.Int(0),
						Variables: pagerduty.EventOrchestrationGlobalSetRuleActionsVariableArray{
							&pagerduty.EventOrchestrationGlobalSetRuleActionsVariableArgs{
								Name:  pulumi.String("string"),
								Path:  pulumi.String("string"),
								Type:  pulumi.String("string"),
								Value: pulumi.String("string"),
							},
						},
					},
					Conditions: pagerduty.EventOrchestrationGlobalSetRuleConditionArray{
						&pagerduty.EventOrchestrationGlobalSetRuleConditionArgs{
							Expression: pulumi.String("string"),
						},
					},
					Disabled: pulumi.Bool(false),
					Id:       pulumi.String("string"),
					Label:    pulumi.String("string"),
				},
			},
		},
	},
})

var eventOrchestrationGlobalResource = new EventOrchestrationGlobal("eventOrchestrationGlobalResource", EventOrchestrationGlobalArgs.builder()
    .catchAll(EventOrchestrationGlobalCatchAllArgs.builder()
        .actions(EventOrchestrationGlobalCatchAllActionsArgs.builder()
            .annotate("string")
            .automationAction(EventOrchestrationGlobalCatchAllActionsAutomationActionArgs.builder()
                .name("string")
                .url("string")
                .autoSend(false)
                .headers(EventOrchestrationGlobalCatchAllActionsAutomationActionHeaderArgs.builder()
                    .key("string")
                    .value("string")
                    .build())
                .parameters(EventOrchestrationGlobalCatchAllActionsAutomationActionParameterArgs.builder()
                    .key("string")
                    .value("string")
                    .build())
                .build())
            .dropEvent(false)
            .escalationPolicy("string")
            .eventAction("string")
            .extractions(EventOrchestrationGlobalCatchAllActionsExtractionArgs.builder()
                .target("string")
                .regex("string")
                .source("string")
                .template("string")
                .build())
            .incidentCustomFieldUpdates(EventOrchestrationGlobalCatchAllActionsIncidentCustomFieldUpdateArgs.builder()
                .id("string")
                .value("string")
                .build())
            .priority("string")
            .routeTo("string")
            .severity("string")
            .suppress(false)
            .suspend(0)
            .variables(EventOrchestrationGlobalCatchAllActionsVariableArgs.builder()
                .name("string")
                .path("string")
                .type("string")
                .value("string")
                .build())
            .build())
        .build())
    .eventOrchestration("string")
    .sets(EventOrchestrationGlobalSetArgs.builder()
        .id("string")
        .rules(EventOrchestrationGlobalSetRuleArgs.builder()
            .actions(EventOrchestrationGlobalSetRuleActionsArgs.builder()
                .annotate("string")
                .automationAction(EventOrchestrationGlobalSetRuleActionsAutomationActionArgs.builder()
                    .name("string")
                    .url("string")
                    .autoSend(false)
                    .headers(EventOrchestrationGlobalSetRuleActionsAutomationActionHeaderArgs.builder()
                        .key("string")
                        .value("string")
                        .build())
                    .parameters(EventOrchestrationGlobalSetRuleActionsAutomationActionParameterArgs.builder()
                        .key("string")
                        .value("string")
                        .build())
                    .build())
                .dropEvent(false)
                .escalationPolicy("string")
                .eventAction("string")
                .extractions(EventOrchestrationGlobalSetRuleActionsExtractionArgs.builder()
                    .target("string")
                    .regex("string")
                    .source("string")
                    .template("string")
                    .build())
                .incidentCustomFieldUpdates(EventOrchestrationGlobalSetRuleActionsIncidentCustomFieldUpdateArgs.builder()
                    .id("string")
                    .value("string")
                    .build())
                .priority("string")
                .routeTo("string")
                .severity("string")
                .suppress(false)
                .suspend(0)
                .variables(EventOrchestrationGlobalSetRuleActionsVariableArgs.builder()
                    .name("string")
                    .path("string")
                    .type("string")
                    .value("string")
                    .build())
                .build())
            .conditions(EventOrchestrationGlobalSetRuleConditionArgs.builder()
                .expression("string")
                .build())
            .disabled(false)
            .id("string")
            .label("string")
            .build())
        .build())
    .build());

event_orchestration_global_resource = pagerduty.EventOrchestrationGlobal("eventOrchestrationGlobalResource",
    catch_all={
        "actions": {
            "annotate": "string",
            "automation_action": {
                "name": "string",
                "url": "string",
                "auto_send": False,
                "headers": [{
                    "key": "string",
                    "value": "string",
                }],
                "parameters": [{
                    "key": "string",
                    "value": "string",
                }],
            },
            "drop_event": False,
            "escalation_policy": "string",
            "event_action": "string",
            "extractions": [{
                "target": "string",
                "regex": "string",
                "source": "string",
                "template": "string",
            }],
            "incident_custom_field_updates": [{
                "id": "string",
                "value": "string",
            }],
            "priority": "string",
            "route_to": "string",
            "severity": "string",
            "suppress": False,
            "suspend": 0,
            "variables": [{
                "name": "string",
                "path": "string",
                "type": "string",
                "value": "string",
            }],
        },
    },
    event_orchestration="string",
    sets=[{
        "id": "string",
        "rules": [{
            "actions": {
                "annotate": "string",
                "automation_action": {
                    "name": "string",
                    "url": "string",
                    "auto_send": False,
                    "headers": [{
                        "key": "string",
                        "value": "string",
                    }],
                    "parameters": [{
                        "key": "string",
                        "value": "string",
                    }],
                },
                "drop_event": False,
                "escalation_policy": "string",
                "event_action": "string",
                "extractions": [{
                    "target": "string",
                    "regex": "string",
                    "source": "string",
                    "template": "string",
                }],
                "incident_custom_field_updates": [{
                    "id": "string",
                    "value": "string",
                }],
                "priority": "string",
                "route_to": "string",
                "severity": "string",
                "suppress": False,
                "suspend": 0,
                "variables": [{
                    "name": "string",
                    "path": "string",
                    "type": "string",
                    "value": "string",
                }],
            },
            "conditions": [{
                "expression": "string",
            }],
            "disabled": False,
            "id": "string",
            "label": "string",
        }],
    }])

const eventOrchestrationGlobalResource = new pagerduty.EventOrchestrationGlobal("eventOrchestrationGlobalResource", {
    catchAll: {
        actions: {
            annotate: "string",
            automationAction: {
                name: "string",
                url: "string",
                autoSend: false,
                headers: [{
                    key: "string",
                    value: "string",
                }],
                parameters: [{
                    key: "string",
                    value: "string",
                }],
            },
            dropEvent: false,
            escalationPolicy: "string",
            eventAction: "string",
            extractions: [{
                target: "string",
                regex: "string",
                source: "string",
                template: "string",
            }],
            incidentCustomFieldUpdates: [{
                id: "string",
                value: "string",
            }],
            priority: "string",
            routeTo: "string",
            severity: "string",
            suppress: false,
            suspend: 0,
            variables: [{
                name: "string",
                path: "string",
                type: "string",
                value: "string",
            }],
        },
    },
    eventOrchestration: "string",
    sets: [{
        id: "string",
        rules: [{
            actions: {
                annotate: "string",
                automationAction: {
                    name: "string",
                    url: "string",
                    autoSend: false,
                    headers: [{
                        key: "string",
                        value: "string",
                    }],
                    parameters: [{
                        key: "string",
                        value: "string",
                    }],
                },
                dropEvent: false,
                escalationPolicy: "string",
                eventAction: "string",
                extractions: [{
                    target: "string",
                    regex: "string",
                    source: "string",
                    template: "string",
                }],
                incidentCustomFieldUpdates: [{
                    id: "string",
                    value: "string",
                }],
                priority: "string",
                routeTo: "string",
                severity: "string",
                suppress: false,
                suspend: 0,
                variables: [{
                    name: "string",
                    path: "string",
                    type: "string",
                    value: "string",
                }],
            },
            conditions: [{
                expression: "string",
            }],
            disabled: false,
            id: "string",
            label: "string",
        }],
    }],
});

type: pagerduty:EventOrchestrationGlobal
properties:
    catchAll:
        actions:
            annotate: string
            automationAction:
                autoSend: false
                headers:
                    - key: string
                      value: string
                name: string
                parameters:
                    - key: string
                      value: string
                url: string
            dropEvent: false
            escalationPolicy: string
            eventAction: string
            extractions:
                - regex: string
                  source: string
                  target: string
                  template: string
            incidentCustomFieldUpdates:
                - id: string
                  value: string
            priority: string
            routeTo: string
            severity: string
            suppress: false
            suspend: 0
            variables:
                - name: string
                  path: string
                  type: string
                  value: string
    eventOrchestration: string
    sets:
        - id: string
          rules:
            - actions:
                annotate: string
                automationAction:
                    autoSend: false
                    headers:
                        - key: string
                          value: string
                    name: string
                    parameters:
                        - key: string
                          value: string
                    url: string
                dropEvent: false
                escalationPolicy: string
                eventAction: string
                extractions:
                    - regex: string
                      source: string
                      target: string
                      template: string
                incidentCustomFieldUpdates:
                    - id: string
                      value: string
                priority: string
                routeTo: string
                severity: string
                suppress: false
                suspend: 0
                variables:
                    - name: string
                      path: string
                      type: string
                      value: string
              conditions:
                - expression: string
              disabled: false
              id: string
              label: string