incident.AlertSource

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
import * as incident from "@pulumi/incident";

//# Create a basic Alert Source that recieves from an SNS Topic in AWS
const cloudwatch = new incident.AlertSource("cloudwatch", {
    sourceType: "cloudwatch",
    template: {
        title: {
            literal: JSON.stringify({
                content: [{
                    content: [{
                        attrs: {
                            label: "Payload → Title",
                            missing: false,
                            name: "title",
                        },
                        type: "varSpec",
                    }],
                    type: "paragraph",
                }],
                type: "doc",
            }),
        },
        description: {
            literal: JSON.stringify({
                content: [{
                    content: [{
                        attrs: {
                            label: "Payload → Description",
                            missing: false,
                            name: "description",
                        },
                        type: "varSpec",
                    }],
                    type: "paragraph",
                }],
                type: "doc",
            }),
        },
        attributes: [{
            alertAttributeId: data.incident_alert_attribute.team.id,
            binding: {
                value: {
                    reference: "expressions[\"cloudwatch-team\"]",
                },
            },
        }],
        expressions: [{
            label: "Team",
            operations: [{
                operationType: "parse",
                parse: {
                    returns: {
                        array: false,
                        type: "CatalogEntry[\"CatalogEntryID\"]",
                    },
                    source: "$['query_params']['team']",
                },
            }],
            reference: "cloudwatch-team",
            rootReference: "payload",
        }],
    },
});
//# The `team` Alert Attribute we've configured to label Alerts and route alerts to schedules
const squad = incident.getAlertAttribute({
    name: "Team",
});
const alerts = new aws.index.Aws_sns_topic("alerts", {name: "cloudwatch-alerts"});
//# SNS Topic Subscription that routes to the incident.io Alert Source created above
const incidentioAlertSource = new aws.index.Aws_sns_topic_subscription("incidentioAlertSource", {
    endpoint: `https://api.incident.io/v2/alert_events/cloudwatch/${cloudwatch.id}?team=platform`,
    endpointAutoConfirms: true,
    protocol: "https",
    topicArn: alerts.arn,
});

import pulumi
import json
import pulumi_aws as aws
import pulumi_incident as incident

## Create a basic Alert Source that recieves from an SNS Topic in AWS
cloudwatch = incident.AlertSource("cloudwatch",
    source_type="cloudwatch",
    template={
        "title": {
            "literal": json.dumps({
                "content": [{
                    "content": [{
                        "attrs": {
                            "label": "Payload → Title",
                            "missing": False,
                            "name": "title",
                        },
                        "type": "varSpec",
                    }],
                    "type": "paragraph",
                }],
                "type": "doc",
            }),
        },
        "description": {
            "literal": json.dumps({
                "content": [{
                    "content": [{
                        "attrs": {
                            "label": "Payload → Description",
                            "missing": False,
                            "name": "description",
                        },
                        "type": "varSpec",
                    }],
                    "type": "paragraph",
                }],
                "type": "doc",
            }),
        },
        "attributes": [{
            "alert_attribute_id": data["incident_alert_attribute"]["team"]["id"],
            "binding": {
                "value": {
                    "reference": "expressions[\"cloudwatch-team\"]",
                },
            },
        }],
        "expressions": [{
            "label": "Team",
            "operations": [{
                "operation_type": "parse",
                "parse": {
                    "returns": {
                        "array": False,
                        "type": "CatalogEntry[\"CatalogEntryID\"]",
                    },
                    "source": "$['query_params']['team']",
                },
            }],
            "reference": "cloudwatch-team",
            "root_reference": "payload",
        }],
    })
## The `team` Alert Attribute we've configured to label Alerts and route alerts to schedules
squad = incident.get_alert_attribute(name="Team")
alerts = aws.index.Aws_sns_topic("alerts", name=cloudwatch-alerts)
## SNS Topic Subscription that routes to the incident.io Alert Source created above
incidentio_alert_source = aws.index.Aws_sns_topic_subscription("incidentioAlertSource",
    endpoint=fhttps://api.incident.io/v2/alert_events/cloudwatch/{cloudwatch.id}?team=platform,
    endpoint_auto_confirms=True,
    protocol=https,
    topic_arn=alerts.arn)

package main

import (
	"encoding/json"
	"fmt"

	"github.com/pulumi/pulumi-aws/sdk/go/aws"
	"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 {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"content": []map[string]interface{}{
				map[string]interface{}{
					"content": []map[string]interface{}{
						map[string]interface{}{
							"attrs": map[string]interface{}{
								"label":   "Payload → Title",
								"missing": false,
								"name":    "title",
							},
							"type": "varSpec",
						},
					},
					"type": "paragraph",
				},
			},
			"type": "doc",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		tmpJSON1, err := json.Marshal(map[string]interface{}{
			"content": []map[string]interface{}{
				map[string]interface{}{
					"content": []map[string]interface{}{
						map[string]interface{}{
							"attrs": map[string]interface{}{
								"label":   "Payload → Description",
								"missing": false,
								"name":    "description",
							},
							"type": "varSpec",
						},
					},
					"type": "paragraph",
				},
			},
			"type": "doc",
		})
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		// # Create a basic Alert Source that recieves from an SNS Topic in AWS
		cloudwatch, err := incident.NewAlertSource(ctx, "cloudwatch", &incident.AlertSourceArgs{
			SourceType: pulumi.String("cloudwatch"),
			Template: &incident.AlertSourceTemplateArgs{
				Title: &incident.AlertSourceTemplateTitleArgs{
					Literal: pulumi.String(json0),
				},
				Description: &incident.AlertSourceTemplateDescriptionArgs{
					Literal: pulumi.String(json1),
				},
				Attributes: incident.AlertSourceTemplateAttributeArray{
					&incident.AlertSourceTemplateAttributeArgs{
						AlertAttributeId: pulumi.Any(data.Incident_alert_attribute.Team.Id),
						Binding: &incident.AlertSourceTemplateAttributeBindingArgs{
							Value: &incident.AlertSourceTemplateAttributeBindingValueArgs{
								Reference: pulumi.String("expressions[\"cloudwatch-team\"]"),
							},
						},
					},
				},
				Expressions: incident.AlertSourceTemplateExpressionArray{
					&incident.AlertSourceTemplateExpressionArgs{
						Label: pulumi.String("Team"),
						Operations: incident.AlertSourceTemplateExpressionOperationArray{
							&incident.AlertSourceTemplateExpressionOperationArgs{
								OperationType: pulumi.String("parse"),
								Parse: &incident.AlertSourceTemplateExpressionOperationParseArgs{
									Returns: &incident.AlertSourceTemplateExpressionOperationParseReturnsArgs{
										Array: pulumi.Bool(false),
										Type:  pulumi.String("CatalogEntry[\"CatalogEntryID\"]"),
									},
									Source: pulumi.String("$['query_params']['team']"),
								},
							},
						},
						Reference:     pulumi.String("cloudwatch-team"),
						RootReference: pulumi.String("payload"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = incident.LookupAlertAttribute(ctx, &incident.LookupAlertAttributeArgs{
			Name: "Team",
		}, nil)
		if err != nil {
			return err
		}
		alerts, err := aws.NewAws_sns_topic(ctx, "alerts", &aws.Aws_sns_topicArgs{
			Name: "cloudwatch-alerts",
		})
		if err != nil {
			return err
		}
		_, err = aws.NewAws_sns_topic_subscription(ctx, "incidentioAlertSource", &aws.Aws_sns_topic_subscriptionArgs{
			Endpoint:             pulumi.Sprintf("https://api.incident.io/v2/alert_events/cloudwatch/%v?team=platform", cloudwatch.ID()),
			EndpointAutoConfirms: true,
			Protocol:             "https",
			TopicArn:             alerts.Arn,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Aws = Pulumi.Aws;
using Incident = Pulumi.Incident;

return await Deployment.RunAsync(() => 
{
    //# Create a basic Alert Source that recieves from an SNS Topic in AWS
    var cloudwatch = new Incident.AlertSource("cloudwatch", new()
    {
        SourceType = "cloudwatch",
        Template = new Incident.Inputs.AlertSourceTemplateArgs
        {
            Title = new Incident.Inputs.AlertSourceTemplateTitleArgs
            {
                Literal = JsonSerializer.Serialize(new Dictionary<string, object?>
                {
                    ["content"] = new[]
                    {
                        new Dictionary<string, object?>
                        {
                            ["content"] = new[]
                            {
                                new Dictionary<string, object?>
                                {
                                    ["attrs"] = new Dictionary<string, object?>
                                    {
                                        ["label"] = "Payload → Title",
                                        ["missing"] = false,
                                        ["name"] = "title",
                                    },
                                    ["type"] = "varSpec",
                                },
                            },
                            ["type"] = "paragraph",
                        },
                    },
                    ["type"] = "doc",
                }),
            },
            Description = new Incident.Inputs.AlertSourceTemplateDescriptionArgs
            {
                Literal = JsonSerializer.Serialize(new Dictionary<string, object?>
                {
                    ["content"] = new[]
                    {
                        new Dictionary<string, object?>
                        {
                            ["content"] = new[]
                            {
                                new Dictionary<string, object?>
                                {
                                    ["attrs"] = new Dictionary<string, object?>
                                    {
                                        ["label"] = "Payload → Description",
                                        ["missing"] = false,
                                        ["name"] = "description",
                                    },
                                    ["type"] = "varSpec",
                                },
                            },
                            ["type"] = "paragraph",
                        },
                    },
                    ["type"] = "doc",
                }),
            },
            Attributes = new[]
            {
                new Incident.Inputs.AlertSourceTemplateAttributeArgs
                {
                    AlertAttributeId = data.Incident_alert_attribute.Team.Id,
                    Binding = new Incident.Inputs.AlertSourceTemplateAttributeBindingArgs
                    {
                        Value = new Incident.Inputs.AlertSourceTemplateAttributeBindingValueArgs
                        {
                            Reference = "expressions[\"cloudwatch-team\"]",
                        },
                    },
                },
            },
            Expressions = new[]
            {
                new Incident.Inputs.AlertSourceTemplateExpressionArgs
                {
                    Label = "Team",
                    Operations = new[]
                    {
                        new Incident.Inputs.AlertSourceTemplateExpressionOperationArgs
                        {
                            OperationType = "parse",
                            Parse = new Incident.Inputs.AlertSourceTemplateExpressionOperationParseArgs
                            {
                                Returns = new Incident.Inputs.AlertSourceTemplateExpressionOperationParseReturnsArgs
                                {
                                    Array = false,
                                    Type = "CatalogEntry[\"CatalogEntryID\"]",
                                },
                                Source = "$['query_params']['team']",
                            },
                        },
                    },
                    Reference = "cloudwatch-team",
                    RootReference = "payload",
                },
            },
        },
    });

    //# The `team` Alert Attribute we've configured to label Alerts and route alerts to schedules
    var squad = Incident.GetAlertAttribute.Invoke(new()
    {
        Name = "Team",
    });

    var alerts = new Aws.Index.Aws_sns_topic("alerts", new()
    {
        Name = "cloudwatch-alerts",
    });

    //# SNS Topic Subscription that routes to the incident.io Alert Source created above
    var incidentioAlertSource = new Aws.Index.Aws_sns_topic_subscription("incidentioAlertSource", new()
    {
        Endpoint = $"https://api.incident.io/v2/alert_events/cloudwatch/{cloudwatch.Id}?team=platform",
        EndpointAutoConfirms = true,
        Protocol = "https",
        TopicArn = alerts.Arn,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.incident.AlertSource;
import com.pulumi.incident.AlertSourceArgs;
import com.pulumi.incident.inputs.AlertSourceTemplateArgs;
import com.pulumi.incident.inputs.AlertSourceTemplateTitleArgs;
import com.pulumi.incident.inputs.AlertSourceTemplateDescriptionArgs;
import com.pulumi.incident.IncidentFunctions;
import com.pulumi.incident.inputs.GetAlertAttributeArgs;
import com.pulumi.aws.aws_sns_topic;
import com.pulumi.aws.Aws_sns_topicArgs;
import com.pulumi.aws.aws_sns_topic_subscription;
import com.pulumi.aws.Aws_sns_topic_subscriptionArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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) {
        //# Create a basic Alert Source that recieves from an SNS Topic in AWS
        var cloudwatch = new AlertSource("cloudwatch", AlertSourceArgs.builder()
            .sourceType("cloudwatch")
            .template(AlertSourceTemplateArgs.builder()
                .title(AlertSourceTemplateTitleArgs.builder()
                    .literal(serializeJson(
                        jsonObject(
                            jsonProperty("content", jsonArray(jsonObject(
                                jsonProperty("content", jsonArray(jsonObject(
                                    jsonProperty("attrs", jsonObject(
                                        jsonProperty("label", "Payload → Title"),
                                        jsonProperty("missing", false),
                                        jsonProperty("name", "title")
                                    )),
                                    jsonProperty("type", "varSpec")
                                ))),
                                jsonProperty("type", "paragraph")
                            ))),
                            jsonProperty("type", "doc")
                        )))
                    .build())
                .description(AlertSourceTemplateDescriptionArgs.builder()
                    .literal(serializeJson(
                        jsonObject(
                            jsonProperty("content", jsonArray(jsonObject(
                                jsonProperty("content", jsonArray(jsonObject(
                                    jsonProperty("attrs", jsonObject(
                                        jsonProperty("label", "Payload → Description"),
                                        jsonProperty("missing", false),
                                        jsonProperty("name", "description")
                                    )),
                                    jsonProperty("type", "varSpec")
                                ))),
                                jsonProperty("type", "paragraph")
                            ))),
                            jsonProperty("type", "doc")
                        )))
                    .build())
                .attributes(AlertSourceTemplateAttributeArgs.builder()
                    .alertAttributeId(data.incident_alert_attribute().team().id())
                    .binding(AlertSourceTemplateAttributeBindingArgs.builder()
                        .value(AlertSourceTemplateAttributeBindingValueArgs.builder()
                            .reference("expressions[\"cloudwatch-team\"]")
                            .build())
                        .build())
                    .build())
                .expressions(AlertSourceTemplateExpressionArgs.builder()
                    .label("Team")
                    .operations(AlertSourceTemplateExpressionOperationArgs.builder()
                        .operationType("parse")
                        .parse(AlertSourceTemplateExpressionOperationParseArgs.builder()
                            .returns(AlertSourceTemplateExpressionOperationParseReturnsArgs.builder()
                                .array(false)
                                .type("CatalogEntry[\"CatalogEntryID\"]")
                                .build())
                            .source("$['query_params']['team']")
                            .build())
                        .build())
                    .reference("cloudwatch-team")
                    .rootReference("payload")
                    .build())
                .build())
            .build());

        //# The `team` Alert Attribute we've configured to label Alerts and route alerts to schedules
        final var squad = IncidentFunctions.getAlertAttribute(GetAlertAttributeArgs.builder()
            .name("Team")
            .build());

        var alerts = new Aws_sns_topic("alerts", Aws_sns_topicArgs.builder()
            .name("cloudwatch-alerts")
            .build());

        //# SNS Topic Subscription that routes to the incident.io Alert Source created above
        var incidentioAlertSource = new Aws_sns_topic_subscription("incidentioAlertSource", Aws_sns_topic_subscriptionArgs.builder()
            .endpoint(String.format("https://api.incident.io/v2/alert_events/cloudwatch/%s?team=platform", cloudwatch.id()))
            .endpointAutoConfirms(true)
            .protocol("https")
            .topicArn(alerts.arn())
            .build());

    }
}

resources:
  ## Create a basic Alert Source that recieves from an SNS Topic in AWS
  cloudwatch: ## The `team` Alert Attribute we've configured to label Alerts and route alerts to schedules
    type: incident:AlertSource
    properties:
      sourceType: cloudwatch
      template:
        title:
          literal:
            fn::toJSON:
              content:
                - content:
                    - attrs:
                        label: Payload → Title
                        missing: false
                        name: title
                      type: varSpec
                  type: paragraph
              type: doc
        description:
          literal:
            fn::toJSON:
              content:
                - content:
                    - attrs:
                        label: Payload → Description
                        missing: false
                        name: description
                      type: varSpec
                  type: paragraph
              type: doc
        attributes:
          - alertAttributeId: ${data.incident_alert_attribute.team.id}
            binding:
              value:
                reference: expressions["cloudwatch-team"]
        expressions:
          - label: Team
            operations:
              - operationType: parse
                parse:
                  returns:
                    array: false
                    type: CatalogEntry["CatalogEntryID"]
                  source: $['query_params']['team']
            reference: cloudwatch-team
            rootReference: payload
  alerts: ## SNS Topic Subscription that routes to the incident.io Alert Source created above
    type: aws:aws_sns_topic
    properties:
      name: cloudwatch-alerts
  incidentioAlertSource:
    type: aws:aws_sns_topic_subscription
    properties:
      endpoint: https://api.incident.io/v2/alert_events/cloudwatch/${cloudwatch.id}?team=platform
      endpointAutoConfirms: true
      protocol: https
      topicArn: ${alerts.arn}
variables:
  squad: ## AWS Resources
    fn::invoke:
      function: incident:getAlertAttribute
      arguments:
        name: Team

var alertSourceResource = new Incident.AlertSource("alertSourceResource", new()
{
    SourceType = "string",
    Template = new Incident.Inputs.AlertSourceTemplateArgs
    {
        Attributes = new[]
        {
            new Incident.Inputs.AlertSourceTemplateAttributeArgs
            {
                AlertAttributeId = "string",
                Binding = new Incident.Inputs.AlertSourceTemplateAttributeBindingArgs
                {
                    ArrayValues = new[]
                    {
                        new Incident.Inputs.AlertSourceTemplateAttributeBindingArrayValueArgs
                        {
                            Literal = "string",
                            Reference = "string",
                        },
                    },
                    Value = new Incident.Inputs.AlertSourceTemplateAttributeBindingValueArgs
                    {
                        Literal = "string",
                        Reference = "string",
                    },
                },
            },
        },
        Description = new Incident.Inputs.AlertSourceTemplateDescriptionArgs
        {
            Literal = "string",
            Reference = "string",
        },
        Expressions = new[]
        {
            new Incident.Inputs.AlertSourceTemplateExpressionArgs
            {
                Label = "string",
                Operations = new[]
                {
                    new Incident.Inputs.AlertSourceTemplateExpressionOperationArgs
                    {
                        OperationType = "string",
                        Branches = new Incident.Inputs.AlertSourceTemplateExpressionOperationBranchesArgs
                        {
                            Branches = new[]
                            {
                                new Incident.Inputs.AlertSourceTemplateExpressionOperationBranchesBranchArgs
                                {
                                    ConditionGroups = new[]
                                    {
                                        new Incident.Inputs.AlertSourceTemplateExpressionOperationBranchesBranchConditionGroupArgs
                                        {
                                            Conditions = new[]
                                            {
                                                new Incident.Inputs.AlertSourceTemplateExpressionOperationBranchesBranchConditionGroupConditionArgs
                                                {
                                                    Operation = "string",
                                                    ParamBindings = new[]
                                                    {
                                                        new Incident.Inputs.AlertSourceTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArgs
                                                        {
                                                            ArrayValues = new[]
                                                            {
                                                                new Incident.Inputs.AlertSourceTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArrayValueArgs
                                                                {
                                                                    Literal = "string",
                                                                    Reference = "string",
                                                                },
                                                            },
                                                            Value = new Incident.Inputs.AlertSourceTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingValueArgs
                                                            {
                                                                Literal = "string",
                                                                Reference = "string",
                                                            },
                                                        },
                                                    },
                                                    Subject = "string",
                                                },
                                            },
                                        },
                                    },
                                    Result = new Incident.Inputs.AlertSourceTemplateExpressionOperationBranchesBranchResultArgs
                                    {
                                        ArrayValues = new[]
                                        {
                                            new Incident.Inputs.AlertSourceTemplateExpressionOperationBranchesBranchResultArrayValueArgs
                                            {
                                                Literal = "string",
                                                Reference = "string",
                                            },
                                        },
                                        Value = new Incident.Inputs.AlertSourceTemplateExpressionOperationBranchesBranchResultValueArgs
                                        {
                                            Literal = "string",
                                            Reference = "string",
                                        },
                                    },
                                },
                            },
                            Returns = new Incident.Inputs.AlertSourceTemplateExpressionOperationBranchesReturnsArgs
                            {
                                Array = false,
                                Type = "string",
                            },
                        },
                        Filter = new Incident.Inputs.AlertSourceTemplateExpressionOperationFilterArgs
                        {
                            ConditionGroups = new[]
                            {
                                new Incident.Inputs.AlertSourceTemplateExpressionOperationFilterConditionGroupArgs
                                {
                                    Conditions = new[]
                                    {
                                        new Incident.Inputs.AlertSourceTemplateExpressionOperationFilterConditionGroupConditionArgs
                                        {
                                            Operation = "string",
                                            ParamBindings = new[]
                                            {
                                                new Incident.Inputs.AlertSourceTemplateExpressionOperationFilterConditionGroupConditionParamBindingArgs
                                                {
                                                    ArrayValues = new[]
                                                    {
                                                        new Incident.Inputs.AlertSourceTemplateExpressionOperationFilterConditionGroupConditionParamBindingArrayValueArgs
                                                        {
                                                            Literal = "string",
                                                            Reference = "string",
                                                        },
                                                    },
                                                    Value = new Incident.Inputs.AlertSourceTemplateExpressionOperationFilterConditionGroupConditionParamBindingValueArgs
                                                    {
                                                        Literal = "string",
                                                        Reference = "string",
                                                    },
                                                },
                                            },
                                            Subject = "string",
                                        },
                                    },
                                },
                            },
                        },
                        Navigate = new Incident.Inputs.AlertSourceTemplateExpressionOperationNavigateArgs
                        {
                            Reference = "string",
                        },
                        Parse = new Incident.Inputs.AlertSourceTemplateExpressionOperationParseArgs
                        {
                            Returns = new Incident.Inputs.AlertSourceTemplateExpressionOperationParseReturnsArgs
                            {
                                Array = false,
                                Type = "string",
                            },
                            Source = "string",
                        },
                    },
                },
                Reference = "string",
                RootReference = "string",
                ElseBranch = new Incident.Inputs.AlertSourceTemplateExpressionElseBranchArgs
                {
                    Result = new Incident.Inputs.AlertSourceTemplateExpressionElseBranchResultArgs
                    {
                        ArrayValues = new[]
                        {
                            new Incident.Inputs.AlertSourceTemplateExpressionElseBranchResultArrayValueArgs
                            {
                                Literal = "string",
                                Reference = "string",
                            },
                        },
                        Value = new Incident.Inputs.AlertSourceTemplateExpressionElseBranchResultValueArgs
                        {
                            Literal = "string",
                            Reference = "string",
                        },
                    },
                },
            },
        },
        Title = new Incident.Inputs.AlertSourceTemplateTitleArgs
        {
            Literal = "string",
            Reference = "string",
        },
    },
    EmailAddress = "string",
    JiraOptions = new Incident.Inputs.AlertSourceJiraOptionsArgs
    {
        ProjectIds = new[]
        {
            "string",
        },
    },
    Name = "string",
});

example, err := incident.NewAlertSource(ctx, "alertSourceResource", &incident.AlertSourceArgs{
SourceType: pulumi.String("string"),
Template: &.AlertSourceTemplateArgs{
Attributes: .AlertSourceTemplateAttributeArray{
&.AlertSourceTemplateAttributeArgs{
AlertAttributeId: pulumi.String("string"),
Binding: &.AlertSourceTemplateAttributeBindingArgs{
ArrayValues: .AlertSourceTemplateAttributeBindingArrayValueArray{
&.AlertSourceTemplateAttributeBindingArrayValueArgs{
Literal: pulumi.String("string"),
Reference: pulumi.String("string"),
},
},
Value: &.AlertSourceTemplateAttributeBindingValueArgs{
Literal: pulumi.String("string"),
Reference: pulumi.String("string"),
},
},
},
},
Description: &.AlertSourceTemplateDescriptionArgs{
Literal: pulumi.String("string"),
Reference: pulumi.String("string"),
},
Expressions: .AlertSourceTemplateExpressionArray{
&.AlertSourceTemplateExpressionArgs{
Label: pulumi.String("string"),
Operations: .AlertSourceTemplateExpressionOperationArray{
&.AlertSourceTemplateExpressionOperationArgs{
OperationType: pulumi.String("string"),
Branches: &.AlertSourceTemplateExpressionOperationBranchesArgs{
Branches: .AlertSourceTemplateExpressionOperationBranchesBranchArray{
&.AlertSourceTemplateExpressionOperationBranchesBranchArgs{
ConditionGroups: .AlertSourceTemplateExpressionOperationBranchesBranchConditionGroupArray{
&.AlertSourceTemplateExpressionOperationBranchesBranchConditionGroupArgs{
Conditions: .AlertSourceTemplateExpressionOperationBranchesBranchConditionGroupConditionArray{
&.AlertSourceTemplateExpressionOperationBranchesBranchConditionGroupConditionArgs{
Operation: pulumi.String("string"),
ParamBindings: .AlertSourceTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArray{
&.AlertSourceTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArgs{
ArrayValues: .AlertSourceTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArrayValueArray{
&.AlertSourceTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArrayValueArgs{
Literal: pulumi.String("string"),
Reference: pulumi.String("string"),
},
},
Value: &.AlertSourceTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingValueArgs{
Literal: pulumi.String("string"),
Reference: pulumi.String("string"),
},
},
},
Subject: pulumi.String("string"),
},
},
},
},
Result: &.AlertSourceTemplateExpressionOperationBranchesBranchResultArgs{
ArrayValues: .AlertSourceTemplateExpressionOperationBranchesBranchResultArrayValueArray{
&.AlertSourceTemplateExpressionOperationBranchesBranchResultArrayValueArgs{
Literal: pulumi.String("string"),
Reference: pulumi.String("string"),
},
},
Value: &.AlertSourceTemplateExpressionOperationBranchesBranchResultValueArgs{
Literal: pulumi.String("string"),
Reference: pulumi.String("string"),
},
},
},
},
Returns: &.AlertSourceTemplateExpressionOperationBranchesReturnsArgs{
Array: pulumi.Bool(false),
Type: pulumi.String("string"),
},
},
Filter: &.AlertSourceTemplateExpressionOperationFilterArgs{
ConditionGroups: .AlertSourceTemplateExpressionOperationFilterConditionGroupArray{
&.AlertSourceTemplateExpressionOperationFilterConditionGroupArgs{
Conditions: .AlertSourceTemplateExpressionOperationFilterConditionGroupConditionArray{
&.AlertSourceTemplateExpressionOperationFilterConditionGroupConditionArgs{
Operation: pulumi.String("string"),
ParamBindings: .AlertSourceTemplateExpressionOperationFilterConditionGroupConditionParamBindingArray{
&.AlertSourceTemplateExpressionOperationFilterConditionGroupConditionParamBindingArgs{
ArrayValues: .AlertSourceTemplateExpressionOperationFilterConditionGroupConditionParamBindingArrayValueArray{
&.AlertSourceTemplateExpressionOperationFilterConditionGroupConditionParamBindingArrayValueArgs{
Literal: pulumi.String("string"),
Reference: pulumi.String("string"),
},
},
Value: &.AlertSourceTemplateExpressionOperationFilterConditionGroupConditionParamBindingValueArgs{
Literal: pulumi.String("string"),
Reference: pulumi.String("string"),
},
},
},
Subject: pulumi.String("string"),
},
},
},
},
},
Navigate: &.AlertSourceTemplateExpressionOperationNavigateArgs{
Reference: pulumi.String("string"),
},
Parse: &.AlertSourceTemplateExpressionOperationParseArgs{
Returns: &.AlertSourceTemplateExpressionOperationParseReturnsArgs{
Array: pulumi.Bool(false),
Type: pulumi.String("string"),
},
Source: pulumi.String("string"),
},
},
},
Reference: pulumi.String("string"),
RootReference: pulumi.String("string"),
ElseBranch: &.AlertSourceTemplateExpressionElseBranchArgs{
Result: &.AlertSourceTemplateExpressionElseBranchResultArgs{
ArrayValues: .AlertSourceTemplateExpressionElseBranchResultArrayValueArray{
&.AlertSourceTemplateExpressionElseBranchResultArrayValueArgs{
Literal: pulumi.String("string"),
Reference: pulumi.String("string"),
},
},
Value: &.AlertSourceTemplateExpressionElseBranchResultValueArgs{
Literal: pulumi.String("string"),
Reference: pulumi.String("string"),
},
},
},
},
},
Title: &.AlertSourceTemplateTitleArgs{
Literal: pulumi.String("string"),
Reference: pulumi.String("string"),
},
},
EmailAddress: pulumi.String("string"),
JiraOptions: &.AlertSourceJiraOptionsArgs{
ProjectIds: pulumi.StringArray{
pulumi.String("string"),
},
},
Name: pulumi.String("string"),
})

var alertSourceResource = new AlertSource("alertSourceResource", AlertSourceArgs.builder()
    .sourceType("string")
    .template(AlertSourceTemplateArgs.builder()
        .attributes(AlertSourceTemplateAttributeArgs.builder()
            .alertAttributeId("string")
            .binding(AlertSourceTemplateAttributeBindingArgs.builder()
                .arrayValues(AlertSourceTemplateAttributeBindingArrayValueArgs.builder()
                    .literal("string")
                    .reference("string")
                    .build())
                .value(AlertSourceTemplateAttributeBindingValueArgs.builder()
                    .literal("string")
                    .reference("string")
                    .build())
                .build())
            .build())
        .description(AlertSourceTemplateDescriptionArgs.builder()
            .literal("string")
            .reference("string")
            .build())
        .expressions(AlertSourceTemplateExpressionArgs.builder()
            .label("string")
            .operations(AlertSourceTemplateExpressionOperationArgs.builder()
                .operationType("string")
                .branches(AlertSourceTemplateExpressionOperationBranchesArgs.builder()
                    .branches(AlertSourceTemplateExpressionOperationBranchesBranchArgs.builder()
                        .conditionGroups(AlertSourceTemplateExpressionOperationBranchesBranchConditionGroupArgs.builder()
                            .conditions(AlertSourceTemplateExpressionOperationBranchesBranchConditionGroupConditionArgs.builder()
                                .operation("string")
                                .paramBindings(AlertSourceTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArgs.builder()
                                    .arrayValues(AlertSourceTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingArrayValueArgs.builder()
                                        .literal("string")
                                        .reference("string")
                                        .build())
                                    .value(AlertSourceTemplateExpressionOperationBranchesBranchConditionGroupConditionParamBindingValueArgs.builder()
                                        .literal("string")
                                        .reference("string")
                                        .build())
                                    .build())
                                .subject("string")
                                .build())
                            .build())
                        .result(AlertSourceTemplateExpressionOperationBranchesBranchResultArgs.builder()
                            .arrayValues(AlertSourceTemplateExpressionOperationBranchesBranchResultArrayValueArgs.builder()
                                .literal("string")
                                .reference("string")
                                .build())
                            .value(AlertSourceTemplateExpressionOperationBranchesBranchResultValueArgs.builder()
                                .literal("string")
                                .reference("string")
                                .build())
                            .build())
                        .build())
                    .returns(AlertSourceTemplateExpressionOperationBranchesReturnsArgs.builder()
                        .array(false)
                        .type("string")
                        .build())
                    .build())
                .filter(AlertSourceTemplateExpressionOperationFilterArgs.builder()
                    .conditionGroups(AlertSourceTemplateExpressionOperationFilterConditionGroupArgs.builder()
                        .conditions(AlertSourceTemplateExpressionOperationFilterConditionGroupConditionArgs.builder()
                            .operation("string")
                            .paramBindings(AlertSourceTemplateExpressionOperationFilterConditionGroupConditionParamBindingArgs.builder()
                                .arrayValues(AlertSourceTemplateExpressionOperationFilterConditionGroupConditionParamBindingArrayValueArgs.builder()
                                    .literal("string")
                                    .reference("string")
                                    .build())
                                .value(AlertSourceTemplateExpressionOperationFilterConditionGroupConditionParamBindingValueArgs.builder()
                                    .literal("string")
                                    .reference("string")
                                    .build())
                                .build())
                            .subject("string")
                            .build())
                        .build())
                    .build())
                .navigate(AlertSourceTemplateExpressionOperationNavigateArgs.builder()
                    .reference("string")
                    .build())
                .parse(AlertSourceTemplateExpressionOperationParseArgs.builder()
                    .returns(AlertSourceTemplateExpressionOperationParseReturnsArgs.builder()
                        .array(false)
                        .type("string")
                        .build())
                    .source("string")
                    .build())
                .build())
            .reference("string")
            .rootReference("string")
            .elseBranch(AlertSourceTemplateExpressionElseBranchArgs.builder()
                .result(AlertSourceTemplateExpressionElseBranchResultArgs.builder()
                    .arrayValues(AlertSourceTemplateExpressionElseBranchResultArrayValueArgs.builder()
                        .literal("string")
                        .reference("string")
                        .build())
                    .value(AlertSourceTemplateExpressionElseBranchResultValueArgs.builder()
                        .literal("string")
                        .reference("string")
                        .build())
                    .build())
                .build())
            .build())
        .title(AlertSourceTemplateTitleArgs.builder()
            .literal("string")
            .reference("string")
            .build())
        .build())
    .emailAddress("string")
    .jiraOptions(AlertSourceJiraOptionsArgs.builder()
        .projectIds("string")
        .build())
    .name("string")
    .build());

alert_source_resource = incident.AlertSource("alertSourceResource",
    source_type="string",
    template={
        "attributes": [{
            "alert_attribute_id": "string",
            "binding": {
                "array_values": [{
                    "literal": "string",
                    "reference": "string",
                }],
                "value": {
                    "literal": "string",
                    "reference": "string",
                },
            },
        }],
        "description": {
            "literal": "string",
            "reference": "string",
        },
        "expressions": [{
            "label": "string",
            "operations": [{
                "operation_type": "string",
                "branches": {
                    "branches": [{
                        "condition_groups": [{
                            "conditions": [{
                                "operation": "string",
                                "param_bindings": [{
                                    "array_values": [{
                                        "literal": "string",
                                        "reference": "string",
                                    }],
                                    "value": {
                                        "literal": "string",
                                        "reference": "string",
                                    },
                                }],
                                "subject": "string",
                            }],
                        }],
                        "result": {
                            "array_values": [{
                                "literal": "string",
                                "reference": "string",
                            }],
                            "value": {
                                "literal": "string",
                                "reference": "string",
                            },
                        },
                    }],
                    "returns": {
                        "array": False,
                        "type": "string",
                    },
                },
                "filter": {
                    "condition_groups": [{
                        "conditions": [{
                            "operation": "string",
                            "param_bindings": [{
                                "array_values": [{
                                    "literal": "string",
                                    "reference": "string",
                                }],
                                "value": {
                                    "literal": "string",
                                    "reference": "string",
                                },
                            }],
                            "subject": "string",
                        }],
                    }],
                },
                "navigate": {
                    "reference": "string",
                },
                "parse": {
                    "returns": {
                        "array": False,
                        "type": "string",
                    },
                    "source": "string",
                },
            }],
            "reference": "string",
            "root_reference": "string",
            "else_branch": {
                "result": {
                    "array_values": [{
                        "literal": "string",
                        "reference": "string",
                    }],
                    "value": {
                        "literal": "string",
                        "reference": "string",
                    },
                },
            },
        }],
        "title": {
            "literal": "string",
            "reference": "string",
        },
    },
    email_address="string",
    jira_options={
        "project_ids": ["string"],
    },
    name="string")

const alertSourceResource = new incident.AlertSource("alertSourceResource", {
    sourceType: "string",
    template: {
        attributes: [{
            alertAttributeId: "string",
            binding: {
                arrayValues: [{
                    literal: "string",
                    reference: "string",
                }],
                value: {
                    literal: "string",
                    reference: "string",
                },
            },
        }],
        description: {
            literal: "string",
            reference: "string",
        },
        expressions: [{
            label: "string",
            operations: [{
                operationType: "string",
                branches: {
                    branches: [{
                        conditionGroups: [{
                            conditions: [{
                                operation: "string",
                                paramBindings: [{
                                    arrayValues: [{
                                        literal: "string",
                                        reference: "string",
                                    }],
                                    value: {
                                        literal: "string",
                                        reference: "string",
                                    },
                                }],
                                subject: "string",
                            }],
                        }],
                        result: {
                            arrayValues: [{
                                literal: "string",
                                reference: "string",
                            }],
                            value: {
                                literal: "string",
                                reference: "string",
                            },
                        },
                    }],
                    returns: {
                        array: false,
                        type: "string",
                    },
                },
                filter: {
                    conditionGroups: [{
                        conditions: [{
                            operation: "string",
                            paramBindings: [{
                                arrayValues: [{
                                    literal: "string",
                                    reference: "string",
                                }],
                                value: {
                                    literal: "string",
                                    reference: "string",
                                },
                            }],
                            subject: "string",
                        }],
                    }],
                },
                navigate: {
                    reference: "string",
                },
                parse: {
                    returns: {
                        array: false,
                        type: "string",
                    },
                    source: "string",
                },
            }],
            reference: "string",
            rootReference: "string",
            elseBranch: {
                result: {
                    arrayValues: [{
                        literal: "string",
                        reference: "string",
                    }],
                    value: {
                        literal: "string",
                        reference: "string",
                    },
                },
            },
        }],
        title: {
            literal: "string",
            reference: "string",
        },
    },
    emailAddress: "string",
    jiraOptions: {
        projectIds: ["string"],
    },
    name: "string",
});