Sign in Dashboard Get started
  1. Registry
  2. Packages
  3. incident.io
  4. API Docs
  5. ScheduleSyncRule
Viewing docs for incident.io v0.4.1
published on Wednesday, Oct 21, 2026 by incident-io
Schema (JSON)
incident-io/pulumi-incident

incident.ScheduleSyncRule

incident logo incident.io
Viewing docs for incident.io v0.4.1
published on Wednesday, Oct 21, 2026 by incident-io
Schema (JSON)
incident-io/pulumi-incident

    Manage schedule sync rules that link schedules to sync targets (Slack user groups).

    Example Usage

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

// 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",
});
// Sync the people on the next upcoming shift, rather than whoever is on call now
const platformNextOncall = new incident.ScheduleSyncRule("platform_next_oncall", {
    scheduleId: platform.id,
    scheduleSyncTargetId: platformNextOncallIncidentScheduleSyncTarget.id,
    syncType: "next_on_call",
});
// 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")
# Sync the people on the next upcoming shift, rather than whoever is on call now
platform_next_oncall = incident.ScheduleSyncRule("platform_next_oncall",
    schedule_id=platform["id"],
    schedule_sync_target_id=platform_next_oncall_incident_schedule_sync_target["id"],
    sync_type="next_on_call")
# 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/incident-io/pulumi-incident/sdk/go/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().ToIDOutput().ToStringOutput(),
			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
		}
		// Sync the people on the next upcoming shift, rather than whoever is on call now
		_, err = incident.NewScheduleSyncRule(ctx, "platform_next_oncall", &incident.ScheduleSyncRuleArgs{
			ScheduleId:           pulumi.Any(platform.Id),
			ScheduleSyncTargetId: pulumi.Any(platformNextOncallIncidentScheduleSyncTarget.Id),
			SyncType:             pulumi.String("next_on_call"),
		})
		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().ToIDOutput().ToStringOutput(),
			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",
    });

    // Sync the people on the next upcoming shift, rather than whoever is on call now
    var platformNextOncall = new Incident.ScheduleSyncRule("platform_next_oncall", new()
    {
        ScheduleId = platform.Id,
        ScheduleSyncTargetId = platformNextOncallIncidentScheduleSyncTarget.Id,
        SyncType = "next_on_call",
    });

    // 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.ArrayList;
import java.util.Arrays;
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());

        // Sync the people on the next upcoming shift, rather than whoever is on call now
        var platformNextOncall = new ScheduleSyncRule("platformNextOncall", ScheduleSyncRuleArgs.builder()
            .scheduleId(platform.id())
            .scheduleSyncTargetId(platformNextOncallIncidentScheduleSyncTarget.id())
            .syncType("next_on_call")
            .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
  # Sync the people on the next upcoming shift, rather than whoever is on call now
  platformNextOncall:
    type: incident:ScheduleSyncRule
    name: platform_next_oncall
    properties:
      scheduleId: ${platform.id}
      scheduleSyncTargetId: ${platformNextOncallIncidentScheduleSyncTarget.id}
      syncType: next_on_call
  # 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}

    pulumi {
  required_providers {
    incident = {
      source = "pulumi/incident"
    }
  }
}

# Create a sync target (Slack user group)
resource "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
resource "incident_schedulesyncrule" "platform_oncall" {
  schedule_id             = platform.id
  schedule_sync_target_id = incident_schedulesynctarget.platform_oncall.id
  sync_type               = "on_call"
}
# Alternatively, sync all users in the rotation (not just who's on call)
resource "incident_schedulesyncrule" "platform_all_users" {
  schedule_id             = platform.id
  schedule_sync_target_id = platformTeam.id
  sync_type               = "all_users"
}
# Sync the people on the next upcoming shift, rather than whoever is on call now
resource "incident_schedulesyncrule" "platform_next_oncall" {
  schedule_id             = platform.id
  schedule_sync_target_id = platformNextOncallIncidentScheduleSyncTarget.id
  sync_type               = "next_on_call"
}
# 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.
resource "incident_schedulesyncrule" "platform_eu_oncall" {
  schedule_id             = platform.id
  schedule_sync_target_id = platformEuOncallIncidentScheduleSyncTarget.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.
resource "incident_schedulesyncrule" "platform_oncall_with_manager" {
  schedule_id               = platform.id
  schedule_sync_target_id   = incident_schedulesynctarget.platform_oncall.id
  sync_type                 = "on_call"
  permanent_member_user_ids = [platformManager.id]
}

    Create ScheduleSyncRule Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new ScheduleSyncRule(name: string, args: ScheduleSyncRuleArgs, opts?: CustomResourceOptions);
    @overload
def ScheduleSyncRule(resource_name: str,
                     args: ScheduleSyncRuleArgs,
                     opts: Optional[ResourceOptions] = None)

@overload
def ScheduleSyncRule(resource_name: str,
                     opts: Optional[ResourceOptions] = None,
                     schedule_id: Optional[str] = None,
                     schedule_sync_target_id: Optional[str] = None,
                     sync_type: Optional[str] = None,
                     permanent_member_user_ids: Optional[Sequence[str]] = None,
                     rotation_id: Optional[str] = None,
                     unlock_in_dashboard: Optional[bool] = None)
    func NewScheduleSyncRule(ctx *Context, name string, args ScheduleSyncRuleArgs, opts ...ResourceOption) (*ScheduleSyncRule, error)
    public ScheduleSyncRule(string name, ScheduleSyncRuleArgs args, CustomResourceOptions? opts = null)
    public ScheduleSyncRule(String name, ScheduleSyncRuleArgs args)
public ScheduleSyncRule(String name, ScheduleSyncRuleArgs args, CustomResourceOptions options)

    type: incident:ScheduleSyncRule
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.


    resource "incident_schedule_sync_rule" "name" {
    # resource properties
}

    Parameters

    name string
    The unique name of the resource.
    args ScheduleSyncRuleArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args ScheduleSyncRuleArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args ScheduleSyncRuleArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ScheduleSyncRuleArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ScheduleSyncRuleArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

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

    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"),
	UnlockInDashboard: pulumi.Bool(false),
})

    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"
  unlock_in_dashboard       = false
}

    var scheduleSyncRuleResource = new ScheduleSyncRule("scheduleSyncRuleResource", ScheduleSyncRuleArgs.builder()
    .scheduleId("string")
    .scheduleSyncTargetId("string")
    .syncType("string")
    .permanentMemberUserIds("string")
    .rotationId("string")
    .unlockInDashboard(false)
    .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",
    unlock_in_dashboard=False)

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

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

    ScheduleSyncRule Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The ScheduleSyncRule resource accepts the following input properties:

    ScheduleId string
    The schedule this rule belongs to
    ScheduleSyncTargetId string
    The sync target ID this rule links to
    SyncType string
    Which schedule members sync to the user group. Possible values are: onCall, allUsers, nextOnCall.
    PermanentMemberUserIds List<string>
    IDs of users always kept in the Slack user group, regardless of who is on call. Useful for keeping e.g. a manager in the group so they see mentions without being paged. Scoped to this rule: when several rules feed the same group, we sync the union of their permanent members.
    RotationId string
    If set, only members of this rotation sync to the user group. When unset, all rotations on the schedule are synced.
    UnlockInDashboard bool
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    ScheduleId string
    The schedule this rule belongs to
    ScheduleSyncTargetId string
    The sync target ID this rule links to
    SyncType string
    Which schedule members sync to the user group. Possible values are: onCall, allUsers, nextOnCall.
    PermanentMemberUserIds []string
    IDs of users always kept in the Slack user group, regardless of who is on call. Useful for keeping e.g. a manager in the group so they see mentions without being paged. Scoped to this rule: when several rules feed the same group, we sync the union of their permanent members.
    RotationId string
    If set, only members of this rotation sync to the user group. When unset, all rotations on the schedule are synced.
    UnlockInDashboard bool
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    schedule_id string
    The schedule this rule belongs to
    schedule_sync_target_id string
    The sync target ID this rule links to
    sync_type string
    Which schedule members sync to the user group. Possible values are: onCall, allUsers, nextOnCall.
    permanent_member_user_ids list(string)
    IDs of users always kept in the Slack user group, regardless of who is on call. Useful for keeping e.g. a manager in the group so they see mentions without being paged. Scoped to this rule: when several rules feed the same group, we sync the union of their permanent members.
    rotation_id string
    If set, only members of this rotation sync to the user group. When unset, all rotations on the schedule are synced.
    unlock_in_dashboard bool
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    scheduleId String
    The schedule this rule belongs to
    scheduleSyncTargetId String
    The sync target ID this rule links to
    syncType String
    Which schedule members sync to the user group. Possible values are: onCall, allUsers, nextOnCall.
    permanentMemberUserIds List<String>
    IDs of users always kept in the Slack user group, regardless of who is on call. Useful for keeping e.g. a manager in the group so they see mentions without being paged. Scoped to this rule: when several rules feed the same group, we sync the union of their permanent members.
    rotationId String
    If set, only members of this rotation sync to the user group. When unset, all rotations on the schedule are synced.
    unlockInDashboard Boolean
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    scheduleId string
    The schedule this rule belongs to
    scheduleSyncTargetId string
    The sync target ID this rule links to
    syncType string
    Which schedule members sync to the user group. Possible values are: onCall, allUsers, nextOnCall.
    permanentMemberUserIds string[]
    IDs of users always kept in the Slack user group, regardless of who is on call. Useful for keeping e.g. a manager in the group so they see mentions without being paged. Scoped to this rule: when several rules feed the same group, we sync the union of their permanent members.
    rotationId string
    If set, only members of this rotation sync to the user group. When unset, all rotations on the schedule are synced.
    unlockInDashboard boolean
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    schedule_id str
    The schedule this rule belongs to
    schedule_sync_target_id str
    The sync target ID this rule links to
    sync_type str
    Which schedule members sync to the user group. Possible values are: onCall, allUsers, nextOnCall.
    permanent_member_user_ids Sequence[str]
    IDs of users always kept in the Slack user group, regardless of who is on call. Useful for keeping e.g. a manager in the group so they see mentions without being paged. Scoped to this rule: when several rules feed the same group, we sync the union of their permanent members.
    rotation_id str
    If set, only members of this rotation sync to the user group. When unset, all rotations on the schedule are synced.
    unlock_in_dashboard bool
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    scheduleId String
    The schedule this rule belongs to
    scheduleSyncTargetId String
    The sync target ID this rule links to
    syncType String
    Which schedule members sync to the user group. Possible values are: onCall, allUsers, nextOnCall.
    permanentMemberUserIds List<String>
    IDs of users always kept in the Slack user group, regardless of who is on call. Useful for keeping e.g. a manager in the group so they see mentions without being paged. Scoped to this rule: when several rules feed the same group, we sync the union of their permanent members.
    rotationId String
    If set, only members of this rotation sync to the user group. When unset, all rotations on the schedule are synced.
    unlockInDashboard Boolean
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the ScheduleSyncRule resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing ScheduleSyncRule Resource

    Get an existing ScheduleSyncRule resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: ScheduleSyncRuleState, opts?: CustomResourceOptions): ScheduleSyncRule
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        permanent_member_user_ids: Optional[Sequence[str]] = None,
        rotation_id: Optional[str] = None,
        schedule_id: Optional[str] = None,
        schedule_sync_target_id: Optional[str] = None,
        sync_type: Optional[str] = None,
        unlock_in_dashboard: Optional[bool] = None) -> ScheduleSyncRule
    func GetScheduleSyncRule(ctx *Context, name string, id IDInput, state *ScheduleSyncRuleState, opts ...ResourceOption) (*ScheduleSyncRule, error)
    public static ScheduleSyncRule Get(string name, Input<string> id, ScheduleSyncRuleState? state, CustomResourceOptions? opts = null)
    public static ScheduleSyncRule get(String name, Output<String> id, ScheduleSyncRuleState state, CustomResourceOptions options)
    resources:  _:    type: incident:ScheduleSyncRule    get:      id: ${id}
    import {
  to = incident_schedule_sync_rule.example
  id = "${id}"
}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    PermanentMemberUserIds List<string>
    IDs of users always kept in the Slack user group, regardless of who is on call. Useful for keeping e.g. a manager in the group so they see mentions without being paged. Scoped to this rule: when several rules feed the same group, we sync the union of their permanent members.
    RotationId string
    If set, only members of this rotation sync to the user group. When unset, all rotations on the schedule are synced.
    ScheduleId string
    The schedule this rule belongs to
    ScheduleSyncTargetId string
    The sync target ID this rule links to
    SyncType string
    Which schedule members sync to the user group. Possible values are: onCall, allUsers, nextOnCall.
    UnlockInDashboard bool
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    PermanentMemberUserIds []string
    IDs of users always kept in the Slack user group, regardless of who is on call. Useful for keeping e.g. a manager in the group so they see mentions without being paged. Scoped to this rule: when several rules feed the same group, we sync the union of their permanent members.
    RotationId string
    If set, only members of this rotation sync to the user group. When unset, all rotations on the schedule are synced.
    ScheduleId string
    The schedule this rule belongs to
    ScheduleSyncTargetId string
    The sync target ID this rule links to
    SyncType string
    Which schedule members sync to the user group. Possible values are: onCall, allUsers, nextOnCall.
    UnlockInDashboard bool
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    permanent_member_user_ids list(string)
    IDs of users always kept in the Slack user group, regardless of who is on call. Useful for keeping e.g. a manager in the group so they see mentions without being paged. Scoped to this rule: when several rules feed the same group, we sync the union of their permanent members.
    rotation_id string
    If set, only members of this rotation sync to the user group. When unset, all rotations on the schedule are synced.
    schedule_id string
    The schedule this rule belongs to
    schedule_sync_target_id string
    The sync target ID this rule links to
    sync_type string
    Which schedule members sync to the user group. Possible values are: onCall, allUsers, nextOnCall.
    unlock_in_dashboard bool
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    permanentMemberUserIds List<String>
    IDs of users always kept in the Slack user group, regardless of who is on call. Useful for keeping e.g. a manager in the group so they see mentions without being paged. Scoped to this rule: when several rules feed the same group, we sync the union of their permanent members.
    rotationId String
    If set, only members of this rotation sync to the user group. When unset, all rotations on the schedule are synced.
    scheduleId String
    The schedule this rule belongs to
    scheduleSyncTargetId String
    The sync target ID this rule links to
    syncType String
    Which schedule members sync to the user group. Possible values are: onCall, allUsers, nextOnCall.
    unlockInDashboard Boolean
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    permanentMemberUserIds string[]
    IDs of users always kept in the Slack user group, regardless of who is on call. Useful for keeping e.g. a manager in the group so they see mentions without being paged. Scoped to this rule: when several rules feed the same group, we sync the union of their permanent members.
    rotationId string
    If set, only members of this rotation sync to the user group. When unset, all rotations on the schedule are synced.
    scheduleId string
    The schedule this rule belongs to
    scheduleSyncTargetId string
    The sync target ID this rule links to
    syncType string
    Which schedule members sync to the user group. Possible values are: onCall, allUsers, nextOnCall.
    unlockInDashboard boolean
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    permanent_member_user_ids Sequence[str]
    IDs of users always kept in the Slack user group, regardless of who is on call. Useful for keeping e.g. a manager in the group so they see mentions without being paged. Scoped to this rule: when several rules feed the same group, we sync the union of their permanent members.
    rotation_id str
    If set, only members of this rotation sync to the user group. When unset, all rotations on the schedule are synced.
    schedule_id str
    The schedule this rule belongs to
    schedule_sync_target_id str
    The sync target ID this rule links to
    sync_type str
    Which schedule members sync to the user group. Possible values are: onCall, allUsers, nextOnCall.
    unlock_in_dashboard bool
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.
    permanentMemberUserIds List<String>
    IDs of users always kept in the Slack user group, regardless of who is on call. Useful for keeping e.g. a manager in the group so they see mentions without being paged. Scoped to this rule: when several rules feed the same group, we sync the union of their permanent members.
    rotationId String
    If set, only members of this rotation sync to the user group. When unset, all rotations on the schedule are synced.
    scheduleId String
    The schedule this rule belongs to
    scheduleSyncTargetId String
    The sync target ID this rule links to
    syncType String
    Which schedule members sync to the user group. Possible values are: onCall, allUsers, nextOnCall.
    unlockInDashboard Boolean
    Whether to leave this resource unlocked in the incident.io dashboard, so people can edit it there. Defaults to false: Terraform claims what it manages, and a claimed resource cannot be edited in the dashboard. Set it to true to leave the resource unclaimed — pair that with lifecycle { ignoreChanges = [...] } naming the attributes people edit, or the next apply reverts them. Setting it on a resource Terraform already claimed hands that resource back, and someone disconnecting one in the dashboard shows as no change.

    Package Details

    Repository
    incident incident-io/pulumi-incident
    License
    MIT
    Notes
    This Pulumi package is based on the incident Terraform Provider.
    incident logo incident.io
    Viewing docs for incident.io v0.4.1
    published on Wednesday, Oct 21, 2026 by incident-io
    Schema (JSON)
    incident-io/pulumi-incident

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial