incident.ScheduleSyncRule

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

// Create a sync target (Slack user group)
const platformOncall = new incident.ScheduleSyncTarget("platform_oncall", {
    addBotToGroup: true,
    newSlackUserGroup: {
        name: "Platform On-Call",
        handle: "platform-oncall",
        description: "Current on-call engineers for the Platform team",
    },
});
// Link a schedule to the sync target
// Only the current on-call engineer(s) will be synced to the user group
const platformOncallScheduleSyncRule = new incident.ScheduleSyncRule("platform_oncall", {
    scheduleId: platform.id,
    scheduleSyncTargetId: platformOncall.id,
    syncType: "on_call",
});
// Alternatively, sync all users in the rotation (not just who's on call)
const platformAllUsers = new incident.ScheduleSyncRule("platform_all_users", {
    scheduleId: platform.id,
    scheduleSyncTargetId: platformTeam.id,
    syncType: "all_users",
});
// Scope a rule to a single rotation. Without rotation_id a rule covers every
// rotation on the schedule; set it to sync only one. To feed a group from
// several rotations, create one rule per rotation pointing at the same target.
const platformEuOncall = new incident.ScheduleSyncRule("platform_eu_oncall", {
    scheduleId: platform.id,
    scheduleSyncTargetId: platformEuOncallIncidentScheduleSyncTarget.id,
    syncType: "on_call",
    rotationId: "eu",
});
// Keep a manager in the Slack user group regardless of who is on call.
// Omit permanent_member_user_ids to leave existing members unchanged on update;
// set it to [] to clear them.
const platformOncallWithManager = new incident.ScheduleSyncRule("platform_oncall_with_manager", {
    scheduleId: platform.id,
    scheduleSyncTargetId: platformOncall.id,
    syncType: "on_call",
    permanentMemberUserIds: [platformManager.id],
});

import pulumi
import pulumi_incident as incident

# Create a sync target (Slack user group)
platform_oncall = incident.ScheduleSyncTarget("platform_oncall",
    add_bot_to_group=True,
    new_slack_user_group={
        "name": "Platform On-Call",
        "handle": "platform-oncall",
        "description": "Current on-call engineers for the Platform team",
    })
# Link a schedule to the sync target
# Only the current on-call engineer(s) will be synced to the user group
platform_oncall_schedule_sync_rule = incident.ScheduleSyncRule("platform_oncall",
    schedule_id=platform["id"],
    schedule_sync_target_id=platform_oncall.id,
    sync_type="on_call")
# Alternatively, sync all users in the rotation (not just who's on call)
platform_all_users = incident.ScheduleSyncRule("platform_all_users",
    schedule_id=platform["id"],
    schedule_sync_target_id=platform_team["id"],
    sync_type="all_users")
# Scope a rule to a single rotation. Without rotation_id a rule covers every
# rotation on the schedule; set it to sync only one. To feed a group from
# several rotations, create one rule per rotation pointing at the same target.
platform_eu_oncall = incident.ScheduleSyncRule("platform_eu_oncall",
    schedule_id=platform["id"],
    schedule_sync_target_id=platform_eu_oncall_incident_schedule_sync_target["id"],
    sync_type="on_call",
    rotation_id="eu")
# Keep a manager in the Slack user group regardless of who is on call.
# Omit permanent_member_user_ids to leave existing members unchanged on update;
# set it to [] to clear them.
platform_oncall_with_manager = incident.ScheduleSyncRule("platform_oncall_with_manager",
    schedule_id=platform["id"],
    schedule_sync_target_id=platform_oncall.id,
    sync_type="on_call",
    permanent_member_user_ids=[platform_manager["id"]])

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/incident/v6/incident"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Create a sync target (Slack user group)
		platformOncall, err := incident.NewScheduleSyncTarget(ctx, "platform_oncall", &incident.ScheduleSyncTargetArgs{
			AddBotToGroup: pulumi.Bool(true),
			NewSlackUserGroup: &incident.ScheduleSyncTargetNewSlackUserGroupArgs{
				Name:        pulumi.String("Platform On-Call"),
				Handle:      pulumi.String("platform-oncall"),
				Description: pulumi.String("Current on-call engineers for the Platform team"),
			},
		})
		if err != nil {
			return err
		}
		// Link a schedule to the sync target
		// Only the current on-call engineer(s) will be synced to the user group
		_, err = incident.NewScheduleSyncRule(ctx, "platform_oncall", &incident.ScheduleSyncRuleArgs{
			ScheduleId:           pulumi.Any(platform.Id),
			ScheduleSyncTargetId: platformOncall.ID(),
			SyncType:             pulumi.String("on_call"),
		})
		if err != nil {
			return err
		}
		// Alternatively, sync all users in the rotation (not just who's on call)
		_, err = incident.NewScheduleSyncRule(ctx, "platform_all_users", &incident.ScheduleSyncRuleArgs{
			ScheduleId:           pulumi.Any(platform.Id),
			ScheduleSyncTargetId: pulumi.Any(platformTeam.Id),
			SyncType:             pulumi.String("all_users"),
		})
		if err != nil {
			return err
		}
		// Scope a rule to a single rotation. Without rotation_id a rule covers every
		// rotation on the schedule; set it to sync only one. To feed a group from
		// several rotations, create one rule per rotation pointing at the same target.
		_, err = incident.NewScheduleSyncRule(ctx, "platform_eu_oncall", &incident.ScheduleSyncRuleArgs{
			ScheduleId:           pulumi.Any(platform.Id),
			ScheduleSyncTargetId: pulumi.Any(platformEuOncallIncidentScheduleSyncTarget.Id),
			SyncType:             pulumi.String("on_call"),
			RotationId:           pulumi.String("eu"),
		})
		if err != nil {
			return err
		}
		// Keep a manager in the Slack user group regardless of who is on call.
		// Omit permanent_member_user_ids to leave existing members unchanged on update;
		// set it to [] to clear them.
		_, err = incident.NewScheduleSyncRule(ctx, "platform_oncall_with_manager", &incident.ScheduleSyncRuleArgs{
			ScheduleId:           pulumi.Any(platform.Id),
			ScheduleSyncTargetId: platformOncall.ID(),
			SyncType:             pulumi.String("on_call"),
			PermanentMemberUserIds: pulumi.StringArray{
				platformManager.Id,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Create a sync target (Slack user group)
    var platformOncall = new Incident.ScheduleSyncTarget("platform_oncall", new()
    {
        AddBotToGroup = true,
        NewSlackUserGroup = new Incident.Inputs.ScheduleSyncTargetNewSlackUserGroupArgs
        {
            Name = "Platform On-Call",
            Handle = "platform-oncall",
            Description = "Current on-call engineers for the Platform team",
        },
    });

    // Link a schedule to the sync target
    // Only the current on-call engineer(s) will be synced to the user group
    var platformOncallScheduleSyncRule = new Incident.ScheduleSyncRule("platform_oncall", new()
    {
        ScheduleId = platform.Id,
        ScheduleSyncTargetId = platformOncall.Id,
        SyncType = "on_call",
    });

    // Alternatively, sync all users in the rotation (not just who's on call)
    var platformAllUsers = new Incident.ScheduleSyncRule("platform_all_users", new()
    {
        ScheduleId = platform.Id,
        ScheduleSyncTargetId = platformTeam.Id,
        SyncType = "all_users",
    });

    // Scope a rule to a single rotation. Without rotation_id a rule covers every
    // rotation on the schedule; set it to sync only one. To feed a group from
    // several rotations, create one rule per rotation pointing at the same target.
    var platformEuOncall = new Incident.ScheduleSyncRule("platform_eu_oncall", new()
    {
        ScheduleId = platform.Id,
        ScheduleSyncTargetId = platformEuOncallIncidentScheduleSyncTarget.Id,
        SyncType = "on_call",
        RotationId = "eu",
    });

    // Keep a manager in the Slack user group regardless of who is on call.
    // Omit permanent_member_user_ids to leave existing members unchanged on update;
    // set it to [] to clear them.
    var platformOncallWithManager = new Incident.ScheduleSyncRule("platform_oncall_with_manager", new()
    {
        ScheduleId = platform.Id,
        ScheduleSyncTargetId = platformOncall.Id,
        SyncType = "on_call",
        PermanentMemberUserIds = new[]
        {
            platformManager.Id,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.incident.ScheduleSyncTarget;
import com.pulumi.incident.ScheduleSyncTargetArgs;
import com.pulumi.incident.inputs.ScheduleSyncTargetNewSlackUserGroupArgs;
import com.pulumi.incident.ScheduleSyncRule;
import com.pulumi.incident.ScheduleSyncRuleArgs;
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 sync target (Slack user group)
        var platformOncall = new ScheduleSyncTarget("platformOncall", ScheduleSyncTargetArgs.builder()
            .addBotToGroup(true)
            .newSlackUserGroup(ScheduleSyncTargetNewSlackUserGroupArgs.builder()
                .name("Platform On-Call")
                .handle("platform-oncall")
                .description("Current on-call engineers for the Platform team")
                .build())
            .build());

        // Link a schedule to the sync target
        // Only the current on-call engineer(s) will be synced to the user group
        var platformOncallScheduleSyncRule = new ScheduleSyncRule("platformOncallScheduleSyncRule", ScheduleSyncRuleArgs.builder()
            .scheduleId(platform.id())
            .scheduleSyncTargetId(platformOncall.id())
            .syncType("on_call")
            .build());

        // Alternatively, sync all users in the rotation (not just who's on call)
        var platformAllUsers = new ScheduleSyncRule("platformAllUsers", ScheduleSyncRuleArgs.builder()
            .scheduleId(platform.id())
            .scheduleSyncTargetId(platformTeam.id())
            .syncType("all_users")
            .build());

        // Scope a rule to a single rotation. Without rotation_id a rule covers every
        // rotation on the schedule; set it to sync only one. To feed a group from
        // several rotations, create one rule per rotation pointing at the same target.
        var platformEuOncall = new ScheduleSyncRule("platformEuOncall", ScheduleSyncRuleArgs.builder()
            .scheduleId(platform.id())
            .scheduleSyncTargetId(platformEuOncallIncidentScheduleSyncTarget.id())
            .syncType("on_call")
            .rotationId("eu")
            .build());

        // Keep a manager in the Slack user group regardless of who is on call.
        // Omit permanent_member_user_ids to leave existing members unchanged on update;
        // set it to [] to clear them.
        var platformOncallWithManager = new ScheduleSyncRule("platformOncallWithManager", ScheduleSyncRuleArgs.builder()
            .scheduleId(platform.id())
            .scheduleSyncTargetId(platformOncall.id())
            .syncType("on_call")
            .permanentMemberUserIds(platformManager.id())
            .build());

    }
}

resources:
  # Create a sync target (Slack user group)
  platformOncall:
    type: incident:ScheduleSyncTarget
    name: platform_oncall
    properties:
      addBotToGroup: true
      newSlackUserGroup:
        name: Platform On-Call
        handle: platform-oncall
        description: Current on-call engineers for the Platform team
  # Link a schedule to the sync target
  # Only the current on-call engineer(s) will be synced to the user group
  platformOncallScheduleSyncRule:
    type: incident:ScheduleSyncRule
    name: platform_oncall
    properties:
      scheduleId: ${platform.id}
      scheduleSyncTargetId: ${platformOncall.id}
      syncType: on_call
  # Alternatively, sync all users in the rotation (not just who's on call)
  platformAllUsers:
    type: incident:ScheduleSyncRule
    name: platform_all_users
    properties:
      scheduleId: ${platform.id}
      scheduleSyncTargetId: ${platformTeam.id}
      syncType: all_users
  # Scope a rule to a single rotation. Without rotation_id a rule covers every
  # rotation on the schedule; set it to sync only one. To feed a group from
  # several rotations, create one rule per rotation pointing at the same target.
  platformEuOncall:
    type: incident:ScheduleSyncRule
    name: platform_eu_oncall
    properties:
      scheduleId: ${platform.id}
      scheduleSyncTargetId: ${platformEuOncallIncidentScheduleSyncTarget.id}
      syncType: on_call
      rotationId: eu
  # Keep a manager in the Slack user group regardless of who is on call.
  # Omit permanent_member_user_ids to leave existing members unchanged on update;
  # set it to [] to clear them.
  platformOncallWithManager:
    type: incident:ScheduleSyncRule
    name: platform_oncall_with_manager
    properties:
      scheduleId: ${platform.id}
      scheduleSyncTargetId: ${platformOncall.id}
      syncType: on_call
      permanentMemberUserIds:
        - ${platformManager.id}

var scheduleSyncRuleResource = new Incident.ScheduleSyncRule("scheduleSyncRuleResource", new()
{
    ScheduleId = "string",
    ScheduleSyncTargetId = "string",
    SyncType = "string",
    PermanentMemberUserIds = new[]
    {
        "string",
    },
    RotationId = "string",
});

example, err := incident.NewScheduleSyncRule(ctx, "scheduleSyncRuleResource", &incident.ScheduleSyncRuleArgs{
	ScheduleId:           pulumi.String("string"),
	ScheduleSyncTargetId: pulumi.String("string"),
	SyncType:             pulumi.String("string"),
	PermanentMemberUserIds: pulumi.StringArray{
		pulumi.String("string"),
	},
	RotationId: pulumi.String("string"),
})

resource "incident_schedule_sync_rule" "scheduleSyncRuleResource" {
  lifecycle {
    create_before_destroy = true
  }
  schedule_id               = "string"
  schedule_sync_target_id   = "string"
  sync_type                 = "string"
  permanent_member_user_ids = ["string"]
  rotation_id               = "string"
}

var scheduleSyncRuleResource = new ScheduleSyncRule("scheduleSyncRuleResource", ScheduleSyncRuleArgs.builder()
    .scheduleId("string")
    .scheduleSyncTargetId("string")
    .syncType("string")
    .permanentMemberUserIds("string")
    .rotationId("string")
    .build());

schedule_sync_rule_resource = incident.ScheduleSyncRule("scheduleSyncRuleResource",
    schedule_id="string",
    schedule_sync_target_id="string",
    sync_type="string",
    permanent_member_user_ids=["string"],
    rotation_id="string")

const scheduleSyncRuleResource = new incident.ScheduleSyncRule("scheduleSyncRuleResource", {
    scheduleId: "string",
    scheduleSyncTargetId: "string",
    syncType: "string",
    permanentMemberUserIds: ["string"],
    rotationId: "string",
});

type: incident:ScheduleSyncRule
properties:
    permanentMemberUserIds:
        - string
    rotationId: string
    scheduleId: string
    scheduleSyncTargetId: string
    syncType: string