opsgenie.TeamRoutingRule

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

return await Deployment.RunAsync(() => 
{
    var testSchedule = new Opsgenie.Schedule("testSchedule", new()
    {
        Description = "schedule test",
        Enabled = false,
        Timezone = "Europe/Rome",
    });

    var testTeam = new Opsgenie.Team("testTeam", new()
    {
        Description = "This team deals with all the things",
    });

    var testTeamRoutingRule = new Opsgenie.TeamRoutingRule("testTeamRoutingRule", new()
    {
        Criterias = new[]
        {
            new Opsgenie.Inputs.TeamRoutingRuleCriteriaArgs
            {
                Conditions = new[]
                {
                    new Opsgenie.Inputs.TeamRoutingRuleCriteriaConditionArgs
                    {
                        ExpectedValue = "expected1",
                        Field = "message",
                        Not = false,
                        Operation = "contains",
                    },
                },
                Type = "match-any-condition",
            },
        },
        Notifies = new[]
        {
            new Opsgenie.Inputs.TeamRoutingRuleNotifyArgs
            {
                Name = testSchedule.Name,
                Type = "schedule",
            },
        },
        Order = 0,
        TeamId = testTeam.Id,
        TimeRestrictions = new[]
        {
            new Opsgenie.Inputs.TeamRoutingRuleTimeRestrictionArgs
            {
                RestrictionList = new[]
                {
                    new Opsgenie.Inputs.TeamRoutingRuleTimeRestrictionRestrictionListArgs
                    {
                        EndDay = "tuesday",
                        EndHour = 18,
                        EndMin = 30,
                        StartDay = "monday",
                        StartHour = 8,
                        StartMin = 0,
                    },
                },
                Type = "weekday-and-time-of-day",
            },
        },
        Timezone = "America/Los_Angeles",
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		testSchedule, err := opsgenie.NewSchedule(ctx, "testSchedule", &opsgenie.ScheduleArgs{
			Description: pulumi.String("schedule test"),
			Enabled:     pulumi.Bool(false),
			Timezone:    pulumi.String("Europe/Rome"),
		})
		if err != nil {
			return err
		}
		testTeam, err := opsgenie.NewTeam(ctx, "testTeam", &opsgenie.TeamArgs{
			Description: pulumi.String("This team deals with all the things"),
		})
		if err != nil {
			return err
		}
		_, err = opsgenie.NewTeamRoutingRule(ctx, "testTeamRoutingRule", &opsgenie.TeamRoutingRuleArgs{
			Criterias: opsgenie.TeamRoutingRuleCriteriaArray{
				&opsgenie.TeamRoutingRuleCriteriaArgs{
					Conditions: opsgenie.TeamRoutingRuleCriteriaConditionArray{
						&opsgenie.TeamRoutingRuleCriteriaConditionArgs{
							ExpectedValue: pulumi.String("expected1"),
							Field:         pulumi.String("message"),
							Not:           pulumi.Bool(false),
							Operation:     pulumi.String("contains"),
						},
					},
					Type: pulumi.String("match-any-condition"),
				},
			},
			Notifies: opsgenie.TeamRoutingRuleNotifyArray{
				&opsgenie.TeamRoutingRuleNotifyArgs{
					Name: testSchedule.Name,
					Type: pulumi.String("schedule"),
				},
			},
			Order:  pulumi.Int(0),
			TeamId: testTeam.ID(),
			TimeRestrictions: opsgenie.TeamRoutingRuleTimeRestrictionArray{
				&opsgenie.TeamRoutingRuleTimeRestrictionArgs{
					RestrictionList: opsgenie.TeamRoutingRuleTimeRestrictionRestrictionListArray{
						&opsgenie.TeamRoutingRuleTimeRestrictionRestrictionListArgs{
							EndDay:    pulumi.String("tuesday"),
							EndHour:   pulumi.Int(18),
							EndMin:    pulumi.Int(30),
							StartDay:  pulumi.String("monday"),
							StartHour: pulumi.Int(8),
							StartMin:  pulumi.Int(0),
						},
					},
					Type: pulumi.String("weekday-and-time-of-day"),
				},
			},
			Timezone: pulumi.String("America/Los_Angeles"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.opsgenie.Schedule;
import com.pulumi.opsgenie.ScheduleArgs;
import com.pulumi.opsgenie.Team;
import com.pulumi.opsgenie.TeamArgs;
import com.pulumi.opsgenie.TeamRoutingRule;
import com.pulumi.opsgenie.TeamRoutingRuleArgs;
import com.pulumi.opsgenie.inputs.TeamRoutingRuleCriteriaArgs;
import com.pulumi.opsgenie.inputs.TeamRoutingRuleNotifyArgs;
import com.pulumi.opsgenie.inputs.TeamRoutingRuleTimeRestrictionArgs;
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 testSchedule = new Schedule("testSchedule", ScheduleArgs.builder()        
            .description("schedule test")
            .enabled(false)
            .timezone("Europe/Rome")
            .build());

        var testTeam = new Team("testTeam", TeamArgs.builder()        
            .description("This team deals with all the things")
            .build());

        var testTeamRoutingRule = new TeamRoutingRule("testTeamRoutingRule", TeamRoutingRuleArgs.builder()        
            .criterias(TeamRoutingRuleCriteriaArgs.builder()
                .conditions(TeamRoutingRuleCriteriaConditionArgs.builder()
                    .expectedValue("expected1")
                    .field("message")
                    .not(false)
                    .operation("contains")
                    .build())
                .type("match-any-condition")
                .build())
            .notifies(TeamRoutingRuleNotifyArgs.builder()
                .name(testSchedule.name())
                .type("schedule")
                .build())
            .order(0)
            .teamId(testTeam.id())
            .timeRestrictions(TeamRoutingRuleTimeRestrictionArgs.builder()
                .restrictionList(TeamRoutingRuleTimeRestrictionRestrictionListArgs.builder()
                    .endDay("tuesday")
                    .endHour(18)
                    .endMin(30)
                    .startDay("monday")
                    .startHour(8)
                    .startMin(0)
                    .build())
                .type("weekday-and-time-of-day")
                .build())
            .timezone("America/Los_Angeles")
            .build());

    }
}

import pulumi
import pulumi_opsgenie as opsgenie

test_schedule = opsgenie.Schedule("testSchedule",
    description="schedule test",
    enabled=False,
    timezone="Europe/Rome")
test_team = opsgenie.Team("testTeam", description="This team deals with all the things")
test_team_routing_rule = opsgenie.TeamRoutingRule("testTeamRoutingRule",
    criterias=[opsgenie.TeamRoutingRuleCriteriaArgs(
        conditions=[opsgenie.TeamRoutingRuleCriteriaConditionArgs(
            expected_value="expected1",
            field="message",
            not_=False,
            operation="contains",
        )],
        type="match-any-condition",
    )],
    notifies=[opsgenie.TeamRoutingRuleNotifyArgs(
        name=test_schedule.name,
        type="schedule",
    )],
    order=0,
    team_id=test_team.id,
    time_restrictions=[opsgenie.TeamRoutingRuleTimeRestrictionArgs(
        restriction_list=[opsgenie.TeamRoutingRuleTimeRestrictionRestrictionListArgs(
            end_day="tuesday",
            end_hour=18,
            end_min=30,
            start_day="monday",
            start_hour=8,
            start_min=0,
        )],
        type="weekday-and-time-of-day",
    )],
    timezone="America/Los_Angeles")

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

const testSchedule = new opsgenie.Schedule("testSchedule", {
    description: "schedule test",
    enabled: false,
    timezone: "Europe/Rome",
});
const testTeam = new opsgenie.Team("testTeam", {description: "This team deals with all the things"});
const testTeamRoutingRule = new opsgenie.TeamRoutingRule("testTeamRoutingRule", {
    criterias: [{
        conditions: [{
            expectedValue: "expected1",
            field: "message",
            not: false,
            operation: "contains",
        }],
        type: "match-any-condition",
    }],
    notifies: [{
        name: testSchedule.name,
        type: "schedule",
    }],
    order: 0,
    teamId: testTeam.id,
    timeRestrictions: [{
        restrictionList: [{
            endDay: "tuesday",
            endHour: 18,
            endMin: 30,
            startDay: "monday",
            startHour: 8,
            startMin: 0,
        }],
        type: "weekday-and-time-of-day",
    }],
    timezone: "America/Los_Angeles",
});

resources:
  testSchedule:
    type: opsgenie:Schedule
    properties:
      description: schedule test
      enabled: false
      timezone: Europe/Rome
  testTeam:
    type: opsgenie:Team
    properties:
      description: This team deals with all the things
  testTeamRoutingRule:
    type: opsgenie:TeamRoutingRule
    properties:
      criterias:
        - conditions:
            - expectedValue: expected1
              field: message
              not: false
              operation: contains
          type: match-any-condition
      notifies:
        - name: ${testSchedule.name}
          type: schedule
      order: 0
      teamId: ${testTeam.id}
      timeRestrictions:
        - restrictionList:
            - endDay: tuesday
              endHour: 18
              endMin: 30
              startDay: monday
              startHour: 8
              startMin: 0
          type: weekday-and-time-of-day
      timezone: America/Los_Angeles