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

incident.PayConfig

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 on-call pay configs: the rates that pay reports price on-call shifts against.

    A pay config sets what someone is paid for being on call: a base rate, plus rules that override it at particular times. An on-call pay report prices each person’s shifts against one.

    weeklyRules is ordered. A shift is priced by the first rule that covers it, so put the rule that should win first. oneOffRules take precedence over every weekly rule and may not overlap each other, so their order has no effect on pricing. Any time no rule covers is paid at baseRateCents.

    Terraform creates the config as a draft, which becomes visible to everyone in the organisation once a report that prices against it is published. Editing a config after that changes the explanation of pay someone has already been sent, so every write to it — its own attributes or any of its rules — additionally needs the schedule_pay_configs.update_published scope on the API key. The payConfigsEditor role carries it, along with everything else this resource needs.

    Example Usage

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

// A pay config sets what someone is paid for being on call: a base rate, plus rules that
// override it at particular times. Every rate is in the lowest denomination of the
// currency, per rate_time_unit, and pay is pro-rated by the second either way.
const platform = new incident.PayConfig("platform", {
    name: "Platform on-call",
    timezone: "Europe/London",
    currency: "GBP",
    baseRateCents: 500,
    rateTimeUnit: "hour",
    weeklyRules: [
        {
            weekdays: [
                "saturday",
                "sunday",
            ],
            startTime: "00:00",
            endTime: "00:00",
            rateCents: 1500,
        },
        {
            weekdays: [
                "monday",
                "tuesday",
                "wednesday",
                "thursday",
                "friday",
            ],
            startTime: "18:00",
            endTime: "00:00",
            rateCents: 1000,
        },
        {
            weekdays: [
                "monday",
                "tuesday",
                "wednesday",
                "thursday",
                "friday",
            ],
            startTime: "00:00",
            endTime: "09:00",
            rateCents: 1000,
        },
    ],
    oneOffRules: [
        {
            name: "Christmas Day",
            startAt: "2026-12-25T00:00:00Z",
            endAt: "2026-12-26T00:00:00Z",
            rateCents: 3000,
        },
        {
            name: "Boxing Day",
            startAt: "2026-12-26T00:00:00Z",
            endAt: "2026-12-27T00:00:00Z",
            rateCents: 2500,
        },
    ],
});
// A flat rate needs no rules at all.
const flatDaily = new incident.PayConfig("flat_daily", {
    name: "Flat daily rate",
    timezone: "America/New_York",
    currency: "USD",
    baseRateCents: 10000,
    rateTimeUnit: "day",
});

    import pulumi
import pulumi_incident as incident

# A pay config sets what someone is paid for being on call: a base rate, plus rules that
# override it at particular times. Every rate is in the lowest denomination of the
# currency, per rate_time_unit, and pay is pro-rated by the second either way.
platform = incident.PayConfig("platform",
    name="Platform on-call",
    timezone="Europe/London",
    currency="GBP",
    base_rate_cents=500,
    rate_time_unit="hour",
    weekly_rules=[
        {
            "weekdays": [
                "saturday",
                "sunday",
            ],
            "start_time": "00:00",
            "end_time": "00:00",
            "rate_cents": 1500,
        },
        {
            "weekdays": [
                "monday",
                "tuesday",
                "wednesday",
                "thursday",
                "friday",
            ],
            "start_time": "18:00",
            "end_time": "00:00",
            "rate_cents": 1000,
        },
        {
            "weekdays": [
                "monday",
                "tuesday",
                "wednesday",
                "thursday",
                "friday",
            ],
            "start_time": "00:00",
            "end_time": "09:00",
            "rate_cents": 1000,
        },
    ],
    one_off_rules=[
        {
            "name": "Christmas Day",
            "start_at": "2026-12-25T00:00:00Z",
            "end_at": "2026-12-26T00:00:00Z",
            "rate_cents": 3000,
        },
        {
            "name": "Boxing Day",
            "start_at": "2026-12-26T00:00:00Z",
            "end_at": "2026-12-27T00:00:00Z",
            "rate_cents": 2500,
        },
    ])
# A flat rate needs no rules at all.
flat_daily = incident.PayConfig("flat_daily",
    name="Flat daily rate",
    timezone="America/New_York",
    currency="USD",
    base_rate_cents=10000,
    rate_time_unit="day")

    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 {
		// A pay config sets what someone is paid for being on call: a base rate, plus rules that
		// override it at particular times. Every rate is in the lowest denomination of the
		// currency, per rate_time_unit, and pay is pro-rated by the second either way.
		_, err := incident.NewPayConfig(ctx, "platform", &incident.PayConfigArgs{
			Name:          pulumi.String("Platform on-call"),
			Timezone:      pulumi.String("Europe/London"),
			Currency:      pulumi.String("GBP"),
			BaseRateCents: pulumi.Int(500),
			RateTimeUnit:  pulumi.String("hour"),
			WeeklyRules: incident.PayConfigWeeklyRuleArray{
				&incident.PayConfigWeeklyRuleArgs{
					Weekdays: pulumi.StringArray{
						pulumi.String("saturday"),
						pulumi.String("sunday"),
					},
					StartTime: pulumi.String("00:00"),
					EndTime:   pulumi.String("00:00"),
					RateCents: pulumi.Int(1500),
				},
				&incident.PayConfigWeeklyRuleArgs{
					Weekdays: pulumi.StringArray{
						pulumi.String("monday"),
						pulumi.String("tuesday"),
						pulumi.String("wednesday"),
						pulumi.String("thursday"),
						pulumi.String("friday"),
					},
					StartTime: pulumi.String("18:00"),
					EndTime:   pulumi.String("00:00"),
					RateCents: pulumi.Int(1000),
				},
				&incident.PayConfigWeeklyRuleArgs{
					Weekdays: pulumi.StringArray{
						pulumi.String("monday"),
						pulumi.String("tuesday"),
						pulumi.String("wednesday"),
						pulumi.String("thursday"),
						pulumi.String("friday"),
					},
					StartTime: pulumi.String("00:00"),
					EndTime:   pulumi.String("09:00"),
					RateCents: pulumi.Int(1000),
				},
			},
			OneOffRules: incident.PayConfigOneOffRuleArray{
				&incident.PayConfigOneOffRuleArgs{
					Name:      pulumi.String("Christmas Day"),
					StartAt:   pulumi.String("2026-12-25T00:00:00Z"),
					EndAt:     pulumi.String("2026-12-26T00:00:00Z"),
					RateCents: pulumi.Int(3000),
				},
				&incident.PayConfigOneOffRuleArgs{
					Name:      pulumi.String("Boxing Day"),
					StartAt:   pulumi.String("2026-12-26T00:00:00Z"),
					EndAt:     pulumi.String("2026-12-27T00:00:00Z"),
					RateCents: pulumi.Int(2500),
				},
			},
		})
		if err != nil {
			return err
		}
		// A flat rate needs no rules at all.
		_, err = incident.NewPayConfig(ctx, "flat_daily", &incident.PayConfigArgs{
			Name:          pulumi.String("Flat daily rate"),
			Timezone:      pulumi.String("America/New_York"),
			Currency:      pulumi.String("USD"),
			BaseRateCents: pulumi.Int(10000),
			RateTimeUnit:  pulumi.String("day"),
		})
		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 pay config sets what someone is paid for being on call: a base rate, plus rules that
    // override it at particular times. Every rate is in the lowest denomination of the
    // currency, per rate_time_unit, and pay is pro-rated by the second either way.
    var platform = new Incident.PayConfig("platform", new()
    {
        Name = "Platform on-call",
        Timezone = "Europe/London",
        Currency = "GBP",
        BaseRateCents = 500,
        RateTimeUnit = "hour",
        WeeklyRules = new[]
        {
            new Incident.Inputs.PayConfigWeeklyRuleArgs
            {
                Weekdays = new[]
                {
                    "saturday",
                    "sunday",
                },
                StartTime = "00:00",
                EndTime = "00:00",
                RateCents = 1500,
            },
            new Incident.Inputs.PayConfigWeeklyRuleArgs
            {
                Weekdays = new[]
                {
                    "monday",
                    "tuesday",
                    "wednesday",
                    "thursday",
                    "friday",
                },
                StartTime = "18:00",
                EndTime = "00:00",
                RateCents = 1000,
            },
            new Incident.Inputs.PayConfigWeeklyRuleArgs
            {
                Weekdays = new[]
                {
                    "monday",
                    "tuesday",
                    "wednesday",
                    "thursday",
                    "friday",
                },
                StartTime = "00:00",
                EndTime = "09:00",
                RateCents = 1000,
            },
        },
        OneOffRules = new[]
        {
            new Incident.Inputs.PayConfigOneOffRuleArgs
            {
                Name = "Christmas Day",
                StartAt = "2026-12-25T00:00:00Z",
                EndAt = "2026-12-26T00:00:00Z",
                RateCents = 3000,
            },
            new Incident.Inputs.PayConfigOneOffRuleArgs
            {
                Name = "Boxing Day",
                StartAt = "2026-12-26T00:00:00Z",
                EndAt = "2026-12-27T00:00:00Z",
                RateCents = 2500,
            },
        },
    });

    // A flat rate needs no rules at all.
    var flatDaily = new Incident.PayConfig("flat_daily", new()
    {
        Name = "Flat daily rate",
        Timezone = "America/New_York",
        Currency = "USD",
        BaseRateCents = 10000,
        RateTimeUnit = "day",
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.incident.PayConfig;
import com.pulumi.incident.PayConfigArgs;
import com.pulumi.incident.inputs.PayConfigWeeklyRuleArgs;
import com.pulumi.incident.inputs.PayConfigOneOffRuleArgs;
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) {
        // A pay config sets what someone is paid for being on call: a base rate, plus rules that
        // override it at particular times. Every rate is in the lowest denomination of the
        // currency, per rate_time_unit, and pay is pro-rated by the second either way.
        var platform = new PayConfig("platform", PayConfigArgs.builder()
            .name("Platform on-call")
            .timezone("Europe/London")
            .currency("GBP")
            .baseRateCents(500)
            .rateTimeUnit("hour")
            .weeklyRules(            
                PayConfigWeeklyRuleArgs.builder()
                    .weekdays(                    
                        "saturday",
                        "sunday")
                    .startTime("00:00")
                    .endTime("00:00")
                    .rateCents(1500)
                    .build(),
                PayConfigWeeklyRuleArgs.builder()
                    .weekdays(                    
                        "monday",
                        "tuesday",
                        "wednesday",
                        "thursday",
                        "friday")
                    .startTime("18:00")
                    .endTime("00:00")
                    .rateCents(1000)
                    .build(),
                PayConfigWeeklyRuleArgs.builder()
                    .weekdays(                    
                        "monday",
                        "tuesday",
                        "wednesday",
                        "thursday",
                        "friday")
                    .startTime("00:00")
                    .endTime("09:00")
                    .rateCents(1000)
                    .build())
            .oneOffRules(            
                PayConfigOneOffRuleArgs.builder()
                    .name("Christmas Day")
                    .startAt("2026-12-25T00:00:00Z")
                    .endAt("2026-12-26T00:00:00Z")
                    .rateCents(3000)
                    .build(),
                PayConfigOneOffRuleArgs.builder()
                    .name("Boxing Day")
                    .startAt("2026-12-26T00:00:00Z")
                    .endAt("2026-12-27T00:00:00Z")
                    .rateCents(2500)
                    .build())
            .build());

        // A flat rate needs no rules at all.
        var flatDaily = new PayConfig("flatDaily", PayConfigArgs.builder()
            .name("Flat daily rate")
            .timezone("America/New_York")
            .currency("USD")
            .baseRateCents(10000)
            .rateTimeUnit("day")
            .build());

    }
}

    resources:
  # A pay config sets what someone is paid for being on call: a base rate, plus rules that
  # override it at particular times. Every rate is in the lowest denomination of the
  # currency, per rate_time_unit, and pay is pro-rated by the second either way.
  platform:
    type: incident:PayConfig
    properties:
      name: Platform on-call
      timezone: Europe/London
      currency: GBP
      baseRateCents: 500 # £5.00 per hour, for any time no rule covers
      rateTimeUnit: hour
      weeklyRules:
        - weekdays:
            - saturday
            - sunday
          startTime: 00:00
          endTime: 00:00
          rateCents: 1500
        - weekdays:
            - monday
            - tuesday
            - wednesday
            - thursday
            - friday
          startTime: 18:00
          endTime: 00:00
          rateCents: 1000
        - weekdays:
            - monday
            - tuesday
            - wednesday
            - thursday
            - friday
          startTime: 00:00
          endTime: 09:00
          rateCents: 1000
      oneOffRules:
        - name: Christmas Day
          startAt: 2026-12-25T00:00:00Z
          endAt: 2026-12-26T00:00:00Z
          rateCents: 3000
        - name: Boxing Day
          startAt: 2026-12-26T00:00:00Z
          endAt: 2026-12-27T00:00:00Z
          rateCents: 2500
  # A flat rate needs no rules at all.
  flatDaily:
    type: incident:PayConfig
    name: flat_daily
    properties:
      name: Flat daily rate
      timezone: America/New_York
      currency: USD
      baseRateCents: 10000 # $100.00 per day
      rateTimeUnit: day

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

# A pay config sets what someone is paid for being on call: a base rate, plus rules that
# override it at particular times. Every rate is in the lowest denomination of the
# currency, per rate_time_unit, and pay is pro-rated by the second either way.
resource "incident_payconfig" "platform" {
  name            = "Platform on-call"
  timezone        = "Europe/London"
  currency        = "GBP"
  base_rate_cents = 500 # £5.00 per hour, for any time no rule covers
  rate_time_unit  = "hour"
  weekly_rules {
    weekdays   = ["saturday", "sunday"]
    start_time = "00:00"
    end_time   = "00:00"
    rate_cents = 1500
  }
  weekly_rules {
    weekdays   = ["monday", "tuesday", "wednesday", "thursday", "friday"]
    start_time = "18:00"
    end_time   = "00:00"
    rate_cents = 1000
  }
  weekly_rules {
    weekdays   = ["monday", "tuesday", "wednesday", "thursday", "friday"]
    start_time = "00:00"
    end_time   = "09:00"
    rate_cents = 1000
  }
  one_off_rules {
    name       = "Christmas Day"
    start_at   = "2026-12-25T00:00:00Z"
    end_at     = "2026-12-26T00:00:00Z"
    rate_cents = 3000
  }
  one_off_rules {
    name       = "Boxing Day"
    start_at   = "2026-12-26T00:00:00Z"
    end_at     = "2026-12-27T00:00:00Z"
    rate_cents = 2500
  }
}
# A flat rate needs no rules at all.
resource "incident_payconfig" "flat_daily" {
  name            = "Flat daily rate"
  timezone        = "America/New_York"
  currency        = "USD"
  base_rate_cents = 10000 # $100.00 per day
  rate_time_unit  = "day"
}

    Create PayConfig Resource

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

    Constructor syntax

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

@overload
def PayConfig(resource_name: str,
              opts: Optional[ResourceOptions] = None,
              base_rate_cents: Optional[int] = None,
              currency: Optional[str] = None,
              rate_time_unit: Optional[str] = None,
              timezone: Optional[str] = None,
              name: Optional[str] = None,
              one_off_rules: Optional[Sequence[PayConfigOneOffRuleArgs]] = None,
              weekly_rules: Optional[Sequence[PayConfigWeeklyRuleArgs]] = None)
    func NewPayConfig(ctx *Context, name string, args PayConfigArgs, opts ...ResourceOption) (*PayConfig, error)
    public PayConfig(string name, PayConfigArgs args, CustomResourceOptions? opts = null)
    public PayConfig(String name, PayConfigArgs args)
public PayConfig(String name, PayConfigArgs args, CustomResourceOptions options)

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


    resource "incident_pay_config" "name" {
    # resource properties
}

    Parameters

    name string
    The unique name of the resource.
    args PayConfigArgs
    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 PayConfigArgs
    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 PayConfigArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args PayConfigArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args PayConfigArgs
    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 payConfigResource = new Incident.PayConfig("payConfigResource", new()
{
    BaseRateCents = 0,
    Currency = "string",
    RateTimeUnit = "string",
    Timezone = "string",
    Name = "string",
    OneOffRules = new[]
    {
        new Incident.Inputs.PayConfigOneOffRuleArgs
        {
            EndAt = "string",
            Name = "string",
            RateCents = 0,
            StartAt = "string",
            Id = "string",
        },
    },
    WeeklyRules = new[]
    {
        new Incident.Inputs.PayConfigWeeklyRuleArgs
        {
            EndTime = "string",
            RateCents = 0,
            StartTime = "string",
            Weekdays = new[]
            {
                "string",
            },
            Id = "string",
        },
    },
});

    example, err := incident.NewPayConfig(ctx, "payConfigResource", &incident.PayConfigArgs{
	BaseRateCents: pulumi.Int(0),
	Currency:      pulumi.String("string"),
	RateTimeUnit:  pulumi.String("string"),
	Timezone:      pulumi.String("string"),
	Name:          pulumi.String("string"),
	OneOffRules: incident.PayConfigOneOffRuleArray{
		&incident.PayConfigOneOffRuleArgs{
			EndAt:     pulumi.String("string"),
			Name:      pulumi.String("string"),
			RateCents: pulumi.Int(0),
			StartAt:   pulumi.String("string"),
			Id:        pulumi.String("string"),
		},
	},
	WeeklyRules: incident.PayConfigWeeklyRuleArray{
		&incident.PayConfigWeeklyRuleArgs{
			EndTime:   pulumi.String("string"),
			RateCents: pulumi.Int(0),
			StartTime: pulumi.String("string"),
			Weekdays: pulumi.StringArray{
				pulumi.String("string"),
			},
			Id: pulumi.String("string"),
		},
	},
})

    resource "incident_pay_config" "payConfigResource" {
  lifecycle {
    create_before_destroy = true
  }
  base_rate_cents = 0
  currency        = "string"
  rate_time_unit  = "string"
  timezone        = "string"
  name            = "string"
  one_off_rules {
    end_at     = "string"
    name       = "string"
    rate_cents = 0
    start_at   = "string"
    id         = "string"
  }
  weekly_rules {
    end_time   = "string"
    rate_cents = 0
    start_time = "string"
    weekdays   = ["string"]
    id         = "string"
  }
}

    var payConfigResource = new PayConfig("payConfigResource", PayConfigArgs.builder()
    .baseRateCents(0)
    .currency("string")
    .rateTimeUnit("string")
    .timezone("string")
    .name("string")
    .oneOffRules(PayConfigOneOffRuleArgs.builder()
        .endAt("string")
        .name("string")
        .rateCents(0)
        .startAt("string")
        .id("string")
        .build())
    .weeklyRules(PayConfigWeeklyRuleArgs.builder()
        .endTime("string")
        .rateCents(0)
        .startTime("string")
        .weekdays("string")
        .id("string")
        .build())
    .build());

    pay_config_resource = incident.PayConfig("payConfigResource",
    base_rate_cents=0,
    currency="string",
    rate_time_unit="string",
    timezone="string",
    name="string",
    one_off_rules=[{
        "end_at": "string",
        "name": "string",
        "rate_cents": 0,
        "start_at": "string",
        "id": "string",
    }],
    weekly_rules=[{
        "end_time": "string",
        "rate_cents": 0,
        "start_time": "string",
        "weekdays": ["string"],
        "id": "string",
    }])

    const payConfigResource = new incident.PayConfig("payConfigResource", {
    baseRateCents: 0,
    currency: "string",
    rateTimeUnit: "string",
    timezone: "string",
    name: "string",
    oneOffRules: [{
        endAt: "string",
        name: "string",
        rateCents: 0,
        startAt: "string",
        id: "string",
    }],
    weeklyRules: [{
        endTime: "string",
        rateCents: 0,
        startTime: "string",
        weekdays: ["string"],
        id: "string",
    }],
});

    type: incident:PayConfig
properties:
    baseRateCents: 0
    currency: string
    name: string
    oneOffRules:
        - endAt: string
          id: string
          name: string
          rateCents: 0
          startAt: string
    rateTimeUnit: string
    timezone: string
    weeklyRules:
        - endTime: string
          id: string
          rateCents: 0
          startTime: string
          weekdays:
            - string

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

    BaseRateCents int
    Rate paid for any time no rule covers, in the lowest denomination of the currency
    Currency string
    Currency this config pays in, in ISO 4217 format, such as GBP.
    RateTimeUnit string
    The unit of time every rate on this config is quoted per. Pay is pro-rated by the second either way. Possible values are: hour, day.
    Timezone string
    IANA timezone this config's rules are interpreted in, such as Europe/London.
    Name string
    Human readable name for this pay config
    OneOffRules List<PayConfigOneOffRule>
    Rules that apply over a single window of time, such as a public holiday. These take precedence over the weekly rules and may not overlap each other. Changing the list changes the rules in place, position by position.
    WeeklyRules List<PayConfigWeeklyRule>
    Rules that apply every week, by day of week and time of day, in evaluation order. The first rule that covers a shift prices it, so order matters. Changing the list changes the rules in place, position by position: a rule that moves keeps its position's ID rather than its own.
    BaseRateCents int
    Rate paid for any time no rule covers, in the lowest denomination of the currency
    Currency string
    Currency this config pays in, in ISO 4217 format, such as GBP.
    RateTimeUnit string
    The unit of time every rate on this config is quoted per. Pay is pro-rated by the second either way. Possible values are: hour, day.
    Timezone string
    IANA timezone this config's rules are interpreted in, such as Europe/London.
    Name string
    Human readable name for this pay config
    OneOffRules []PayConfigOneOffRuleArgs
    Rules that apply over a single window of time, such as a public holiday. These take precedence over the weekly rules and may not overlap each other. Changing the list changes the rules in place, position by position.
    WeeklyRules []PayConfigWeeklyRuleArgs
    Rules that apply every week, by day of week and time of day, in evaluation order. The first rule that covers a shift prices it, so order matters. Changing the list changes the rules in place, position by position: a rule that moves keeps its position's ID rather than its own.
    base_rate_cents number
    Rate paid for any time no rule covers, in the lowest denomination of the currency
    currency string
    Currency this config pays in, in ISO 4217 format, such as GBP.
    rate_time_unit string
    The unit of time every rate on this config is quoted per. Pay is pro-rated by the second either way. Possible values are: hour, day.
    timezone string
    IANA timezone this config's rules are interpreted in, such as Europe/London.
    name string
    Human readable name for this pay config
    one_off_rules list(object)
    Rules that apply over a single window of time, such as a public holiday. These take precedence over the weekly rules and may not overlap each other. Changing the list changes the rules in place, position by position.
    weekly_rules list(object)
    Rules that apply every week, by day of week and time of day, in evaluation order. The first rule that covers a shift prices it, so order matters. Changing the list changes the rules in place, position by position: a rule that moves keeps its position's ID rather than its own.
    baseRateCents Integer
    Rate paid for any time no rule covers, in the lowest denomination of the currency
    currency String
    Currency this config pays in, in ISO 4217 format, such as GBP.
    rateTimeUnit String
    The unit of time every rate on this config is quoted per. Pay is pro-rated by the second either way. Possible values are: hour, day.
    timezone String
    IANA timezone this config's rules are interpreted in, such as Europe/London.
    name String
    Human readable name for this pay config
    oneOffRules List<PayConfigOneOffRule>
    Rules that apply over a single window of time, such as a public holiday. These take precedence over the weekly rules and may not overlap each other. Changing the list changes the rules in place, position by position.
    weeklyRules List<PayConfigWeeklyRule>
    Rules that apply every week, by day of week and time of day, in evaluation order. The first rule that covers a shift prices it, so order matters. Changing the list changes the rules in place, position by position: a rule that moves keeps its position's ID rather than its own.
    baseRateCents number
    Rate paid for any time no rule covers, in the lowest denomination of the currency
    currency string
    Currency this config pays in, in ISO 4217 format, such as GBP.
    rateTimeUnit string
    The unit of time every rate on this config is quoted per. Pay is pro-rated by the second either way. Possible values are: hour, day.
    timezone string
    IANA timezone this config's rules are interpreted in, such as Europe/London.
    name string
    Human readable name for this pay config
    oneOffRules PayConfigOneOffRule[]
    Rules that apply over a single window of time, such as a public holiday. These take precedence over the weekly rules and may not overlap each other. Changing the list changes the rules in place, position by position.
    weeklyRules PayConfigWeeklyRule[]
    Rules that apply every week, by day of week and time of day, in evaluation order. The first rule that covers a shift prices it, so order matters. Changing the list changes the rules in place, position by position: a rule that moves keeps its position's ID rather than its own.
    base_rate_cents int
    Rate paid for any time no rule covers, in the lowest denomination of the currency
    currency str
    Currency this config pays in, in ISO 4217 format, such as GBP.
    rate_time_unit str
    The unit of time every rate on this config is quoted per. Pay is pro-rated by the second either way. Possible values are: hour, day.
    timezone str
    IANA timezone this config's rules are interpreted in, such as Europe/London.
    name str
    Human readable name for this pay config
    one_off_rules Sequence[PayConfigOneOffRuleArgs]
    Rules that apply over a single window of time, such as a public holiday. These take precedence over the weekly rules and may not overlap each other. Changing the list changes the rules in place, position by position.
    weekly_rules Sequence[PayConfigWeeklyRuleArgs]
    Rules that apply every week, by day of week and time of day, in evaluation order. The first rule that covers a shift prices it, so order matters. Changing the list changes the rules in place, position by position: a rule that moves keeps its position's ID rather than its own.
    baseRateCents Number
    Rate paid for any time no rule covers, in the lowest denomination of the currency
    currency String
    Currency this config pays in, in ISO 4217 format, such as GBP.
    rateTimeUnit String
    The unit of time every rate on this config is quoted per. Pay is pro-rated by the second either way. Possible values are: hour, day.
    timezone String
    IANA timezone this config's rules are interpreted in, such as Europe/London.
    name String
    Human readable name for this pay config
    oneOffRules List<Property Map>
    Rules that apply over a single window of time, such as a public holiday. These take precedence over the weekly rules and may not overlap each other. Changing the list changes the rules in place, position by position.
    weeklyRules List<Property Map>
    Rules that apply every week, by day of week and time of day, in evaluation order. The first rule that covers a shift prices it, so order matters. Changing the list changes the rules in place, position by position: a rule that moves keeps its position's ID rather than its own.

    Outputs

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

    CreatedAt string
    When this pay config was created.
    Id string
    The provider-assigned unique ID for this managed resource.
    PublishedAt string
    When a published report first priced against this config. Once set, editing the config needs the schedulepayconfigs.update_published scope. Null until then.
    UpdatedAt string
    When this pay config, or one of its rules, was last changed.
    CreatedAt string
    When this pay config was created.
    Id string
    The provider-assigned unique ID for this managed resource.
    PublishedAt string
    When a published report first priced against this config. Once set, editing the config needs the schedulepayconfigs.update_published scope. Null until then.
    UpdatedAt string
    When this pay config, or one of its rules, was last changed.
    created_at string
    When this pay config was created.
    id string
    The provider-assigned unique ID for this managed resource.
    published_at string
    When a published report first priced against this config. Once set, editing the config needs the schedulepayconfigs.update_published scope. Null until then.
    updated_at string
    When this pay config, or one of its rules, was last changed.
    createdAt String
    When this pay config was created.
    id String
    The provider-assigned unique ID for this managed resource.
    publishedAt String
    When a published report first priced against this config. Once set, editing the config needs the schedulepayconfigs.update_published scope. Null until then.
    updatedAt String
    When this pay config, or one of its rules, was last changed.
    createdAt string
    When this pay config was created.
    id string
    The provider-assigned unique ID for this managed resource.
    publishedAt string
    When a published report first priced against this config. Once set, editing the config needs the schedulepayconfigs.update_published scope. Null until then.
    updatedAt string
    When this pay config, or one of its rules, was last changed.
    created_at str
    When this pay config was created.
    id str
    The provider-assigned unique ID for this managed resource.
    published_at str
    When a published report first priced against this config. Once set, editing the config needs the schedulepayconfigs.update_published scope. Null until then.
    updated_at str
    When this pay config, or one of its rules, was last changed.
    createdAt String
    When this pay config was created.
    id String
    The provider-assigned unique ID for this managed resource.
    publishedAt String
    When a published report first priced against this config. Once set, editing the config needs the schedulepayconfigs.update_published scope. Null until then.
    updatedAt String
    When this pay config, or one of its rules, was last changed.

    Look up Existing PayConfig Resource

    Get an existing PayConfig 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?: PayConfigState, opts?: CustomResourceOptions): PayConfig
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        base_rate_cents: Optional[int] = None,
        created_at: Optional[str] = None,
        currency: Optional[str] = None,
        name: Optional[str] = None,
        one_off_rules: Optional[Sequence[PayConfigOneOffRuleArgs]] = None,
        published_at: Optional[str] = None,
        rate_time_unit: Optional[str] = None,
        timezone: Optional[str] = None,
        updated_at: Optional[str] = None,
        weekly_rules: Optional[Sequence[PayConfigWeeklyRuleArgs]] = None) -> PayConfig
    func GetPayConfig(ctx *Context, name string, id IDInput, state *PayConfigState, opts ...ResourceOption) (*PayConfig, error)
    public static PayConfig Get(string name, Input<string> id, PayConfigState? state, CustomResourceOptions? opts = null)
    public static PayConfig get(String name, Output<String> id, PayConfigState state, CustomResourceOptions options)
    resources:  _:    type: incident:PayConfig    get:      id: ${id}
    import {
  to = incident_pay_config.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:
    BaseRateCents int
    Rate paid for any time no rule covers, in the lowest denomination of the currency
    CreatedAt string
    When this pay config was created.
    Currency string
    Currency this config pays in, in ISO 4217 format, such as GBP.
    Name string
    Human readable name for this pay config
    OneOffRules List<PayConfigOneOffRule>
    Rules that apply over a single window of time, such as a public holiday. These take precedence over the weekly rules and may not overlap each other. Changing the list changes the rules in place, position by position.
    PublishedAt string
    When a published report first priced against this config. Once set, editing the config needs the schedulepayconfigs.update_published scope. Null until then.
    RateTimeUnit string
    The unit of time every rate on this config is quoted per. Pay is pro-rated by the second either way. Possible values are: hour, day.
    Timezone string
    IANA timezone this config's rules are interpreted in, such as Europe/London.
    UpdatedAt string
    When this pay config, or one of its rules, was last changed.
    WeeklyRules List<PayConfigWeeklyRule>
    Rules that apply every week, by day of week and time of day, in evaluation order. The first rule that covers a shift prices it, so order matters. Changing the list changes the rules in place, position by position: a rule that moves keeps its position's ID rather than its own.
    BaseRateCents int
    Rate paid for any time no rule covers, in the lowest denomination of the currency
    CreatedAt string
    When this pay config was created.
    Currency string
    Currency this config pays in, in ISO 4217 format, such as GBP.
    Name string
    Human readable name for this pay config
    OneOffRules []PayConfigOneOffRuleArgs
    Rules that apply over a single window of time, such as a public holiday. These take precedence over the weekly rules and may not overlap each other. Changing the list changes the rules in place, position by position.
    PublishedAt string
    When a published report first priced against this config. Once set, editing the config needs the schedulepayconfigs.update_published scope. Null until then.
    RateTimeUnit string
    The unit of time every rate on this config is quoted per. Pay is pro-rated by the second either way. Possible values are: hour, day.
    Timezone string
    IANA timezone this config's rules are interpreted in, such as Europe/London.
    UpdatedAt string
    When this pay config, or one of its rules, was last changed.
    WeeklyRules []PayConfigWeeklyRuleArgs
    Rules that apply every week, by day of week and time of day, in evaluation order. The first rule that covers a shift prices it, so order matters. Changing the list changes the rules in place, position by position: a rule that moves keeps its position's ID rather than its own.
    base_rate_cents number
    Rate paid for any time no rule covers, in the lowest denomination of the currency
    created_at string
    When this pay config was created.
    currency string
    Currency this config pays in, in ISO 4217 format, such as GBP.
    name string
    Human readable name for this pay config
    one_off_rules list(object)
    Rules that apply over a single window of time, such as a public holiday. These take precedence over the weekly rules and may not overlap each other. Changing the list changes the rules in place, position by position.
    published_at string
    When a published report first priced against this config. Once set, editing the config needs the schedulepayconfigs.update_published scope. Null until then.
    rate_time_unit string
    The unit of time every rate on this config is quoted per. Pay is pro-rated by the second either way. Possible values are: hour, day.
    timezone string
    IANA timezone this config's rules are interpreted in, such as Europe/London.
    updated_at string
    When this pay config, or one of its rules, was last changed.
    weekly_rules list(object)
    Rules that apply every week, by day of week and time of day, in evaluation order. The first rule that covers a shift prices it, so order matters. Changing the list changes the rules in place, position by position: a rule that moves keeps its position's ID rather than its own.
    baseRateCents Integer
    Rate paid for any time no rule covers, in the lowest denomination of the currency
    createdAt String
    When this pay config was created.
    currency String
    Currency this config pays in, in ISO 4217 format, such as GBP.
    name String
    Human readable name for this pay config
    oneOffRules List<PayConfigOneOffRule>
    Rules that apply over a single window of time, such as a public holiday. These take precedence over the weekly rules and may not overlap each other. Changing the list changes the rules in place, position by position.
    publishedAt String
    When a published report first priced against this config. Once set, editing the config needs the schedulepayconfigs.update_published scope. Null until then.
    rateTimeUnit String
    The unit of time every rate on this config is quoted per. Pay is pro-rated by the second either way. Possible values are: hour, day.
    timezone String
    IANA timezone this config's rules are interpreted in, such as Europe/London.
    updatedAt String
    When this pay config, or one of its rules, was last changed.
    weeklyRules List<PayConfigWeeklyRule>
    Rules that apply every week, by day of week and time of day, in evaluation order. The first rule that covers a shift prices it, so order matters. Changing the list changes the rules in place, position by position: a rule that moves keeps its position's ID rather than its own.
    baseRateCents number
    Rate paid for any time no rule covers, in the lowest denomination of the currency
    createdAt string
    When this pay config was created.
    currency string
    Currency this config pays in, in ISO 4217 format, such as GBP.
    name string
    Human readable name for this pay config
    oneOffRules PayConfigOneOffRule[]
    Rules that apply over a single window of time, such as a public holiday. These take precedence over the weekly rules and may not overlap each other. Changing the list changes the rules in place, position by position.
    publishedAt string
    When a published report first priced against this config. Once set, editing the config needs the schedulepayconfigs.update_published scope. Null until then.
    rateTimeUnit string
    The unit of time every rate on this config is quoted per. Pay is pro-rated by the second either way. Possible values are: hour, day.
    timezone string
    IANA timezone this config's rules are interpreted in, such as Europe/London.
    updatedAt string
    When this pay config, or one of its rules, was last changed.
    weeklyRules PayConfigWeeklyRule[]
    Rules that apply every week, by day of week and time of day, in evaluation order. The first rule that covers a shift prices it, so order matters. Changing the list changes the rules in place, position by position: a rule that moves keeps its position's ID rather than its own.
    base_rate_cents int
    Rate paid for any time no rule covers, in the lowest denomination of the currency
    created_at str
    When this pay config was created.
    currency str
    Currency this config pays in, in ISO 4217 format, such as GBP.
    name str
    Human readable name for this pay config
    one_off_rules Sequence[PayConfigOneOffRuleArgs]
    Rules that apply over a single window of time, such as a public holiday. These take precedence over the weekly rules and may not overlap each other. Changing the list changes the rules in place, position by position.
    published_at str
    When a published report first priced against this config. Once set, editing the config needs the schedulepayconfigs.update_published scope. Null until then.
    rate_time_unit str
    The unit of time every rate on this config is quoted per. Pay is pro-rated by the second either way. Possible values are: hour, day.
    timezone str
    IANA timezone this config's rules are interpreted in, such as Europe/London.
    updated_at str
    When this pay config, or one of its rules, was last changed.
    weekly_rules Sequence[PayConfigWeeklyRuleArgs]
    Rules that apply every week, by day of week and time of day, in evaluation order. The first rule that covers a shift prices it, so order matters. Changing the list changes the rules in place, position by position: a rule that moves keeps its position's ID rather than its own.
    baseRateCents Number
    Rate paid for any time no rule covers, in the lowest denomination of the currency
    createdAt String
    When this pay config was created.
    currency String
    Currency this config pays in, in ISO 4217 format, such as GBP.
    name String
    Human readable name for this pay config
    oneOffRules List<Property Map>
    Rules that apply over a single window of time, such as a public holiday. These take precedence over the weekly rules and may not overlap each other. Changing the list changes the rules in place, position by position.
    publishedAt String
    When a published report first priced against this config. Once set, editing the config needs the schedulepayconfigs.update_published scope. Null until then.
    rateTimeUnit String
    The unit of time every rate on this config is quoted per. Pay is pro-rated by the second either way. Possible values are: hour, day.
    timezone String
    IANA timezone this config's rules are interpreted in, such as Europe/London.
    updatedAt String
    When this pay config, or one of its rules, was last changed.
    weeklyRules List<Property Map>
    Rules that apply every week, by day of week and time of day, in evaluation order. The first rule that covers a shift prices it, so order matters. Changing the list changes the rules in place, position by position: a rule that moves keeps its position's ID rather than its own.

    Supporting Types

    PayConfigOneOffRule, PayConfigOneOffRuleArgs

    EndAt string
    When this rule stops applying, as an RFC 3339 timestamp.
    Name string
    Human readable name for this rule
    RateCents int
    Rate paid while this rule applies, in the lowest denomination of the config's currency
    StartAt string
    When this rule starts applying, as an RFC 3339 timestamp. Any offset works: the API reports the same moment in UTC, and that is not a change.
    Id string
    Unique identifier for this rule, stable across edits to the config
    EndAt string
    When this rule stops applying, as an RFC 3339 timestamp.
    Name string
    Human readable name for this rule
    RateCents int
    Rate paid while this rule applies, in the lowest denomination of the config's currency
    StartAt string
    When this rule starts applying, as an RFC 3339 timestamp. Any offset works: the API reports the same moment in UTC, and that is not a change.
    Id string
    Unique identifier for this rule, stable across edits to the config
    end_at string
    When this rule stops applying, as an RFC 3339 timestamp.
    name string
    Human readable name for this rule
    rate_cents number
    Rate paid while this rule applies, in the lowest denomination of the config's currency
    start_at string
    When this rule starts applying, as an RFC 3339 timestamp. Any offset works: the API reports the same moment in UTC, and that is not a change.
    id string
    Unique identifier for this rule, stable across edits to the config
    endAt String
    When this rule stops applying, as an RFC 3339 timestamp.
    name String
    Human readable name for this rule
    rateCents Integer
    Rate paid while this rule applies, in the lowest denomination of the config's currency
    startAt String
    When this rule starts applying, as an RFC 3339 timestamp. Any offset works: the API reports the same moment in UTC, and that is not a change.
    id String
    Unique identifier for this rule, stable across edits to the config
    endAt string
    When this rule stops applying, as an RFC 3339 timestamp.
    name string
    Human readable name for this rule
    rateCents number
    Rate paid while this rule applies, in the lowest denomination of the config's currency
    startAt string
    When this rule starts applying, as an RFC 3339 timestamp. Any offset works: the API reports the same moment in UTC, and that is not a change.
    id string
    Unique identifier for this rule, stable across edits to the config
    end_at str
    When this rule stops applying, as an RFC 3339 timestamp.
    name str
    Human readable name for this rule
    rate_cents int
    Rate paid while this rule applies, in the lowest denomination of the config's currency
    start_at str
    When this rule starts applying, as an RFC 3339 timestamp. Any offset works: the API reports the same moment in UTC, and that is not a change.
    id str
    Unique identifier for this rule, stable across edits to the config
    endAt String
    When this rule stops applying, as an RFC 3339 timestamp.
    name String
    Human readable name for this rule
    rateCents Number
    Rate paid while this rule applies, in the lowest denomination of the config's currency
    startAt String
    When this rule starts applying, as an RFC 3339 timestamp. Any offset works: the API reports the same moment in UTC, and that is not a change.
    id String
    Unique identifier for this rule, stable across edits to the config

    PayConfigWeeklyRule, PayConfigWeeklyRuleArgs

    EndTime string
    Time of day this rule ends, in 24 hour format, as HH:MM. It is read on the same day as startTime, so it must be later in that day, or 00:00 for midnight at the end of it — 00:00 to 00:00 is the whole day. A rule that runs past midnight is written as two: one ending at 00:00, and one starting there on the following days.
    RateCents int
    Rate paid while this rule applies, in the lowest denomination of the config's currency
    StartTime string
    Time of day this rule starts, in 24 hour format, as HH:MM.
    Weekdays List<string>
    Days of the week this rule applies on. Possible values are: monday, tuesday, wednesday, thursday, friday, saturday, sunday.
    Id string
    Unique identifier for this rule, stable across edits to the config
    EndTime string
    Time of day this rule ends, in 24 hour format, as HH:MM. It is read on the same day as startTime, so it must be later in that day, or 00:00 for midnight at the end of it — 00:00 to 00:00 is the whole day. A rule that runs past midnight is written as two: one ending at 00:00, and one starting there on the following days.
    RateCents int
    Rate paid while this rule applies, in the lowest denomination of the config's currency
    StartTime string
    Time of day this rule starts, in 24 hour format, as HH:MM.
    Weekdays []string
    Days of the week this rule applies on. Possible values are: monday, tuesday, wednesday, thursday, friday, saturday, sunday.
    Id string
    Unique identifier for this rule, stable across edits to the config
    end_time string
    Time of day this rule ends, in 24 hour format, as HH:MM. It is read on the same day as startTime, so it must be later in that day, or 00:00 for midnight at the end of it — 00:00 to 00:00 is the whole day. A rule that runs past midnight is written as two: one ending at 00:00, and one starting there on the following days.
    rate_cents number
    Rate paid while this rule applies, in the lowest denomination of the config's currency
    start_time string
    Time of day this rule starts, in 24 hour format, as HH:MM.
    weekdays list(string)
    Days of the week this rule applies on. Possible values are: monday, tuesday, wednesday, thursday, friday, saturday, sunday.
    id string
    Unique identifier for this rule, stable across edits to the config
    endTime String
    Time of day this rule ends, in 24 hour format, as HH:MM. It is read on the same day as startTime, so it must be later in that day, or 00:00 for midnight at the end of it — 00:00 to 00:00 is the whole day. A rule that runs past midnight is written as two: one ending at 00:00, and one starting there on the following days.
    rateCents Integer
    Rate paid while this rule applies, in the lowest denomination of the config's currency
    startTime String
    Time of day this rule starts, in 24 hour format, as HH:MM.
    weekdays List<String>
    Days of the week this rule applies on. Possible values are: monday, tuesday, wednesday, thursday, friday, saturday, sunday.
    id String
    Unique identifier for this rule, stable across edits to the config
    endTime string
    Time of day this rule ends, in 24 hour format, as HH:MM. It is read on the same day as startTime, so it must be later in that day, or 00:00 for midnight at the end of it — 00:00 to 00:00 is the whole day. A rule that runs past midnight is written as two: one ending at 00:00, and one starting there on the following days.
    rateCents number
    Rate paid while this rule applies, in the lowest denomination of the config's currency
    startTime string
    Time of day this rule starts, in 24 hour format, as HH:MM.
    weekdays string[]
    Days of the week this rule applies on. Possible values are: monday, tuesday, wednesday, thursday, friday, saturday, sunday.
    id string
    Unique identifier for this rule, stable across edits to the config
    end_time str
    Time of day this rule ends, in 24 hour format, as HH:MM. It is read on the same day as startTime, so it must be later in that day, or 00:00 for midnight at the end of it — 00:00 to 00:00 is the whole day. A rule that runs past midnight is written as two: one ending at 00:00, and one starting there on the following days.
    rate_cents int
    Rate paid while this rule applies, in the lowest denomination of the config's currency
    start_time str
    Time of day this rule starts, in 24 hour format, as HH:MM.
    weekdays Sequence[str]
    Days of the week this rule applies on. Possible values are: monday, tuesday, wednesday, thursday, friday, saturday, sunday.
    id str
    Unique identifier for this rule, stable across edits to the config
    endTime String
    Time of day this rule ends, in 24 hour format, as HH:MM. It is read on the same day as startTime, so it must be later in that day, or 00:00 for midnight at the end of it — 00:00 to 00:00 is the whole day. A rule that runs past midnight is written as two: one ending at 00:00, and one starting there on the following days.
    rateCents Number
    Rate paid while this rule applies, in the lowest denomination of the config's currency
    startTime String
    Time of day this rule starts, in 24 hour format, as HH:MM.
    weekdays List<String>
    Days of the week this rule applies on. Possible values are: monday, tuesday, wednesday, thursday, friday, saturday, sunday.
    id String
    Unique identifier for this rule, stable across edits to the config

    Import

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

    The pulumi import command can be used, for example:

    !/bin/bash

    Import a pay config using its ID Replace the ID with a real ID from your incident.io organization

    $ pulumi import incident:index/payConfig:PayConfig example 01ABC123DEF456GHI789JKL

    The rules come with it, in the order the API holds them. Write weeklyRules in your configuration in that same order, or the first plan updates every rule that moved.

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

    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