pagerduty.getSchedulev2

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

const oncall = pagerduty.getSchedulev2({
    name: "Engineering On-Call",
});
const example = new pagerduty.EscalationPolicy("example", {
    name: "Engineering Escalation Policy",
    numLoops: 2,
    rules: [{
        escalationDelayInMinutes: 10,
        targets: [{
            type: "schedule_reference",
            id: oncall.then(oncall => oncall.id),
        }],
    }],
});

import pulumi
import pulumi_pagerduty as pagerduty

oncall = pagerduty.get_schedulev2(name="Engineering On-Call")
example = pagerduty.EscalationPolicy("example",
    name="Engineering Escalation Policy",
    num_loops=2,
    rules=[{
        "escalation_delay_in_minutes": 10,
        "targets": [{
            "type": "schedule_reference",
            "id": oncall.id,
        }],
    }])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		oncall, err := pagerduty.LookupSchedulev2(ctx, &pagerduty.LookupSchedulev2Args{
			Name: "Engineering On-Call",
		}, nil)
		if err != nil {
			return err
		}
		_, err = pagerduty.NewEscalationPolicy(ctx, "example", &pagerduty.EscalationPolicyArgs{
			Name:     pulumi.String("Engineering Escalation Policy"),
			NumLoops: pulumi.Int(2),
			Rules: pagerduty.EscalationPolicyRuleArray{
				&pagerduty.EscalationPolicyRuleArgs{
					EscalationDelayInMinutes: pulumi.Int(10),
					Targets: pagerduty.EscalationPolicyRuleTargetArray{
						&pagerduty.EscalationPolicyRuleTargetArgs{
							Type: pulumi.String("schedule_reference"),
							Id:   pulumi.String(oncall.Id),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var oncall = Pagerduty.GetSchedulev2.Invoke(new()
    {
        Name = "Engineering On-Call",
    });

    var example = new Pagerduty.EscalationPolicy("example", new()
    {
        Name = "Engineering Escalation Policy",
        NumLoops = 2,
        Rules = new[]
        {
            new Pagerduty.Inputs.EscalationPolicyRuleArgs
            {
                EscalationDelayInMinutes = 10,
                Targets = new[]
                {
                    new Pagerduty.Inputs.EscalationPolicyRuleTargetArgs
                    {
                        Type = "schedule_reference",
                        Id = oncall.Apply(getSchedulev2Result => getSchedulev2Result.Id),
                    },
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.pagerduty.PagerdutyFunctions;
import com.pulumi.pagerduty.inputs.GetSchedulev2Args;
import com.pulumi.pagerduty.EscalationPolicy;
import com.pulumi.pagerduty.EscalationPolicyArgs;
import com.pulumi.pagerduty.inputs.EscalationPolicyRuleArgs;
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) {
        final var oncall = PagerdutyFunctions.getSchedulev2(GetSchedulev2Args.builder()
            .name("Engineering On-Call")
            .build());

        var example = new EscalationPolicy("example", EscalationPolicyArgs.builder()
            .name("Engineering Escalation Policy")
            .numLoops(2)
            .rules(EscalationPolicyRuleArgs.builder()
                .escalationDelayInMinutes(10)
                .targets(EscalationPolicyRuleTargetArgs.builder()
                    .type("schedule_reference")
                    .id(oncall.id())
                    .build())
                .build())
            .build());

    }
}

resources:
  example:
    type: pagerduty:EscalationPolicy
    properties:
      name: Engineering Escalation Policy
      numLoops: 2
      rules:
        - escalationDelayInMinutes: 10
          targets:
            - type: schedule_reference
              id: ${oncall.id}
variables:
  oncall:
    fn::invoke:
      function: pagerduty:getSchedulev2
      arguments:
        name: Engineering On-Call

function getSchedulev2(args: GetSchedulev2Args, opts?: InvokeOptions): Promise<GetSchedulev2Result>
function getSchedulev2Output(args: GetSchedulev2OutputArgs, opts?: InvokeOptions): Output<GetSchedulev2Result>

def get_schedulev2(name: Optional[str] = None,
                   opts: Optional[InvokeOptions] = None) -> GetSchedulev2Result
def get_schedulev2_output(name: Optional[pulumi.Input[str]] = None,
                   opts: Optional[InvokeOptions] = None) -> Output[GetSchedulev2Result]

func LookupSchedulev2(ctx *Context, args *LookupSchedulev2Args, opts ...InvokeOption) (*LookupSchedulev2Result, error)
func LookupSchedulev2Output(ctx *Context, args *LookupSchedulev2OutputArgs, opts ...InvokeOption) LookupSchedulev2ResultOutput

public static class GetSchedulev2 
{
    public static Task<GetSchedulev2Result> InvokeAsync(GetSchedulev2Args args, InvokeOptions? opts = null)
    public static Output<GetSchedulev2Result> Invoke(GetSchedulev2InvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetSchedulev2Result> getSchedulev2(GetSchedulev2Args args, InvokeOptions options)
public static Output<GetSchedulev2Result> getSchedulev2(GetSchedulev2Args args, InvokeOptions options)

fn::invoke:
  function: pagerduty:index/getSchedulev2:getSchedulev2
  arguments:
    # arguments dictionary