ScheduleRotation

incident 7.0.0, Sep 11 26

Viewing docs for incident 7.0.0
published on Friday, Sep 11, 2026 by incident-io

Changing when shifts hand over

first_interval_starts_at is the point intervals are counted from. With handovers it fixes the time of day and day of week that shifts change hands — the dashboard calls it the handover time.

It can’t change in the same apply as rollout. Whenever rollout is set the rotation keeps the interval start it already runs: an immediate rollout copies that across so the cadence doesn’t move, and a phased one works backwards from the next handover so the new line-up slots into the rhythm people are already working. Either way a new first_interval_starts_at is discarded, so the provider stops the apply rather than storing a value that won’t be kept.

To change both, take it in two applies:

Change first_interval_starts_at on its own, with rollout unset. The new cadence takes effect straight away.
Then make the line-up change, with rollout set.

Choosing a scheduling mode

scheduling_mode decides who takes the next shift.

fair shares time on call out evenly, tracking how much each person has already done and giving the next shift to whoever is behind. Someone newly added has done none, so fair tends to bring them on call sooner rather than adding them to the back of the queue.

sequential goes around the list in order, so the next person on call is always the one after the last.

For an even rotation — everyone on for the same length of time, no working hours, nobody joining or leaving — the two behave identically. They only diverge once shifts differ in length, working_intervals is set, or the list of users changes. Reach for sequential when it matters that the running order is obvious to the people in it.

Upgrading from v6

Before v7, a rotation was declared inline on incident.Schedule, in its rotations attribute. It is now its own resource. See incident.Schedule for what that changes and how to import the rotations you already have.

Example Usage

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

// A rotation is a group of people who take turns being on call. Each one is managed
// on its own, so editing this rotation doesn't touch the others on the schedule.
const primary = new incident.ScheduleRotation("primary", {
    scheduleId: platform.id,
    name: "Primary",
    users: [
        alice.id,
        bob.id,
    ],
    firstIntervalStartsAt: "2024-01-08T09:00:00Z",
    handovers: [{
        interval: 1,
        intervalType: "weekly",
    }],
});
// A rotation that only covers weekday working hours, with two people on call at
// once and a place in the schedule's running order.
const businessHours = new incident.ScheduleRotation("business_hours", {
    scheduleId: platform.id,
    name: "Business hours",
    rank: 2,
    users: [
        alice.id,
        bob.id,
        carol.id,
    ],
    firstIntervalStartsAt: "2024-01-08T09:00:00Z",
    handovers: [{
        interval: 1,
        intervalType: "daily",
    }],
    concurrentShifts: 2,
    workingIntervals: [
        {
            weekday: "monday",
            startTime: "09:00",
            endTime: "17:00",
        },
        {
            weekday: "tuesday",
            startTime: "09:00",
            endTime: "17:00",
        },
        {
            weekday: "wednesday",
            startTime: "09:00",
            endTime: "17:00",
        },
        {
            weekday: "thursday",
            startTime: "09:00",
            endTime: "17:00",
        },
        {
            weekday: "friday",
            startTime: "09:00",
            endTime: "17:00",
        },
    ],
});

import pulumi
import pulumi_incident as incident

# A rotation is a group of people who take turns being on call. Each one is managed
# on its own, so editing this rotation doesn't touch the others on the schedule.
primary = incident.ScheduleRotation("primary",
    schedule_id=platform["id"],
    name="Primary",
    users=[
        alice["id"],
        bob["id"],
    ],
    first_interval_starts_at="2024-01-08T09:00:00Z",
    handovers=[{
        "interval": 1,
        "interval_type": "weekly",
    }])
# A rotation that only covers weekday working hours, with two people on call at
# once and a place in the schedule's running order.
business_hours = incident.ScheduleRotation("business_hours",
    schedule_id=platform["id"],
    name="Business hours",
    rank=2,
    users=[
        alice["id"],
        bob["id"],
        carol["id"],
    ],
    first_interval_starts_at="2024-01-08T09:00:00Z",
    handovers=[{
        "interval": 1,
        "interval_type": "daily",
    }],
    concurrent_shifts=2,
    working_intervals=[
        {
            "weekday": "monday",
            "start_time": "09:00",
            "end_time": "17:00",
        },
        {
            "weekday": "tuesday",
            "start_time": "09:00",
            "end_time": "17:00",
        },
        {
            "weekday": "wednesday",
            "start_time": "09:00",
            "end_time": "17:00",
        },
        {
            "weekday": "thursday",
            "start_time": "09:00",
            "end_time": "17:00",
        },
        {
            "weekday": "friday",
            "start_time": "09:00",
            "end_time": "17:00",
        },
    ])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// A rotation is a group of people who take turns being on call. Each one is managed
		// on its own, so editing this rotation doesn't touch the others on the schedule.
		_, err := incident.NewScheduleRotation(ctx, "primary", &incident.ScheduleRotationArgs{
			ScheduleId: pulumi.Any(platform.Id),
			Name:       pulumi.String("Primary"),
			Users: pulumi.StringArray{
				alice.Id,
				bob.Id,
			},
			FirstIntervalStartsAt: pulumi.String("2024-01-08T09:00:00Z"),
			Handovers: incident.ScheduleRotationHandoverArray{
				&incident.ScheduleRotationHandoverArgs{
					Interval:     pulumi.Float64(1),
					IntervalType: pulumi.String("weekly"),
				},
			},
		})
		if err != nil {
			return err
		}
		// A rotation that only covers weekday working hours, with two people on call at
		// once and a place in the schedule's running order.
		_, err = incident.NewScheduleRotation(ctx, "business_hours", &incident.ScheduleRotationArgs{
			ScheduleId: pulumi.Any(platform.Id),
			Name:       pulumi.String("Business hours"),
			Rank:       pulumi.Float64(2),
			Users: pulumi.StringArray{
				alice.Id,
				bob.Id,
				carol.Id,
			},
			FirstIntervalStartsAt: pulumi.String("2024-01-08T09:00:00Z"),
			Handovers: incident.ScheduleRotationHandoverArray{
				&incident.ScheduleRotationHandoverArgs{
					Interval:     pulumi.Float64(1),
					IntervalType: pulumi.String("daily"),
				},
			},
			ConcurrentShifts: pulumi.Float64(2),
			WorkingIntervals: incident.ScheduleRotationWorkingIntervalArray{
				&incident.ScheduleRotationWorkingIntervalArgs{
					Weekday:   pulumi.String("monday"),
					StartTime: pulumi.String("09:00"),
					EndTime:   pulumi.String("17:00"),
				},
				&incident.ScheduleRotationWorkingIntervalArgs{
					Weekday:   pulumi.String("tuesday"),
					StartTime: pulumi.String("09:00"),
					EndTime:   pulumi.String("17:00"),
				},
				&incident.ScheduleRotationWorkingIntervalArgs{
					Weekday:   pulumi.String("wednesday"),
					StartTime: pulumi.String("09:00"),
					EndTime:   pulumi.String("17:00"),
				},
				&incident.ScheduleRotationWorkingIntervalArgs{
					Weekday:   pulumi.String("thursday"),
					StartTime: pulumi.String("09:00"),
					EndTime:   pulumi.String("17:00"),
				},
				&incident.ScheduleRotationWorkingIntervalArgs{
					Weekday:   pulumi.String("friday"),
					StartTime: pulumi.String("09:00"),
					EndTime:   pulumi.String("17:00"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // A rotation is a group of people who take turns being on call. Each one is managed
    // on its own, so editing this rotation doesn't touch the others on the schedule.
    var primary = new Incident.ScheduleRotation("primary", new()
    {
        ScheduleId = platform.Id,
        Name = "Primary",
        Users = new[]
        {
            alice.Id,
            bob.Id,
        },
        FirstIntervalStartsAt = "2024-01-08T09:00:00Z",
        Handovers = new[]
        {
            new Incident.Inputs.ScheduleRotationHandoverArgs
            {
                Interval = 1,
                IntervalType = "weekly",
            },
        },
    });

    // A rotation that only covers weekday working hours, with two people on call at
    // once and a place in the schedule's running order.
    var businessHours = new Incident.ScheduleRotation("business_hours", new()
    {
        ScheduleId = platform.Id,
        Name = "Business hours",
        Rank = 2,
        Users = new[]
        {
            alice.Id,
            bob.Id,
            carol.Id,
        },
        FirstIntervalStartsAt = "2024-01-08T09:00:00Z",
        Handovers = new[]
        {
            new Incident.Inputs.ScheduleRotationHandoverArgs
            {
                Interval = 1,
                IntervalType = "daily",
            },
        },
        ConcurrentShifts = 2,
        WorkingIntervals = new[]
        {
            new Incident.Inputs.ScheduleRotationWorkingIntervalArgs
            {
                Weekday = "monday",
                StartTime = "09:00",
                EndTime = "17:00",
            },
            new Incident.Inputs.ScheduleRotationWorkingIntervalArgs
            {
                Weekday = "tuesday",
                StartTime = "09:00",
                EndTime = "17:00",
            },
            new Incident.Inputs.ScheduleRotationWorkingIntervalArgs
            {
                Weekday = "wednesday",
                StartTime = "09:00",
                EndTime = "17:00",
            },
            new Incident.Inputs.ScheduleRotationWorkingIntervalArgs
            {
                Weekday = "thursday",
                StartTime = "09:00",
                EndTime = "17:00",
            },
            new Incident.Inputs.ScheduleRotationWorkingIntervalArgs
            {
                Weekday = "friday",
                StartTime = "09:00",
                EndTime = "17:00",
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.incident.ScheduleRotation;
import com.pulumi.incident.ScheduleRotationArgs;
import com.pulumi.incident.inputs.ScheduleRotationHandoverArgs;
import com.pulumi.incident.inputs.ScheduleRotationWorkingIntervalArgs;
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) {
        // A rotation is a group of people who take turns being on call. Each one is managed
        // on its own, so editing this rotation doesn't touch the others on the schedule.
        var primary = new ScheduleRotation("primary", ScheduleRotationArgs.builder()
            .scheduleId(platform.id())
            .name("Primary")
            .users(            
                alice.id(),
                bob.id())
            .firstIntervalStartsAt("2024-01-08T09:00:00Z")
            .handovers(ScheduleRotationHandoverArgs.builder()
                .interval(1.0)
                .intervalType("weekly")
                .build())
            .build());

        // A rotation that only covers weekday working hours, with two people on call at
        // once and a place in the schedule's running order.
        var businessHours = new ScheduleRotation("businessHours", ScheduleRotationArgs.builder()
            .scheduleId(platform.id())
            .name("Business hours")
            .rank(2.0)
            .users(            
                alice.id(),
                bob.id(),
                carol.id())
            .firstIntervalStartsAt("2024-01-08T09:00:00Z")
            .handovers(ScheduleRotationHandoverArgs.builder()
                .interval(1.0)
                .intervalType("daily")
                .build())
            .concurrentShifts(2.0)
            .workingIntervals(            
                ScheduleRotationWorkingIntervalArgs.builder()
                    .weekday("monday")
                    .startTime("09:00")
                    .endTime("17:00")
                    .build(),
                ScheduleRotationWorkingIntervalArgs.builder()
                    .weekday("tuesday")
                    .startTime("09:00")
                    .endTime("17:00")
                    .build(),
                ScheduleRotationWorkingIntervalArgs.builder()
                    .weekday("wednesday")
                    .startTime("09:00")
                    .endTime("17:00")
                    .build(),
                ScheduleRotationWorkingIntervalArgs.builder()
                    .weekday("thursday")
                    .startTime("09:00")
                    .endTime("17:00")
                    .build(),
                ScheduleRotationWorkingIntervalArgs.builder()
                    .weekday("friday")
                    .startTime("09:00")
                    .endTime("17:00")
                    .build())
            .build());

    }
}

resources:
  # A rotation is a group of people who take turns being on call. Each one is managed
  # on its own, so editing this rotation doesn't touch the others on the schedule.
  primary:
    type: incident:ScheduleRotation
    properties:
      scheduleId: ${platform.id}
      name: Primary
      users:
        - ${alice.id}
        - ${bob.id}
      firstIntervalStartsAt: 2024-01-08T09:00:00Z
      handovers: # concurrent_shifts is omitted, so one person is on call at a time.
        - interval: 1
          intervalType: weekly
  # A rotation that only covers weekday working hours, with two people on call at
  # once and a place in the schedule's running order.
  businessHours:
    type: incident:ScheduleRotation
    name: business_hours
    properties:
      scheduleId: ${platform.id}
      name: Business hours
      rank: 2
      users:
        - ${alice.id}
        - ${bob.id}
        - ${carol.id}
      firstIntervalStartsAt: 2024-01-08T09:00:00Z
      handovers:
        - interval: 1
          intervalType: daily
      concurrentShifts: 2 # Omit this to keep the rotation on call around the clock. An empty list isn't a
      #   # way to say that.
      workingIntervals:
        - weekday: monday
          startTime: 09:00
          endTime: 17:00
        - weekday: tuesday
          startTime: 09:00
          endTime: 17:00
        - weekday: wednesday
          startTime: 09:00
          endTime: 17:00
        - weekday: thursday
          startTime: 09:00
          endTime: 17:00
        - weekday: friday
          startTime: 09:00
          endTime: 17:00

Example coming soon!

Create ScheduleRotation Resource

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

Constructor syntax

new ScheduleRotation(name: string, args: ScheduleRotationArgs, opts?: CustomResourceOptions);

@overload
def ScheduleRotation(resource_name: str,
                     args: ScheduleRotationArgs,
                     opts: Optional[ResourceOptions] = None)

@overload
def ScheduleRotation(resource_name: str,
                     opts: Optional[ResourceOptions] = None,
                     first_interval_starts_at: Optional[str] = None,
                     handovers: Optional[Sequence[ScheduleRotationHandoverArgs]] = None,
                     schedule_id: Optional[str] = None,
                     users: Optional[Sequence[str]] = None,
                     concurrent_shifts: Optional[float] = None,
                     name: Optional[str] = None,
                     rank: Optional[float] = None,
                     rollout: Optional[str] = None,
                     scheduling_mode: Optional[str] = None,
                     working_intervals: Optional[Sequence[ScheduleRotationWorkingIntervalArgs]] = None)

func NewScheduleRotation(ctx *Context, name string, args ScheduleRotationArgs, opts ...ResourceOption) (*ScheduleRotation, error)

public ScheduleRotation(string name, ScheduleRotationArgs args, CustomResourceOptions? opts = null)

public ScheduleRotation(String name, ScheduleRotationArgs args)
public ScheduleRotation(String name, ScheduleRotationArgs args, CustomResourceOptions options)

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

resource "incident_schedule_rotation" "name" {
    # resource properties
}

Parameters

name string: The unique name of the resource.
args ScheduleRotationArgs: 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 ScheduleRotationArgs: 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 ScheduleRotationArgs: The arguments to resource properties.
opts ResourceOption: Bag of options to control resource's behavior.

name string: The unique name of the resource.
args ScheduleRotationArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

name String: The unique name of the resource.
args ScheduleRotationArgs: 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 scheduleRotationResource = new Incident.ScheduleRotation("scheduleRotationResource", new()
{
    FirstIntervalStartsAt = "string",
    Handovers = new[]
    {
        new Incident.Inputs.ScheduleRotationHandoverArgs
        {
            Interval = 0.0,
            IntervalType = "string",
        },
    },
    ScheduleId = "string",
    Users = new[]
    {
        "string",
    },
    ConcurrentShifts = 0.0,
    Name = "string",
    Rank = 0.0,
    Rollout = "string",
    SchedulingMode = "string",
    WorkingIntervals = new[]
    {
        new Incident.Inputs.ScheduleRotationWorkingIntervalArgs
        {
            EndTime = "string",
            StartTime = "string",
            Weekday = "string",
        },
    },
});

example, err := incident.NewScheduleRotation(ctx, "scheduleRotationResource", &incident.ScheduleRotationArgs{
	FirstIntervalStartsAt: pulumi.String("string"),
	Handovers: incident.ScheduleRotationHandoverArray{
		&incident.ScheduleRotationHandoverArgs{
			Interval:     pulumi.Float64(0),
			IntervalType: pulumi.String("string"),
		},
	},
	ScheduleId: pulumi.String("string"),
	Users: pulumi.StringArray{
		pulumi.String("string"),
	},
	ConcurrentShifts: pulumi.Float64(0),
	Name:             pulumi.String("string"),
	Rank:             pulumi.Float64(0),
	Rollout:          pulumi.String("string"),
	SchedulingMode:   pulumi.String("string"),
	WorkingIntervals: incident.ScheduleRotationWorkingIntervalArray{
		&incident.ScheduleRotationWorkingIntervalArgs{
			EndTime:   pulumi.String("string"),
			StartTime: pulumi.String("string"),
			Weekday:   pulumi.String("string"),
		},
	},
})

resource "incident_schedule_rotation" "scheduleRotationResource" {
  lifecycle {
    create_before_destroy = true
  }
  first_interval_starts_at = "string"
  handovers {
    interval      = 0
    interval_type = "string"
  }
  schedule_id       = "string"
  users             = ["string"]
  concurrent_shifts = 0
  name              = "string"
  rank              = 0
  rollout           = "string"
  scheduling_mode   = "string"
  working_intervals {
    end_time   = "string"
    start_time = "string"
    weekday    = "string"
  }
}

var scheduleRotationResource = new ScheduleRotation("scheduleRotationResource", ScheduleRotationArgs.builder()
    .firstIntervalStartsAt("string")
    .handovers(ScheduleRotationHandoverArgs.builder()
        .interval(0.0)
        .intervalType("string")
        .build())
    .scheduleId("string")
    .users("string")
    .concurrentShifts(0.0)
    .name("string")
    .rank(0.0)
    .rollout("string")
    .schedulingMode("string")
    .workingIntervals(ScheduleRotationWorkingIntervalArgs.builder()
        .endTime("string")
        .startTime("string")
        .weekday("string")
        .build())
    .build());

schedule_rotation_resource = incident.ScheduleRotation("scheduleRotationResource",
    first_interval_starts_at="string",
    handovers=[{
        "interval": float(0),
        "interval_type": "string",
    }],
    schedule_id="string",
    users=["string"],
    concurrent_shifts=float(0),
    name="string",
    rank=float(0),
    rollout="string",
    scheduling_mode="string",
    working_intervals=[{
        "end_time": "string",
        "start_time": "string",
        "weekday": "string",
    }])

const scheduleRotationResource = new incident.ScheduleRotation("scheduleRotationResource", {
    firstIntervalStartsAt: "string",
    handovers: [{
        interval: 0,
        intervalType: "string",
    }],
    scheduleId: "string",
    users: ["string"],
    concurrentShifts: 0,
    name: "string",
    rank: 0,
    rollout: "string",
    schedulingMode: "string",
    workingIntervals: [{
        endTime: "string",
        startTime: "string",
        weekday: "string",
    }],
});

type: incident:ScheduleRotation
properties:
    concurrentShifts: 0
    firstIntervalStartsAt: string
    handovers:
        - interval: 0
          intervalType: string
    name: string
    rank: 0
    rollout: string
    scheduleId: string
    schedulingMode: string
    users:
        - string
    workingIntervals:
        - endTime: string
          startTime: string
          weekday: string

ScheduleRotation 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 ScheduleRotation resource accepts the following input properties:

FirstIntervalStartsAt string: When the first handover interval starts being counted from, which fixes the time of day and day of week shifts change hands. The dashboard calls this the handover time.. Can't be changed in the same apply as rollout — see the resource description for why, and what to do instead.
Handovers List<ScheduleRotationHandover>: The cadence shifts hand over on, applied in turn
ScheduleId string: ID of the schedule this rotation belongs to. Changing this replaces the rotation, as a rotation can't move between schedules.
Users List<string>: IDs of the people in the rotation, in the order they take shifts. Use the special ID NOBODY for a slot with nobody in it, which schedules the shift without putting anyone on call until an override covers it.
ConcurrentShifts double: How many shifts run at the same time, which is how many people are on call at once. Defaults to 1, one person on call at a time. Reducing this stops scheduling the last of them, and stops any overrides on those shifts from applying.
Name string: Human readable name for the rotation, unique within the schedule
Rank double: Where this rotation sits in the schedule's running order, lowest first. Unset when it has never been ordered.
Rollout string: How a change to this rotation is introduced: immediate replaces the line-up now and can change who is on call this minute, after_current_shift lets the shift on call finish first, and after_full_rotation waits for everyone to have taken a turn. Leave it out to replace the line-up straight away. Creating a rotation ignores it, as there's no shift to protect yet.
SchedulingMode string: How users are allocated across shifts of differing length. Possible values are: fair, sequential. Omit it to leave us to pick. For an even rotation the two behave identically — see the resource description for when they diverge.
WorkingIntervals List<ScheduleRotationWorkingInterval>: If set, restricts on-call to these weekday intervals. Omit it to keep the rotation on call around the clock. An empty list is not valid, and is rejected at plan time — it would leave a rotation nobody is ever on call for.

FirstIntervalStartsAt string: When the first handover interval starts being counted from, which fixes the time of day and day of week shifts change hands. The dashboard calls this the handover time.. Can't be changed in the same apply as rollout — see the resource description for why, and what to do instead.
Handovers []ScheduleRotationHandoverArgs: The cadence shifts hand over on, applied in turn
ScheduleId string: ID of the schedule this rotation belongs to. Changing this replaces the rotation, as a rotation can't move between schedules.
Users []string: IDs of the people in the rotation, in the order they take shifts. Use the special ID NOBODY for a slot with nobody in it, which schedules the shift without putting anyone on call until an override covers it.
ConcurrentShifts float64: How many shifts run at the same time, which is how many people are on call at once. Defaults to 1, one person on call at a time. Reducing this stops scheduling the last of them, and stops any overrides on those shifts from applying.
Name string: Human readable name for the rotation, unique within the schedule
Rank float64: Where this rotation sits in the schedule's running order, lowest first. Unset when it has never been ordered.
Rollout string: How a change to this rotation is introduced: immediate replaces the line-up now and can change who is on call this minute, after_current_shift lets the shift on call finish first, and after_full_rotation waits for everyone to have taken a turn. Leave it out to replace the line-up straight away. Creating a rotation ignores it, as there's no shift to protect yet.
SchedulingMode string: How users are allocated across shifts of differing length. Possible values are: fair, sequential. Omit it to leave us to pick. For an even rotation the two behave identically — see the resource description for when they diverge.
WorkingIntervals []ScheduleRotationWorkingIntervalArgs: If set, restricts on-call to these weekday intervals. Omit it to keep the rotation on call around the clock. An empty list is not valid, and is rejected at plan time — it would leave a rotation nobody is ever on call for.

first_interval_starts_at string: When the first handover interval starts being counted from, which fixes the time of day and day of week shifts change hands. The dashboard calls this the handover time.. Can't be changed in the same apply as rollout — see the resource description for why, and what to do instead.
handovers list(object): The cadence shifts hand over on, applied in turn
schedule_id string: ID of the schedule this rotation belongs to. Changing this replaces the rotation, as a rotation can't move between schedules.
users list(string): IDs of the people in the rotation, in the order they take shifts. Use the special ID NOBODY for a slot with nobody in it, which schedules the shift without putting anyone on call until an override covers it.
concurrent_shifts number: How many shifts run at the same time, which is how many people are on call at once. Defaults to 1, one person on call at a time. Reducing this stops scheduling the last of them, and stops any overrides on those shifts from applying.
name string: Human readable name for the rotation, unique within the schedule
rank number: Where this rotation sits in the schedule's running order, lowest first. Unset when it has never been ordered.
rollout string: How a change to this rotation is introduced: immediate replaces the line-up now and can change who is on call this minute, after_current_shift lets the shift on call finish first, and after_full_rotation waits for everyone to have taken a turn. Leave it out to replace the line-up straight away. Creating a rotation ignores it, as there's no shift to protect yet.
scheduling_mode string: How users are allocated across shifts of differing length. Possible values are: fair, sequential. Omit it to leave us to pick. For an even rotation the two behave identically — see the resource description for when they diverge.
working_intervals list(object): If set, restricts on-call to these weekday intervals. Omit it to keep the rotation on call around the clock. An empty list is not valid, and is rejected at plan time — it would leave a rotation nobody is ever on call for.

firstIntervalStartsAt String: When the first handover interval starts being counted from, which fixes the time of day and day of week shifts change hands. The dashboard calls this the handover time.. Can't be changed in the same apply as rollout — see the resource description for why, and what to do instead.
handovers List<ScheduleRotationHandover>: The cadence shifts hand over on, applied in turn
scheduleId String: ID of the schedule this rotation belongs to. Changing this replaces the rotation, as a rotation can't move between schedules.
users List<String>: IDs of the people in the rotation, in the order they take shifts. Use the special ID NOBODY for a slot with nobody in it, which schedules the shift without putting anyone on call until an override covers it.
concurrentShifts Double: How many shifts run at the same time, which is how many people are on call at once. Defaults to 1, one person on call at a time. Reducing this stops scheduling the last of them, and stops any overrides on those shifts from applying.
name String: Human readable name for the rotation, unique within the schedule
rank Double: Where this rotation sits in the schedule's running order, lowest first. Unset when it has never been ordered.
rollout String: How a change to this rotation is introduced: immediate replaces the line-up now and can change who is on call this minute, after_current_shift lets the shift on call finish first, and after_full_rotation waits for everyone to have taken a turn. Leave it out to replace the line-up straight away. Creating a rotation ignores it, as there's no shift to protect yet.
schedulingMode String: How users are allocated across shifts of differing length. Possible values are: fair, sequential. Omit it to leave us to pick. For an even rotation the two behave identically — see the resource description for when they diverge.
workingIntervals List<ScheduleRotationWorkingInterval>: If set, restricts on-call to these weekday intervals. Omit it to keep the rotation on call around the clock. An empty list is not valid, and is rejected at plan time — it would leave a rotation nobody is ever on call for.

firstIntervalStartsAt string: When the first handover interval starts being counted from, which fixes the time of day and day of week shifts change hands. The dashboard calls this the handover time.. Can't be changed in the same apply as rollout — see the resource description for why, and what to do instead.
handovers ScheduleRotationHandover[]: The cadence shifts hand over on, applied in turn
scheduleId string: ID of the schedule this rotation belongs to. Changing this replaces the rotation, as a rotation can't move between schedules.
users string[]: IDs of the people in the rotation, in the order they take shifts. Use the special ID NOBODY for a slot with nobody in it, which schedules the shift without putting anyone on call until an override covers it.
concurrentShifts number: How many shifts run at the same time, which is how many people are on call at once. Defaults to 1, one person on call at a time. Reducing this stops scheduling the last of them, and stops any overrides on those shifts from applying.
name string: Human readable name for the rotation, unique within the schedule
rank number: Where this rotation sits in the schedule's running order, lowest first. Unset when it has never been ordered.
rollout string: How a change to this rotation is introduced: immediate replaces the line-up now and can change who is on call this minute, after_current_shift lets the shift on call finish first, and after_full_rotation waits for everyone to have taken a turn. Leave it out to replace the line-up straight away. Creating a rotation ignores it, as there's no shift to protect yet.
schedulingMode string: How users are allocated across shifts of differing length. Possible values are: fair, sequential. Omit it to leave us to pick. For an even rotation the two behave identically — see the resource description for when they diverge.
workingIntervals ScheduleRotationWorkingInterval[]: If set, restricts on-call to these weekday intervals. Omit it to keep the rotation on call around the clock. An empty list is not valid, and is rejected at plan time — it would leave a rotation nobody is ever on call for.

first_interval_starts_at str: When the first handover interval starts being counted from, which fixes the time of day and day of week shifts change hands. The dashboard calls this the handover time.. Can't be changed in the same apply as rollout — see the resource description for why, and what to do instead.
handovers Sequence[ScheduleRotationHandoverArgs]: The cadence shifts hand over on, applied in turn
schedule_id str: ID of the schedule this rotation belongs to. Changing this replaces the rotation, as a rotation can't move between schedules.
users Sequence[str]: IDs of the people in the rotation, in the order they take shifts. Use the special ID NOBODY for a slot with nobody in it, which schedules the shift without putting anyone on call until an override covers it.
concurrent_shifts float: How many shifts run at the same time, which is how many people are on call at once. Defaults to 1, one person on call at a time. Reducing this stops scheduling the last of them, and stops any overrides on those shifts from applying.
name str: Human readable name for the rotation, unique within the schedule
rank float: Where this rotation sits in the schedule's running order, lowest first. Unset when it has never been ordered.
rollout str: How a change to this rotation is introduced: immediate replaces the line-up now and can change who is on call this minute, after_current_shift lets the shift on call finish first, and after_full_rotation waits for everyone to have taken a turn. Leave it out to replace the line-up straight away. Creating a rotation ignores it, as there's no shift to protect yet.
scheduling_mode str: How users are allocated across shifts of differing length. Possible values are: fair, sequential. Omit it to leave us to pick. For an even rotation the two behave identically — see the resource description for when they diverge.
working_intervals Sequence[ScheduleRotationWorkingIntervalArgs]: If set, restricts on-call to these weekday intervals. Omit it to keep the rotation on call around the clock. An empty list is not valid, and is rejected at plan time — it would leave a rotation nobody is ever on call for.

firstIntervalStartsAt String: When the first handover interval starts being counted from, which fixes the time of day and day of week shifts change hands. The dashboard calls this the handover time.. Can't be changed in the same apply as rollout — see the resource description for why, and what to do instead.
handovers List<Property Map>: The cadence shifts hand over on, applied in turn
scheduleId String: ID of the schedule this rotation belongs to. Changing this replaces the rotation, as a rotation can't move between schedules.
users List<String>: IDs of the people in the rotation, in the order they take shifts. Use the special ID NOBODY for a slot with nobody in it, which schedules the shift without putting anyone on call until an override covers it.
concurrentShifts Number: How many shifts run at the same time, which is how many people are on call at once. Defaults to 1, one person on call at a time. Reducing this stops scheduling the last of them, and stops any overrides on those shifts from applying.
name String: Human readable name for the rotation, unique within the schedule
rank Number: Where this rotation sits in the schedule's running order, lowest first. Unset when it has never been ordered.
rollout String: How a change to this rotation is introduced: immediate replaces the line-up now and can change who is on call this minute, after_current_shift lets the shift on call finish first, and after_full_rotation waits for everyone to have taken a turn. Leave it out to replace the line-up straight away. Creating a rotation ignores it, as there's no shift to protect yet.
schedulingMode String: How users are allocated across shifts of differing length. Possible values are: fair, sequential. Omit it to leave us to pick. For an even rotation the two behave identically — see the resource description for when they diverge.
workingIntervals List<Property Map>: If set, restricts on-call to these weekday intervals. Omit it to keep the rotation on call around the clock. An empty list is not valid, and is rejected at plan time — it would leave a rotation nobody is ever on call for.

Outputs

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

EffectiveFrom string: When this shape of the rotation took over. Unset when the rotation has only ever had one.
Id string: The provider-assigned unique ID for this managed resource.

EffectiveFrom string: When this shape of the rotation took over. Unset when the rotation has only ever had one.
Id string: The provider-assigned unique ID for this managed resource.

effective_from string: When this shape of the rotation took over. Unset when the rotation has only ever had one.
id string: The provider-assigned unique ID for this managed resource.

effectiveFrom String: When this shape of the rotation took over. Unset when the rotation has only ever had one.
id String: The provider-assigned unique ID for this managed resource.

effectiveFrom string: When this shape of the rotation took over. Unset when the rotation has only ever had one.
id string: The provider-assigned unique ID for this managed resource.

effective_from str: When this shape of the rotation took over. Unset when the rotation has only ever had one.
id str: The provider-assigned unique ID for this managed resource.

effectiveFrom String: When this shape of the rotation took over. Unset when the rotation has only ever had one.
id String: The provider-assigned unique ID for this managed resource.

Look up Existing ScheduleRotation Resource

Get an existing ScheduleRotation 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?: ScheduleRotationState, opts?: CustomResourceOptions): ScheduleRotation

@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        concurrent_shifts: Optional[float] = None,
        effective_from: Optional[str] = None,
        first_interval_starts_at: Optional[str] = None,
        handovers: Optional[Sequence[ScheduleRotationHandoverArgs]] = None,
        name: Optional[str] = None,
        rank: Optional[float] = None,
        rollout: Optional[str] = None,
        schedule_id: Optional[str] = None,
        scheduling_mode: Optional[str] = None,
        users: Optional[Sequence[str]] = None,
        working_intervals: Optional[Sequence[ScheduleRotationWorkingIntervalArgs]] = None) -> ScheduleRotation

func GetScheduleRotation(ctx *Context, name string, id IDInput, state *ScheduleRotationState, opts ...ResourceOption) (*ScheduleRotation, error)

public static ScheduleRotation Get(string name, Input<string> id, ScheduleRotationState? state, CustomResourceOptions? opts = null)

public static ScheduleRotation get(String name, Output<String> id, ScheduleRotationState state, CustomResourceOptions options)

resources:  _:    type: incident:ScheduleRotation    get:      id: ${id}

import {
  to = incident_schedule_rotation.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:

ConcurrentShifts double: How many shifts run at the same time, which is how many people are on call at once. Defaults to 1, one person on call at a time. Reducing this stops scheduling the last of them, and stops any overrides on those shifts from applying.
EffectiveFrom string: When this shape of the rotation took over. Unset when the rotation has only ever had one.
FirstIntervalStartsAt string: When the first handover interval starts being counted from, which fixes the time of day and day of week shifts change hands. The dashboard calls this the handover time.. Can't be changed in the same apply as rollout — see the resource description for why, and what to do instead.
Handovers List<ScheduleRotationHandover>: The cadence shifts hand over on, applied in turn
Name string: Human readable name for the rotation, unique within the schedule
Rank double: Where this rotation sits in the schedule's running order, lowest first. Unset when it has never been ordered.
Rollout string: How a change to this rotation is introduced: immediate replaces the line-up now and can change who is on call this minute, after_current_shift lets the shift on call finish first, and after_full_rotation waits for everyone to have taken a turn. Leave it out to replace the line-up straight away. Creating a rotation ignores it, as there's no shift to protect yet.
ScheduleId string: ID of the schedule this rotation belongs to. Changing this replaces the rotation, as a rotation can't move between schedules.
SchedulingMode string: How users are allocated across shifts of differing length. Possible values are: fair, sequential. Omit it to leave us to pick. For an even rotation the two behave identically — see the resource description for when they diverge.
Users List<string>: IDs of the people in the rotation, in the order they take shifts. Use the special ID NOBODY for a slot with nobody in it, which schedules the shift without putting anyone on call until an override covers it.
WorkingIntervals List<ScheduleRotationWorkingInterval>: If set, restricts on-call to these weekday intervals. Omit it to keep the rotation on call around the clock. An empty list is not valid, and is rejected at plan time — it would leave a rotation nobody is ever on call for.

ConcurrentShifts float64: How many shifts run at the same time, which is how many people are on call at once. Defaults to 1, one person on call at a time. Reducing this stops scheduling the last of them, and stops any overrides on those shifts from applying.
EffectiveFrom string: When this shape of the rotation took over. Unset when the rotation has only ever had one.
FirstIntervalStartsAt string: When the first handover interval starts being counted from, which fixes the time of day and day of week shifts change hands. The dashboard calls this the handover time.. Can't be changed in the same apply as rollout — see the resource description for why, and what to do instead.
Handovers []ScheduleRotationHandoverArgs: The cadence shifts hand over on, applied in turn
Name string: Human readable name for the rotation, unique within the schedule
Rank float64: Where this rotation sits in the schedule's running order, lowest first. Unset when it has never been ordered.
Rollout string: How a change to this rotation is introduced: immediate replaces the line-up now and can change who is on call this minute, after_current_shift lets the shift on call finish first, and after_full_rotation waits for everyone to have taken a turn. Leave it out to replace the line-up straight away. Creating a rotation ignores it, as there's no shift to protect yet.
ScheduleId string: ID of the schedule this rotation belongs to. Changing this replaces the rotation, as a rotation can't move between schedules.
SchedulingMode string: How users are allocated across shifts of differing length. Possible values are: fair, sequential. Omit it to leave us to pick. For an even rotation the two behave identically — see the resource description for when they diverge.
Users []string: IDs of the people in the rotation, in the order they take shifts. Use the special ID NOBODY for a slot with nobody in it, which schedules the shift without putting anyone on call until an override covers it.
WorkingIntervals []ScheduleRotationWorkingIntervalArgs: If set, restricts on-call to these weekday intervals. Omit it to keep the rotation on call around the clock. An empty list is not valid, and is rejected at plan time — it would leave a rotation nobody is ever on call for.

concurrent_shifts number: How many shifts run at the same time, which is how many people are on call at once. Defaults to 1, one person on call at a time. Reducing this stops scheduling the last of them, and stops any overrides on those shifts from applying.
effective_from string: When this shape of the rotation took over. Unset when the rotation has only ever had one.
first_interval_starts_at string: When the first handover interval starts being counted from, which fixes the time of day and day of week shifts change hands. The dashboard calls this the handover time.. Can't be changed in the same apply as rollout — see the resource description for why, and what to do instead.
handovers list(object): The cadence shifts hand over on, applied in turn
name string: Human readable name for the rotation, unique within the schedule
rank number: Where this rotation sits in the schedule's running order, lowest first. Unset when it has never been ordered.
rollout string: How a change to this rotation is introduced: immediate replaces the line-up now and can change who is on call this minute, after_current_shift lets the shift on call finish first, and after_full_rotation waits for everyone to have taken a turn. Leave it out to replace the line-up straight away. Creating a rotation ignores it, as there's no shift to protect yet.
schedule_id string: ID of the schedule this rotation belongs to. Changing this replaces the rotation, as a rotation can't move between schedules.
scheduling_mode string: How users are allocated across shifts of differing length. Possible values are: fair, sequential. Omit it to leave us to pick. For an even rotation the two behave identically — see the resource description for when they diverge.
users list(string): IDs of the people in the rotation, in the order they take shifts. Use the special ID NOBODY for a slot with nobody in it, which schedules the shift without putting anyone on call until an override covers it.
working_intervals list(object): If set, restricts on-call to these weekday intervals. Omit it to keep the rotation on call around the clock. An empty list is not valid, and is rejected at plan time — it would leave a rotation nobody is ever on call for.

concurrentShifts Double: How many shifts run at the same time, which is how many people are on call at once. Defaults to 1, one person on call at a time. Reducing this stops scheduling the last of them, and stops any overrides on those shifts from applying.
effectiveFrom String: When this shape of the rotation took over. Unset when the rotation has only ever had one.
firstIntervalStartsAt String: When the first handover interval starts being counted from, which fixes the time of day and day of week shifts change hands. The dashboard calls this the handover time.. Can't be changed in the same apply as rollout — see the resource description for why, and what to do instead.
handovers List<ScheduleRotationHandover>: The cadence shifts hand over on, applied in turn
name String: Human readable name for the rotation, unique within the schedule
rank Double: Where this rotation sits in the schedule's running order, lowest first. Unset when it has never been ordered.
rollout String: How a change to this rotation is introduced: immediate replaces the line-up now and can change who is on call this minute, after_current_shift lets the shift on call finish first, and after_full_rotation waits for everyone to have taken a turn. Leave it out to replace the line-up straight away. Creating a rotation ignores it, as there's no shift to protect yet.
scheduleId String: ID of the schedule this rotation belongs to. Changing this replaces the rotation, as a rotation can't move between schedules.
schedulingMode String: How users are allocated across shifts of differing length. Possible values are: fair, sequential. Omit it to leave us to pick. For an even rotation the two behave identically — see the resource description for when they diverge.
users List<String>: IDs of the people in the rotation, in the order they take shifts. Use the special ID NOBODY for a slot with nobody in it, which schedules the shift without putting anyone on call until an override covers it.
workingIntervals List<ScheduleRotationWorkingInterval>: If set, restricts on-call to these weekday intervals. Omit it to keep the rotation on call around the clock. An empty list is not valid, and is rejected at plan time — it would leave a rotation nobody is ever on call for.

concurrentShifts number: How many shifts run at the same time, which is how many people are on call at once. Defaults to 1, one person on call at a time. Reducing this stops scheduling the last of them, and stops any overrides on those shifts from applying.
effectiveFrom string: When this shape of the rotation took over. Unset when the rotation has only ever had one.
firstIntervalStartsAt string: When the first handover interval starts being counted from, which fixes the time of day and day of week shifts change hands. The dashboard calls this the handover time.. Can't be changed in the same apply as rollout — see the resource description for why, and what to do instead.
handovers ScheduleRotationHandover[]: The cadence shifts hand over on, applied in turn
name string: Human readable name for the rotation, unique within the schedule
rank number: Where this rotation sits in the schedule's running order, lowest first. Unset when it has never been ordered.
rollout string: How a change to this rotation is introduced: immediate replaces the line-up now and can change who is on call this minute, after_current_shift lets the shift on call finish first, and after_full_rotation waits for everyone to have taken a turn. Leave it out to replace the line-up straight away. Creating a rotation ignores it, as there's no shift to protect yet.
scheduleId string: ID of the schedule this rotation belongs to. Changing this replaces the rotation, as a rotation can't move between schedules.
schedulingMode string: How users are allocated across shifts of differing length. Possible values are: fair, sequential. Omit it to leave us to pick. For an even rotation the two behave identically — see the resource description for when they diverge.
users string[]: IDs of the people in the rotation, in the order they take shifts. Use the special ID NOBODY for a slot with nobody in it, which schedules the shift without putting anyone on call until an override covers it.
workingIntervals ScheduleRotationWorkingInterval[]: If set, restricts on-call to these weekday intervals. Omit it to keep the rotation on call around the clock. An empty list is not valid, and is rejected at plan time — it would leave a rotation nobody is ever on call for.

concurrent_shifts float: How many shifts run at the same time, which is how many people are on call at once. Defaults to 1, one person on call at a time. Reducing this stops scheduling the last of them, and stops any overrides on those shifts from applying.
effective_from str: When this shape of the rotation took over. Unset when the rotation has only ever had one.
first_interval_starts_at str: When the first handover interval starts being counted from, which fixes the time of day and day of week shifts change hands. The dashboard calls this the handover time.. Can't be changed in the same apply as rollout — see the resource description for why, and what to do instead.
handovers Sequence[ScheduleRotationHandoverArgs]: The cadence shifts hand over on, applied in turn
name str: Human readable name for the rotation, unique within the schedule
rank float: Where this rotation sits in the schedule's running order, lowest first. Unset when it has never been ordered.
rollout str: How a change to this rotation is introduced: immediate replaces the line-up now and can change who is on call this minute, after_current_shift lets the shift on call finish first, and after_full_rotation waits for everyone to have taken a turn. Leave it out to replace the line-up straight away. Creating a rotation ignores it, as there's no shift to protect yet.
schedule_id str: ID of the schedule this rotation belongs to. Changing this replaces the rotation, as a rotation can't move between schedules.
scheduling_mode str: How users are allocated across shifts of differing length. Possible values are: fair, sequential. Omit it to leave us to pick. For an even rotation the two behave identically — see the resource description for when they diverge.
users Sequence[str]: IDs of the people in the rotation, in the order they take shifts. Use the special ID NOBODY for a slot with nobody in it, which schedules the shift without putting anyone on call until an override covers it.
working_intervals Sequence[ScheduleRotationWorkingIntervalArgs]: If set, restricts on-call to these weekday intervals. Omit it to keep the rotation on call around the clock. An empty list is not valid, and is rejected at plan time — it would leave a rotation nobody is ever on call for.

concurrentShifts Number: How many shifts run at the same time, which is how many people are on call at once. Defaults to 1, one person on call at a time. Reducing this stops scheduling the last of them, and stops any overrides on those shifts from applying.
effectiveFrom String: When this shape of the rotation took over. Unset when the rotation has only ever had one.
firstIntervalStartsAt String: When the first handover interval starts being counted from, which fixes the time of day and day of week shifts change hands. The dashboard calls this the handover time.. Can't be changed in the same apply as rollout — see the resource description for why, and what to do instead.
handovers List<Property Map>: The cadence shifts hand over on, applied in turn
name String: Human readable name for the rotation, unique within the schedule
rank Number: Where this rotation sits in the schedule's running order, lowest first. Unset when it has never been ordered.
rollout String: How a change to this rotation is introduced: immediate replaces the line-up now and can change who is on call this minute, after_current_shift lets the shift on call finish first, and after_full_rotation waits for everyone to have taken a turn. Leave it out to replace the line-up straight away. Creating a rotation ignores it, as there's no shift to protect yet.
scheduleId String: ID of the schedule this rotation belongs to. Changing this replaces the rotation, as a rotation can't move between schedules.
schedulingMode String: How users are allocated across shifts of differing length. Possible values are: fair, sequential. Omit it to leave us to pick. For an even rotation the two behave identically — see the resource description for when they diverge.
users List<String>: IDs of the people in the rotation, in the order they take shifts. Use the special ID NOBODY for a slot with nobody in it, which schedules the shift without putting anyone on call until an override covers it.
workingIntervals List<Property Map>: If set, restricts on-call to these weekday intervals. Omit it to keep the rotation on call around the clock. An empty list is not valid, and is rejected at plan time — it would leave a rotation nobody is ever on call for.

Supporting Types

ScheduleRotationHandover, ScheduleRotationHandoverArgs

Interval double: How many of the interval type to wait between handovers.
IntervalType string: How often a handover occurs. Possible values are: hourly, daily, weekly.

Interval float64: How many of the interval type to wait between handovers.
IntervalType string: How often a handover occurs. Possible values are: hourly, daily, weekly.

interval number: How many of the interval type to wait between handovers.
interval_type string: How often a handover occurs. Possible values are: hourly, daily, weekly.

interval Double: How many of the interval type to wait between handovers.
intervalType String: How often a handover occurs. Possible values are: hourly, daily, weekly.

interval number: How many of the interval type to wait between handovers.
intervalType string: How often a handover occurs. Possible values are: hourly, daily, weekly.

interval float: How many of the interval type to wait between handovers.
interval_type str: How often a handover occurs. Possible values are: hourly, daily, weekly.

interval Number: How many of the interval type to wait between handovers.
intervalType String: How often a handover occurs. Possible values are: hourly, daily, weekly.

ScheduleRotationWorkingInterval, ScheduleRotationWorkingIntervalArgs

EndTime string: Time of day this window closes, as HH:MM.
StartTime string: Time of day this window opens, as HH:MM.
Weekday string: Day of the week, lowercase. Possible values are: monday, tuesday, wednesday, thursday, friday, saturday, sunday.

EndTime string: Time of day this window closes, as HH:MM.
StartTime string: Time of day this window opens, as HH:MM.
Weekday string: Day of the week, lowercase. Possible values are: monday, tuesday, wednesday, thursday, friday, saturday, sunday.

end_time string: Time of day this window closes, as HH:MM.
start_time string: Time of day this window opens, as HH:MM.
weekday string: Day of the week, lowercase. Possible values are: monday, tuesday, wednesday, thursday, friday, saturday, sunday.

endTime String: Time of day this window closes, as HH:MM.
startTime String: Time of day this window opens, as HH:MM.
weekday String: Day of the week, lowercase. Possible values are: monday, tuesday, wednesday, thursday, friday, saturday, sunday.

endTime string: Time of day this window closes, as HH:MM.
startTime string: Time of day this window opens, as HH:MM.
weekday string: Day of the week, lowercase. Possible values are: monday, tuesday, wednesday, thursday, friday, saturday, sunday.

end_time str: Time of day this window closes, as HH:MM.
start_time str: Time of day this window opens, as HH:MM.
weekday str: Day of the week, lowercase. Possible values are: monday, tuesday, wednesday, thursday, friday, saturday, sunday.

endTime String: Time of day this window closes, as HH:MM.
startTime String: Time of day this window opens, as HH:MM.
weekday String: Day of the week, lowercase. Possible values are: monday, tuesday, wednesday, thursday, friday, saturday, sunday.

Import

Import is supported using an import block or the pulumi import command:

The import block can be used with the id attribute, for example:

terraform

Import a rotation using its schedule’s ID and its own ID, separated by a colon.

A rotation is only addressable through the schedule that holds it.

Replace both IDs with real ones from your incident.io organization.

import {

to = incident_schedule_rotation.example

id = “01ABC123DEF456GHI789JKL:01MNO456PQR789STU012VWX”

}

The pulumi import command can be used, for example:

#!/bin/bash

Import a rotation using its schedule’s ID and its own ID, separated by a colon.

A rotation is only addressable through the schedule that holds it.

Replace both IDs with real ones from your incident.io organization.

$ pulumi import incident:index/scheduleRotation:ScheduleRotation example 01ABC123DEF456GHI789JKL:01MNO456PQR789STU012VWX

To learn more about importing existing cloud resources, see Importing resources.

Package Details

Repository: incident incident-io/terraform-provider-incident
License
Notes: This Pulumi package is based on the incident Terraform Provider.

Viewing docs for incident 7.0.0
published on Friday, Sep 11, 2026 by incident-io

Schema (JSON)

incident-io/terraform-provider-incident

incident.ScheduleRotation

On this page

On this page

Changing when shifts hand over

Choosing a scheduling mode

Upgrading from v6

Example Usage

Create ScheduleRotation Resource

Constructor syntax

Parameters

Constructor example

ScheduleRotation Resource Properties

Inputs

Outputs

Look up Existing ScheduleRotation Resource

Supporting Types

ScheduleRotationHandover, ScheduleRotationHandoverArgs

ScheduleRotationWorkingInterval, ScheduleRotationWorkingIntervalArgs

Import

Package Details

On this page

On this page

Try Pulumi Cloud free.
Your team will thank you.

incident.ScheduleRotation

On this page

On this page

Changing when shifts hand over

Choosing a scheduling mode

Upgrading from v6

Example Usage

Create ScheduleRotation Resource

Constructor syntax

Parameters

Constructor example

ScheduleRotation Resource Properties

Inputs

Outputs

Look up Existing ScheduleRotation Resource

Supporting Types

ScheduleRotationHandover, ScheduleRotationHandoverArgs

ScheduleRotationWorkingInterval, ScheduleRotationWorkingIntervalArgs

Import

Package Details

On this page

On this page

Try Pulumi Cloud free.Your team will thank you.

Try Pulumi Cloud free.
Your team will thank you.