pagerduty.ServiceIntegration

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

const example = new pagerduty.User("example", {
    name: "Earline Greenholt",
    email: "125.greenholt.earline@graham.name",
    teams: [examplePagerdutyTeam.id],
});
const foo = new pagerduty.EscalationPolicy("foo", {
    name: "Engineering Escalation Policy",
    numLoops: 2,
    rules: [{
        escalationDelayInMinutes: 10,
        targets: [{
            type: "user",
            id: example.id,
        }],
    }],
});
const exampleService = new pagerduty.Service("example", {
    name: "My Web App",
    autoResolveTimeout: "14400",
    acknowledgementTimeout: "600",
    escalationPolicy: examplePagerdutyEscalationPolicy.id,
});
const exampleServiceIntegration = new pagerduty.ServiceIntegration("example", {
    name: "Generic API Service Integration",
    type: "generic_events_api_inbound_integration",
    service: exampleService.id,
});
const apiv2 = new pagerduty.ServiceIntegration("apiv2", {
    name: "API V2",
    type: "events_api_v2_inbound_integration",
    service: exampleService.id,
});
const emailX = new pagerduty.ServiceIntegration("email_x", {
    name: "Email X",
    type: "generic_email_inbound_integration",
    integrationEmail: "ecommerce@subdomain.pagerduty.com",
    service: exampleService.id,
});
const datadog = pagerduty.getVendor({
    name: "Datadog",
});
const datadogServiceIntegration = new pagerduty.ServiceIntegration("datadog", {
    name: datadog.then(datadog => datadog.name),
    service: exampleService.id,
    vendor: datadog.then(datadog => datadog.id),
});
const cloudwatch = pagerduty.getVendor({
    name: "Cloudwatch",
});
const cloudwatchServiceIntegration = new pagerduty.ServiceIntegration("cloudwatch", {
    name: cloudwatch.then(cloudwatch => cloudwatch.name),
    service: exampleService.id,
    vendor: cloudwatch.then(cloudwatch => cloudwatch.id),
});
const email = pagerduty.getVendor({
    name: "Email",
});
const emailServiceIntegration = new pagerduty.ServiceIntegration("email", {
    name: email.then(email => email.name),
    service: exampleService.id,
    vendor: email.then(email => email.id),
    integrationEmail: "s1@your_account.pagerduty.com",
    emailIncidentCreation: "use_rules",
    emailFilterMode: "and-rules-email",
    emailFilters: [
        {
            bodyMode: "always",
            bodyRegex: undefined,
            fromEmailMode: "match",
            fromEmailRegex: "(@foo.test*)",
            subjectMode: "match",
            subjectRegex: "(CRITICAL*)",
        },
        {
            bodyMode: "always",
            bodyRegex: undefined,
            fromEmailMode: "match",
            fromEmailRegex: "(@bar.com*)",
            subjectMode: "match",
            subjectRegex: "(CRITICAL*)",
        },
    ],
    emailParsers: [{
        action: "resolve",
        matchPredicate: {
            type: "any",
            predicates: [
                {
                    matcher: "foo",
                    part: "subject",
                    type: "contains",
                },
                {
                    type: "not",
                    predicates: [{
                        matcher: "(bar*)",
                        part: "body",
                        type: "regex",
                    }],
                },
            ],
        },
        valueExtractors: [
            {
                endsBefore: "end",
                part: "subject",
                startsAfter: "start",
                type: "between",
                valueName: "incident_key",
            },
            {
                endsBefore: "end",
                part: "subject",
                startsAfter: "start",
                type: "between",
                valueName: "FieldName1",
            },
        ],
    }],
});

import pulumi
import pulumi_pagerduty as pagerduty

example = pagerduty.User("example",
    name="Earline Greenholt",
    email="125.greenholt.earline@graham.name",
    teams=[example_pagerduty_team["id"]])
foo = pagerduty.EscalationPolicy("foo",
    name="Engineering Escalation Policy",
    num_loops=2,
    rules=[pagerduty.EscalationPolicyRuleArgs(
        escalation_delay_in_minutes=10,
        targets=[pagerduty.EscalationPolicyRuleTargetArgs(
            type="user",
            id=example.id,
        )],
    )])
example_service = pagerduty.Service("example",
    name="My Web App",
    auto_resolve_timeout="14400",
    acknowledgement_timeout="600",
    escalation_policy=example_pagerduty_escalation_policy["id"])
example_service_integration = pagerduty.ServiceIntegration("example",
    name="Generic API Service Integration",
    type="generic_events_api_inbound_integration",
    service=example_service.id)
apiv2 = pagerduty.ServiceIntegration("apiv2",
    name="API V2",
    type="events_api_v2_inbound_integration",
    service=example_service.id)
email_x = pagerduty.ServiceIntegration("email_x",
    name="Email X",
    type="generic_email_inbound_integration",
    integration_email="ecommerce@subdomain.pagerduty.com",
    service=example_service.id)
datadog = pagerduty.get_vendor(name="Datadog")
datadog_service_integration = pagerduty.ServiceIntegration("datadog",
    name=datadog.name,
    service=example_service.id,
    vendor=datadog.id)
cloudwatch = pagerduty.get_vendor(name="Cloudwatch")
cloudwatch_service_integration = pagerduty.ServiceIntegration("cloudwatch",
    name=cloudwatch.name,
    service=example_service.id,
    vendor=cloudwatch.id)
email = pagerduty.get_vendor(name="Email")
email_service_integration = pagerduty.ServiceIntegration("email",
    name=email.name,
    service=example_service.id,
    vendor=email.id,
    integration_email="s1@your_account.pagerduty.com",
    email_incident_creation="use_rules",
    email_filter_mode="and-rules-email",
    email_filters=[
        pagerduty.ServiceIntegrationEmailFilterArgs(
            body_mode="always",
            body_regex=None,
            from_email_mode="match",
            from_email_regex="(@foo.test*)",
            subject_mode="match",
            subject_regex="(CRITICAL*)",
        ),
        pagerduty.ServiceIntegrationEmailFilterArgs(
            body_mode="always",
            body_regex=None,
            from_email_mode="match",
            from_email_regex="(@bar.com*)",
            subject_mode="match",
            subject_regex="(CRITICAL*)",
        ),
    ],
    email_parsers=[pagerduty.ServiceIntegrationEmailParserArgs(
        action="resolve",
        match_predicate=pagerduty.ServiceIntegrationEmailParserMatchPredicateArgs(
            type="any",
            predicates=[
                pagerduty.ServiceIntegrationEmailParserMatchPredicatePredicateArgs(
                    matcher="foo",
                    part="subject",
                    type="contains",
                ),
                pagerduty.ServiceIntegrationEmailParserMatchPredicatePredicateArgs(
                    type="not",
                    predicates=[pagerduty.ServiceIntegrationEmailParserMatchPredicatePredicatePredicateArgs(
                        matcher="(bar*)",
                        part="body",
                        type="regex",
                    )],
                ),
            ],
        ),
        value_extractors=[
            pagerduty.ServiceIntegrationEmailParserValueExtractorArgs(
                ends_before="end",
                part="subject",
                starts_after="start",
                type="between",
                value_name="incident_key",
            ),
            pagerduty.ServiceIntegrationEmailParserValueExtractorArgs(
                ends_before="end",
                part="subject",
                starts_after="start",
                type="between",
                value_name="FieldName1",
            ),
        ],
    )])

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 {
		example, err := pagerduty.NewUser(ctx, "example", &pagerduty.UserArgs{
			Name:  pulumi.String("Earline Greenholt"),
			Email: pulumi.String("125.greenholt.earline@graham.name"),
			Teams: pulumi.StringArray{
				examplePagerdutyTeam.Id,
			},
		})
		if err != nil {
			return err
		}
		_, err = pagerduty.NewEscalationPolicy(ctx, "foo", &pagerduty.EscalationPolicyArgs{
			Name:     pulumi.String("Engineering Escalation Policy"),
			NumLoops: pulumi.Int(2),
			Rules: pagerduty.EscalationPolicyRuleArray{
				&pagerduty.EscalationPolicyRuleArgs{
					EscalationDelayInMinutes: pulumi.Int(10),
					Targets: pagerduty.EscalationPolicyRuleTargetArray{
						&pagerduty.EscalationPolicyRuleTargetArgs{
							Type: pulumi.String("user"),
							Id:   example.ID(),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		exampleService, err := pagerduty.NewService(ctx, "example", &pagerduty.ServiceArgs{
			Name:                   pulumi.String("My Web App"),
			AutoResolveTimeout:     pulumi.String("14400"),
			AcknowledgementTimeout: pulumi.String("600"),
			EscalationPolicy:       pulumi.Any(examplePagerdutyEscalationPolicy.Id),
		})
		if err != nil {
			return err
		}
		_, err = pagerduty.NewServiceIntegration(ctx, "example", &pagerduty.ServiceIntegrationArgs{
			Name:    pulumi.String("Generic API Service Integration"),
			Type:    pulumi.String("generic_events_api_inbound_integration"),
			Service: exampleService.ID(),
		})
		if err != nil {
			return err
		}
		_, err = pagerduty.NewServiceIntegration(ctx, "apiv2", &pagerduty.ServiceIntegrationArgs{
			Name:    pulumi.String("API V2"),
			Type:    pulumi.String("events_api_v2_inbound_integration"),
			Service: exampleService.ID(),
		})
		if err != nil {
			return err
		}
		_, err = pagerduty.NewServiceIntegration(ctx, "email_x", &pagerduty.ServiceIntegrationArgs{
			Name:             pulumi.String("Email X"),
			Type:             pulumi.String("generic_email_inbound_integration"),
			IntegrationEmail: pulumi.String("ecommerce@subdomain.pagerduty.com"),
			Service:          exampleService.ID(),
		})
		if err != nil {
			return err
		}
		datadog, err := pagerduty.GetVendor(ctx, &pagerduty.GetVendorArgs{
			Name: "Datadog",
		}, nil)
		if err != nil {
			return err
		}
		_, err = pagerduty.NewServiceIntegration(ctx, "datadog", &pagerduty.ServiceIntegrationArgs{
			Name:    pulumi.String(datadog.Name),
			Service: exampleService.ID(),
			Vendor:  pulumi.String(datadog.Id),
		})
		if err != nil {
			return err
		}
		cloudwatch, err := pagerduty.GetVendor(ctx, &pagerduty.GetVendorArgs{
			Name: "Cloudwatch",
		}, nil)
		if err != nil {
			return err
		}
		_, err = pagerduty.NewServiceIntegration(ctx, "cloudwatch", &pagerduty.ServiceIntegrationArgs{
			Name:    pulumi.String(cloudwatch.Name),
			Service: exampleService.ID(),
			Vendor:  pulumi.String(cloudwatch.Id),
		})
		if err != nil {
			return err
		}
		email, err := pagerduty.GetVendor(ctx, &pagerduty.GetVendorArgs{
			Name: "Email",
		}, nil)
		if err != nil {
			return err
		}
		_, err = pagerduty.NewServiceIntegration(ctx, "email", &pagerduty.ServiceIntegrationArgs{
			Name:                  pulumi.String(email.Name),
			Service:               exampleService.ID(),
			Vendor:                pulumi.String(email.Id),
			IntegrationEmail:      pulumi.String("s1@your_account.pagerduty.com"),
			EmailIncidentCreation: pulumi.String("use_rules"),
			EmailFilterMode:       pulumi.String("and-rules-email"),
			EmailFilters: pagerduty.ServiceIntegrationEmailFilterArray{
				&pagerduty.ServiceIntegrationEmailFilterArgs{
					BodyMode:       pulumi.String("always"),
					BodyRegex:      nil,
					FromEmailMode:  pulumi.String("match"),
					FromEmailRegex: pulumi.String("(@foo.test*)"),
					SubjectMode:    pulumi.String("match"),
					SubjectRegex:   pulumi.String("(CRITICAL*)"),
				},
				&pagerduty.ServiceIntegrationEmailFilterArgs{
					BodyMode:       pulumi.String("always"),
					BodyRegex:      nil,
					FromEmailMode:  pulumi.String("match"),
					FromEmailRegex: pulumi.String("(@bar.com*)"),
					SubjectMode:    pulumi.String("match"),
					SubjectRegex:   pulumi.String("(CRITICAL*)"),
				},
			},
			EmailParsers: pagerduty.ServiceIntegrationEmailParserArray{
				&pagerduty.ServiceIntegrationEmailParserArgs{
					Action: pulumi.String("resolve"),
					MatchPredicate: &pagerduty.ServiceIntegrationEmailParserMatchPredicateArgs{
						Type: pulumi.String("any"),
						Predicates: pagerduty.ServiceIntegrationEmailParserMatchPredicatePredicateArray{
							&pagerduty.ServiceIntegrationEmailParserMatchPredicatePredicateArgs{
								Matcher: pulumi.String("foo"),
								Part:    pulumi.String("subject"),
								Type:    pulumi.String("contains"),
							},
							&pagerduty.ServiceIntegrationEmailParserMatchPredicatePredicateArgs{
								Type: pulumi.String("not"),
								Predicates: pagerduty.ServiceIntegrationEmailParserMatchPredicatePredicatePredicateArray{
									&pagerduty.ServiceIntegrationEmailParserMatchPredicatePredicatePredicateArgs{
										Matcher: pulumi.String("(bar*)"),
										Part:    pulumi.String("body"),
										Type:    pulumi.String("regex"),
									},
								},
							},
						},
					},
					ValueExtractors: pagerduty.ServiceIntegrationEmailParserValueExtractorArray{
						&pagerduty.ServiceIntegrationEmailParserValueExtractorArgs{
							EndsBefore:  pulumi.String("end"),
							Part:        pulumi.String("subject"),
							StartsAfter: pulumi.String("start"),
							Type:        pulumi.String("between"),
							ValueName:   pulumi.String("incident_key"),
						},
						&pagerduty.ServiceIntegrationEmailParserValueExtractorArgs{
							EndsBefore:  pulumi.String("end"),
							Part:        pulumi.String("subject"),
							StartsAfter: pulumi.String("start"),
							Type:        pulumi.String("between"),
							ValueName:   pulumi.String("FieldName1"),
						},
					},
				},
			},
		})
		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 example = new Pagerduty.User("example", new()
    {
        Name = "Earline Greenholt",
        Email = "125.greenholt.earline@graham.name",
        Teams = new[]
        {
            examplePagerdutyTeam.Id,
        },
    });

    var foo = new Pagerduty.EscalationPolicy("foo", new()
    {
        Name = "Engineering Escalation Policy",
        NumLoops = 2,
        Rules = new[]
        {
            new Pagerduty.Inputs.EscalationPolicyRuleArgs
            {
                EscalationDelayInMinutes = 10,
                Targets = new[]
                {
                    new Pagerduty.Inputs.EscalationPolicyRuleTargetArgs
                    {
                        Type = "user",
                        Id = example.Id,
                    },
                },
            },
        },
    });

    var exampleService = new Pagerduty.Service("example", new()
    {
        Name = "My Web App",
        AutoResolveTimeout = "14400",
        AcknowledgementTimeout = "600",
        EscalationPolicy = examplePagerdutyEscalationPolicy.Id,
    });

    var exampleServiceIntegration = new Pagerduty.ServiceIntegration("example", new()
    {
        Name = "Generic API Service Integration",
        Type = "generic_events_api_inbound_integration",
        Service = exampleService.Id,
    });

    var apiv2 = new Pagerduty.ServiceIntegration("apiv2", new()
    {
        Name = "API V2",
        Type = "events_api_v2_inbound_integration",
        Service = exampleService.Id,
    });

    var emailX = new Pagerduty.ServiceIntegration("email_x", new()
    {
        Name = "Email X",
        Type = "generic_email_inbound_integration",
        IntegrationEmail = "ecommerce@subdomain.pagerduty.com",
        Service = exampleService.Id,
    });

    var datadog = Pagerduty.GetVendor.Invoke(new()
    {
        Name = "Datadog",
    });

    var datadogServiceIntegration = new Pagerduty.ServiceIntegration("datadog", new()
    {
        Name = datadog.Apply(getVendorResult => getVendorResult.Name),
        Service = exampleService.Id,
        Vendor = datadog.Apply(getVendorResult => getVendorResult.Id),
    });

    var cloudwatch = Pagerduty.GetVendor.Invoke(new()
    {
        Name = "Cloudwatch",
    });

    var cloudwatchServiceIntegration = new Pagerduty.ServiceIntegration("cloudwatch", new()
    {
        Name = cloudwatch.Apply(getVendorResult => getVendorResult.Name),
        Service = exampleService.Id,
        Vendor = cloudwatch.Apply(getVendorResult => getVendorResult.Id),
    });

    var email = Pagerduty.GetVendor.Invoke(new()
    {
        Name = "Email",
    });

    var emailServiceIntegration = new Pagerduty.ServiceIntegration("email", new()
    {
        Name = email.Apply(getVendorResult => getVendorResult.Name),
        Service = exampleService.Id,
        Vendor = email.Apply(getVendorResult => getVendorResult.Id),
        IntegrationEmail = "s1@your_account.pagerduty.com",
        EmailIncidentCreation = "use_rules",
        EmailFilterMode = "and-rules-email",
        EmailFilters = new[]
        {
            new Pagerduty.Inputs.ServiceIntegrationEmailFilterArgs
            {
                BodyMode = "always",
                BodyRegex = null,
                FromEmailMode = "match",
                FromEmailRegex = "(@foo.test*)",
                SubjectMode = "match",
                SubjectRegex = "(CRITICAL*)",
            },
            new Pagerduty.Inputs.ServiceIntegrationEmailFilterArgs
            {
                BodyMode = "always",
                BodyRegex = null,
                FromEmailMode = "match",
                FromEmailRegex = "(@bar.com*)",
                SubjectMode = "match",
                SubjectRegex = "(CRITICAL*)",
            },
        },
        EmailParsers = new[]
        {
            new Pagerduty.Inputs.ServiceIntegrationEmailParserArgs
            {
                Action = "resolve",
                MatchPredicate = new Pagerduty.Inputs.ServiceIntegrationEmailParserMatchPredicateArgs
                {
                    Type = "any",
                    Predicates = new[]
                    {
                        new Pagerduty.Inputs.ServiceIntegrationEmailParserMatchPredicatePredicateArgs
                        {
                            Matcher = "foo",
                            Part = "subject",
                            Type = "contains",
                        },
                        new Pagerduty.Inputs.ServiceIntegrationEmailParserMatchPredicatePredicateArgs
                        {
                            Type = "not",
                            Predicates = new[]
                            {
                                new Pagerduty.Inputs.ServiceIntegrationEmailParserMatchPredicatePredicatePredicateArgs
                                {
                                    Matcher = "(bar*)",
                                    Part = "body",
                                    Type = "regex",
                                },
                            },
                        },
                    },
                },
                ValueExtractors = new[]
                {
                    new Pagerduty.Inputs.ServiceIntegrationEmailParserValueExtractorArgs
                    {
                        EndsBefore = "end",
                        Part = "subject",
                        StartsAfter = "start",
                        Type = "between",
                        ValueName = "incident_key",
                    },
                    new Pagerduty.Inputs.ServiceIntegrationEmailParserValueExtractorArgs
                    {
                        EndsBefore = "end",
                        Part = "subject",
                        StartsAfter = "start",
                        Type = "between",
                        ValueName = "FieldName1",
                    },
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.pagerduty.User;
import com.pulumi.pagerduty.UserArgs;
import com.pulumi.pagerduty.EscalationPolicy;
import com.pulumi.pagerduty.EscalationPolicyArgs;
import com.pulumi.pagerduty.inputs.EscalationPolicyRuleArgs;
import com.pulumi.pagerduty.Service;
import com.pulumi.pagerduty.ServiceArgs;
import com.pulumi.pagerduty.ServiceIntegration;
import com.pulumi.pagerduty.ServiceIntegrationArgs;
import com.pulumi.pagerduty.PagerdutyFunctions;
import com.pulumi.pagerduty.inputs.GetVendorArgs;
import com.pulumi.pagerduty.inputs.ServiceIntegrationEmailFilterArgs;
import com.pulumi.pagerduty.inputs.ServiceIntegrationEmailParserArgs;
import com.pulumi.pagerduty.inputs.ServiceIntegrationEmailParserMatchPredicateArgs;
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 example = new User("example", UserArgs.builder()        
            .name("Earline Greenholt")
            .email("125.greenholt.earline@graham.name")
            .teams(examplePagerdutyTeam.id())
            .build());

        var foo = new EscalationPolicy("foo", EscalationPolicyArgs.builder()        
            .name("Engineering Escalation Policy")
            .numLoops(2)
            .rules(EscalationPolicyRuleArgs.builder()
                .escalationDelayInMinutes(10)
                .targets(EscalationPolicyRuleTargetArgs.builder()
                    .type("user")
                    .id(example.id())
                    .build())
                .build())
            .build());

        var exampleService = new Service("exampleService", ServiceArgs.builder()        
            .name("My Web App")
            .autoResolveTimeout(14400)
            .acknowledgementTimeout(600)
            .escalationPolicy(examplePagerdutyEscalationPolicy.id())
            .build());

        var exampleServiceIntegration = new ServiceIntegration("exampleServiceIntegration", ServiceIntegrationArgs.builder()        
            .name("Generic API Service Integration")
            .type("generic_events_api_inbound_integration")
            .service(exampleService.id())
            .build());

        var apiv2 = new ServiceIntegration("apiv2", ServiceIntegrationArgs.builder()        
            .name("API V2")
            .type("events_api_v2_inbound_integration")
            .service(exampleService.id())
            .build());

        var emailX = new ServiceIntegration("emailX", ServiceIntegrationArgs.builder()        
            .name("Email X")
            .type("generic_email_inbound_integration")
            .integrationEmail("ecommerce@subdomain.pagerduty.com")
            .service(exampleService.id())
            .build());

        final var datadog = PagerdutyFunctions.getVendor(GetVendorArgs.builder()
            .name("Datadog")
            .build());

        var datadogServiceIntegration = new ServiceIntegration("datadogServiceIntegration", ServiceIntegrationArgs.builder()        
            .name(datadog.applyValue(getVendorResult -> getVendorResult.name()))
            .service(exampleService.id())
            .vendor(datadog.applyValue(getVendorResult -> getVendorResult.id()))
            .build());

        final var cloudwatch = PagerdutyFunctions.getVendor(GetVendorArgs.builder()
            .name("Cloudwatch")
            .build());

        var cloudwatchServiceIntegration = new ServiceIntegration("cloudwatchServiceIntegration", ServiceIntegrationArgs.builder()        
            .name(cloudwatch.applyValue(getVendorResult -> getVendorResult.name()))
            .service(exampleService.id())
            .vendor(cloudwatch.applyValue(getVendorResult -> getVendorResult.id()))
            .build());

        final var email = PagerdutyFunctions.getVendor(GetVendorArgs.builder()
            .name("Email")
            .build());

        var emailServiceIntegration = new ServiceIntegration("emailServiceIntegration", ServiceIntegrationArgs.builder()        
            .name(email.applyValue(getVendorResult -> getVendorResult.name()))
            .service(exampleService.id())
            .vendor(email.applyValue(getVendorResult -> getVendorResult.id()))
            .integrationEmail("s1@your_account.pagerduty.com")
            .emailIncidentCreation("use_rules")
            .emailFilterMode("and-rules-email")
            .emailFilters(            
                ServiceIntegrationEmailFilterArgs.builder()
                    .bodyMode("always")
                    .bodyRegex(null)
                    .fromEmailMode("match")
                    .fromEmailRegex("(@foo.test*)")
                    .subjectMode("match")
                    .subjectRegex("(CRITICAL*)")
                    .build(),
                ServiceIntegrationEmailFilterArgs.builder()
                    .bodyMode("always")
                    .bodyRegex(null)
                    .fromEmailMode("match")
                    .fromEmailRegex("(@bar.com*)")
                    .subjectMode("match")
                    .subjectRegex("(CRITICAL*)")
                    .build())
            .emailParsers(ServiceIntegrationEmailParserArgs.builder()
                .action("resolve")
                .matchPredicate(ServiceIntegrationEmailParserMatchPredicateArgs.builder()
                    .type("any")
                    .predicates(                    
                        ServiceIntegrationEmailParserMatchPredicatePredicateArgs.builder()
                            .matcher("foo")
                            .part("subject")
                            .type("contains")
                            .build(),
                        ServiceIntegrationEmailParserMatchPredicatePredicateArgs.builder()
                            .type("not")
                            .predicates(ServiceIntegrationEmailParserMatchPredicatePredicatePredicateArgs.builder()
                                .matcher("(bar*)")
                                .part("body")
                                .type("regex")
                                .build())
                            .build())
                    .build())
                .valueExtractors(                
                    ServiceIntegrationEmailParserValueExtractorArgs.builder()
                        .endsBefore("end")
                        .part("subject")
                        .startsAfter("start")
                        .type("between")
                        .valueName("incident_key")
                        .build(),
                    ServiceIntegrationEmailParserValueExtractorArgs.builder()
                        .endsBefore("end")
                        .part("subject")
                        .startsAfter("start")
                        .type("between")
                        .valueName("FieldName1")
                        .build())
                .build())
            .build());

    }
}

resources:
  example:
    type: pagerduty:User
    properties:
      name: Earline Greenholt
      email: 125.greenholt.earline@graham.name
      teams:
        - ${examplePagerdutyTeam.id}
  foo:
    type: pagerduty:EscalationPolicy
    properties:
      name: Engineering Escalation Policy
      numLoops: 2
      rules:
        - escalationDelayInMinutes: 10
          targets:
            - type: user
              id: ${example.id}
  exampleService:
    type: pagerduty:Service
    name: example
    properties:
      name: My Web App
      autoResolveTimeout: 14400
      acknowledgementTimeout: 600
      escalationPolicy: ${examplePagerdutyEscalationPolicy.id}
  exampleServiceIntegration:
    type: pagerduty:ServiceIntegration
    name: example
    properties:
      name: Generic API Service Integration
      type: generic_events_api_inbound_integration
      service: ${exampleService.id}
  apiv2:
    type: pagerduty:ServiceIntegration
    properties:
      name: API V2
      type: events_api_v2_inbound_integration
      service: ${exampleService.id}
  emailX:
    type: pagerduty:ServiceIntegration
    name: email_x
    properties:
      name: Email X
      type: generic_email_inbound_integration
      integrationEmail: ecommerce@subdomain.pagerduty.com
      service: ${exampleService.id}
  datadogServiceIntegration:
    type: pagerduty:ServiceIntegration
    name: datadog
    properties:
      name: ${datadog.name}
      service: ${exampleService.id}
      vendor: ${datadog.id}
  cloudwatchServiceIntegration:
    type: pagerduty:ServiceIntegration
    name: cloudwatch
    properties:
      name: ${cloudwatch.name}
      service: ${exampleService.id}
      vendor: ${cloudwatch.id}
  emailServiceIntegration:
    type: pagerduty:ServiceIntegration
    name: email
    properties:
      name: ${email.name}
      service: ${exampleService.id}
      vendor: ${email.id}
      integrationEmail: s1@your_account.pagerduty.com
      emailIncidentCreation: use_rules
      emailFilterMode: and-rules-email
      emailFilters:
        - bodyMode: always
          bodyRegex: null
          fromEmailMode: match
          fromEmailRegex: (@foo.test*)
          subjectMode: match
          subjectRegex: (CRITICAL*)
        - bodyMode: always
          bodyRegex: null
          fromEmailMode: match
          fromEmailRegex: (@bar.com*)
          subjectMode: match
          subjectRegex: (CRITICAL*)
      emailParsers:
        - action: resolve
          matchPredicate:
            type: any
            predicates:
              - matcher: foo
                part: subject
                type: contains
              - type: not
                predicates:
                  - matcher: (bar*)
                    part: body
                    type: regex
          valueExtractors:
            - endsBefore: end
              part: subject
              startsAfter: start
              type: between
              valueName: incident_key
            - endsBefore: end
              part: subject
              startsAfter: start
              type: between
              valueName: FieldName1
variables:
  datadog:
    fn::invoke:
      Function: pagerduty:getVendor
      Arguments:
        name: Datadog
  cloudwatch:
    fn::invoke:
      Function: pagerduty:getVendor
      Arguments:
        name: Cloudwatch
  email:
    fn::invoke:
      Function: pagerduty:getVendor
      Arguments:
        name: Email

var serviceIntegrationResource = new Pagerduty.ServiceIntegration("serviceIntegrationResource", new()
{
    Service = "string",
    EmailFilterMode = "string",
    EmailFilters = new[]
    {
        new Pagerduty.Inputs.ServiceIntegrationEmailFilterArgs
        {
            BodyMode = "string",
            BodyRegex = "string",
            FromEmailMode = "string",
            FromEmailRegex = "string",
            Id = "string",
            SubjectMode = "string",
            SubjectRegex = "string",
        },
    },
    EmailIncidentCreation = "string",
    EmailParsers = new[]
    {
        new Pagerduty.Inputs.ServiceIntegrationEmailParserArgs
        {
            Action = "string",
            MatchPredicate = new Pagerduty.Inputs.ServiceIntegrationEmailParserMatchPredicateArgs
            {
                Type = "string",
                Predicates = new[]
                {
                    new Pagerduty.Inputs.ServiceIntegrationEmailParserMatchPredicatePredicateArgs
                    {
                        Type = "string",
                        Matcher = "string",
                        Part = "string",
                        Predicates = new[]
                        {
                            new Pagerduty.Inputs.ServiceIntegrationEmailParserMatchPredicatePredicatePredicateArgs
                            {
                                Matcher = "string",
                                Part = "string",
                                Type = "string",
                            },
                        },
                    },
                },
            },
            Id = 0,
            ValueExtractors = new[]
            {
                new Pagerduty.Inputs.ServiceIntegrationEmailParserValueExtractorArgs
                {
                    Part = "string",
                    Type = "string",
                    ValueName = "string",
                    EndsBefore = "string",
                    Regex = "string",
                    StartsAfter = "string",
                },
            },
        },
    },
    EmailParsingFallback = "string",
    IntegrationEmail = "string",
    IntegrationKey = "string",
    Name = "string",
    Type = "string",
    Vendor = "string",
});

example, err := pagerduty.NewServiceIntegration(ctx, "serviceIntegrationResource", &pagerduty.ServiceIntegrationArgs{
	Service:         pulumi.String("string"),
	EmailFilterMode: pulumi.String("string"),
	EmailFilters: pagerduty.ServiceIntegrationEmailFilterArray{
		&pagerduty.ServiceIntegrationEmailFilterArgs{
			BodyMode:       pulumi.String("string"),
			BodyRegex:      pulumi.String("string"),
			FromEmailMode:  pulumi.String("string"),
			FromEmailRegex: pulumi.String("string"),
			Id:             pulumi.String("string"),
			SubjectMode:    pulumi.String("string"),
			SubjectRegex:   pulumi.String("string"),
		},
	},
	EmailIncidentCreation: pulumi.String("string"),
	EmailParsers: pagerduty.ServiceIntegrationEmailParserArray{
		&pagerduty.ServiceIntegrationEmailParserArgs{
			Action: pulumi.String("string"),
			MatchPredicate: &pagerduty.ServiceIntegrationEmailParserMatchPredicateArgs{
				Type: pulumi.String("string"),
				Predicates: pagerduty.ServiceIntegrationEmailParserMatchPredicatePredicateArray{
					&pagerduty.ServiceIntegrationEmailParserMatchPredicatePredicateArgs{
						Type:    pulumi.String("string"),
						Matcher: pulumi.String("string"),
						Part:    pulumi.String("string"),
						Predicates: pagerduty.ServiceIntegrationEmailParserMatchPredicatePredicatePredicateArray{
							&pagerduty.ServiceIntegrationEmailParserMatchPredicatePredicatePredicateArgs{
								Matcher: pulumi.String("string"),
								Part:    pulumi.String("string"),
								Type:    pulumi.String("string"),
							},
						},
					},
				},
			},
			Id: pulumi.Int(0),
			ValueExtractors: pagerduty.ServiceIntegrationEmailParserValueExtractorArray{
				&pagerduty.ServiceIntegrationEmailParserValueExtractorArgs{
					Part:        pulumi.String("string"),
					Type:        pulumi.String("string"),
					ValueName:   pulumi.String("string"),
					EndsBefore:  pulumi.String("string"),
					Regex:       pulumi.String("string"),
					StartsAfter: pulumi.String("string"),
				},
			},
		},
	},
	EmailParsingFallback: pulumi.String("string"),
	IntegrationEmail:     pulumi.String("string"),
	IntegrationKey:       pulumi.String("string"),
	Name:                 pulumi.String("string"),
	Type:                 pulumi.String("string"),
	Vendor:               pulumi.String("string"),
})

var serviceIntegrationResource = new ServiceIntegration("serviceIntegrationResource", ServiceIntegrationArgs.builder()
    .service("string")
    .emailFilterMode("string")
    .emailFilters(ServiceIntegrationEmailFilterArgs.builder()
        .bodyMode("string")
        .bodyRegex("string")
        .fromEmailMode("string")
        .fromEmailRegex("string")
        .id("string")
        .subjectMode("string")
        .subjectRegex("string")
        .build())
    .emailIncidentCreation("string")
    .emailParsers(ServiceIntegrationEmailParserArgs.builder()
        .action("string")
        .matchPredicate(ServiceIntegrationEmailParserMatchPredicateArgs.builder()
            .type("string")
            .predicates(ServiceIntegrationEmailParserMatchPredicatePredicateArgs.builder()
                .type("string")
                .matcher("string")
                .part("string")
                .predicates(ServiceIntegrationEmailParserMatchPredicatePredicatePredicateArgs.builder()
                    .matcher("string")
                    .part("string")
                    .type("string")
                    .build())
                .build())
            .build())
        .id(0)
        .valueExtractors(ServiceIntegrationEmailParserValueExtractorArgs.builder()
            .part("string")
            .type("string")
            .valueName("string")
            .endsBefore("string")
            .regex("string")
            .startsAfter("string")
            .build())
        .build())
    .emailParsingFallback("string")
    .integrationEmail("string")
    .integrationKey("string")
    .name("string")
    .type("string")
    .vendor("string")
    .build());

service_integration_resource = pagerduty.ServiceIntegration("serviceIntegrationResource",
    service="string",
    email_filter_mode="string",
    email_filters=[pagerduty.ServiceIntegrationEmailFilterArgs(
        body_mode="string",
        body_regex="string",
        from_email_mode="string",
        from_email_regex="string",
        id="string",
        subject_mode="string",
        subject_regex="string",
    )],
    email_incident_creation="string",
    email_parsers=[pagerduty.ServiceIntegrationEmailParserArgs(
        action="string",
        match_predicate=pagerduty.ServiceIntegrationEmailParserMatchPredicateArgs(
            type="string",
            predicates=[pagerduty.ServiceIntegrationEmailParserMatchPredicatePredicateArgs(
                type="string",
                matcher="string",
                part="string",
                predicates=[pagerduty.ServiceIntegrationEmailParserMatchPredicatePredicatePredicateArgs(
                    matcher="string",
                    part="string",
                    type="string",
                )],
            )],
        ),
        id=0,
        value_extractors=[pagerduty.ServiceIntegrationEmailParserValueExtractorArgs(
            part="string",
            type="string",
            value_name="string",
            ends_before="string",
            regex="string",
            starts_after="string",
        )],
    )],
    email_parsing_fallback="string",
    integration_email="string",
    integration_key="string",
    name="string",
    type="string",
    vendor="string")

const serviceIntegrationResource = new pagerduty.ServiceIntegration("serviceIntegrationResource", {
    service: "string",
    emailFilterMode: "string",
    emailFilters: [{
        bodyMode: "string",
        bodyRegex: "string",
        fromEmailMode: "string",
        fromEmailRegex: "string",
        id: "string",
        subjectMode: "string",
        subjectRegex: "string",
    }],
    emailIncidentCreation: "string",
    emailParsers: [{
        action: "string",
        matchPredicate: {
            type: "string",
            predicates: [{
                type: "string",
                matcher: "string",
                part: "string",
                predicates: [{
                    matcher: "string",
                    part: "string",
                    type: "string",
                }],
            }],
        },
        id: 0,
        valueExtractors: [{
            part: "string",
            type: "string",
            valueName: "string",
            endsBefore: "string",
            regex: "string",
            startsAfter: "string",
        }],
    }],
    emailParsingFallback: "string",
    integrationEmail: "string",
    integrationKey: "string",
    name: "string",
    type: "string",
    vendor: "string",
});

type: pagerduty:ServiceIntegration
properties:
    emailFilterMode: string
    emailFilters:
        - bodyMode: string
          bodyRegex: string
          fromEmailMode: string
          fromEmailRegex: string
          id: string
          subjectMode: string
          subjectRegex: string
    emailIncidentCreation: string
    emailParsers:
        - action: string
          id: 0
          matchPredicate:
            predicates:
                - matcher: string
                  part: string
                  predicates:
                    - matcher: string
                      part: string
                      type: string
                  type: string
            type: string
          valueExtractors:
            - endsBefore: string
              part: string
              regex: string
              startsAfter: string
              type: string
              valueName: string
    emailParsingFallback: string
    integrationEmail: string
    integrationKey: string
    name: string
    service: string
    type: string
    vendor: string