pagerduty.ServiceDependency

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

const foo = new pagerduty.ServiceDependency("foo", {dependency: {
    dependentServices: [{
        id: fooPagerdutyBusinessService.id,
        type: fooPagerdutyBusinessService.type,
    }],
    supportingServices: [{
        id: fooPagerdutyService.id,
        type: fooPagerdutyService.type,
    }],
}});
const bar = new pagerduty.ServiceDependency("bar", {dependency: {
    dependentServices: [{
        id: fooPagerdutyBusinessService.id,
        type: fooPagerdutyBusinessService.type,
    }],
    supportingServices: [{
        id: two.id,
        type: two.type,
    }],
}});

import pulumi
import pulumi_pagerduty as pagerduty

foo = pagerduty.ServiceDependency("foo", dependency={
    "dependent_services": [{
        "id": foo_pagerduty_business_service["id"],
        "type": foo_pagerduty_business_service["type"],
    }],
    "supporting_services": [{
        "id": foo_pagerduty_service["id"],
        "type": foo_pagerduty_service["type"],
    }],
})
bar = pagerduty.ServiceDependency("bar", dependency={
    "dependent_services": [{
        "id": foo_pagerduty_business_service["id"],
        "type": foo_pagerduty_business_service["type"],
    }],
    "supporting_services": [{
        "id": two["id"],
        "type": two["type"],
    }],
})

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 {
		_, err := pagerduty.NewServiceDependency(ctx, "foo", &pagerduty.ServiceDependencyArgs{
			Dependency: &pagerduty.ServiceDependencyDependencyArgs{
				DependentServices: pagerduty.ServiceDependencyDependencyDependentServiceArray{
					&pagerduty.ServiceDependencyDependencyDependentServiceArgs{
						Id:   pulumi.Any(fooPagerdutyBusinessService.Id),
						Type: pulumi.Any(fooPagerdutyBusinessService.Type),
					},
				},
				SupportingServices: pagerduty.ServiceDependencyDependencySupportingServiceArray{
					&pagerduty.ServiceDependencyDependencySupportingServiceArgs{
						Id:   pulumi.Any(fooPagerdutyService.Id),
						Type: pulumi.Any(fooPagerdutyService.Type),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = pagerduty.NewServiceDependency(ctx, "bar", &pagerduty.ServiceDependencyArgs{
			Dependency: &pagerduty.ServiceDependencyDependencyArgs{
				DependentServices: pagerduty.ServiceDependencyDependencyDependentServiceArray{
					&pagerduty.ServiceDependencyDependencyDependentServiceArgs{
						Id:   pulumi.Any(fooPagerdutyBusinessService.Id),
						Type: pulumi.Any(fooPagerdutyBusinessService.Type),
					},
				},
				SupportingServices: pagerduty.ServiceDependencyDependencySupportingServiceArray{
					&pagerduty.ServiceDependencyDependencySupportingServiceArgs{
						Id:   pulumi.Any(two.Id),
						Type: pulumi.Any(two.Type),
					},
				},
			},
		})
		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 foo = new Pagerduty.ServiceDependency("foo", new()
    {
        Dependency = new Pagerduty.Inputs.ServiceDependencyDependencyArgs
        {
            DependentServices = new[]
            {
                new Pagerduty.Inputs.ServiceDependencyDependencyDependentServiceArgs
                {
                    Id = fooPagerdutyBusinessService.Id,
                    Type = fooPagerdutyBusinessService.Type,
                },
            },
            SupportingServices = new[]
            {
                new Pagerduty.Inputs.ServiceDependencyDependencySupportingServiceArgs
                {
                    Id = fooPagerdutyService.Id,
                    Type = fooPagerdutyService.Type,
                },
            },
        },
    });

    var bar = new Pagerduty.ServiceDependency("bar", new()
    {
        Dependency = new Pagerduty.Inputs.ServiceDependencyDependencyArgs
        {
            DependentServices = new[]
            {
                new Pagerduty.Inputs.ServiceDependencyDependencyDependentServiceArgs
                {
                    Id = fooPagerdutyBusinessService.Id,
                    Type = fooPagerdutyBusinessService.Type,
                },
            },
            SupportingServices = new[]
            {
                new Pagerduty.Inputs.ServiceDependencyDependencySupportingServiceArgs
                {
                    Id = two.Id,
                    Type = two.Type,
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.pagerduty.ServiceDependency;
import com.pulumi.pagerduty.ServiceDependencyArgs;
import com.pulumi.pagerduty.inputs.ServiceDependencyDependencyArgs;
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) {
        var foo = new ServiceDependency("foo", ServiceDependencyArgs.builder()
            .dependency(ServiceDependencyDependencyArgs.builder()
                .dependentServices(ServiceDependencyDependencyDependentServiceArgs.builder()
                    .id(fooPagerdutyBusinessService.id())
                    .type(fooPagerdutyBusinessService.type())
                    .build())
                .supportingServices(ServiceDependencyDependencySupportingServiceArgs.builder()
                    .id(fooPagerdutyService.id())
                    .type(fooPagerdutyService.type())
                    .build())
                .build())
            .build());

        var bar = new ServiceDependency("bar", ServiceDependencyArgs.builder()
            .dependency(ServiceDependencyDependencyArgs.builder()
                .dependentServices(ServiceDependencyDependencyDependentServiceArgs.builder()
                    .id(fooPagerdutyBusinessService.id())
                    .type(fooPagerdutyBusinessService.type())
                    .build())
                .supportingServices(ServiceDependencyDependencySupportingServiceArgs.builder()
                    .id(two.id())
                    .type(two.type())
                    .build())
                .build())
            .build());

    }
}

resources:
  foo:
    type: pagerduty:ServiceDependency
    properties:
      dependency:
        dependentServices:
          - id: ${fooPagerdutyBusinessService.id}
            type: ${fooPagerdutyBusinessService.type}
        supportingServices:
          - id: ${fooPagerdutyService.id}
            type: ${fooPagerdutyService.type}
  bar:
    type: pagerduty:ServiceDependency
    properties:
      dependency:
        dependentServices:
          - id: ${fooPagerdutyBusinessService.id}
            type: ${fooPagerdutyBusinessService.type}
        supportingServices:
          - id: ${two.id}
            type: ${two.type}

var serviceDependencyResource = new Pagerduty.ServiceDependency("serviceDependencyResource", new()
{
    Dependency = new Pagerduty.Inputs.ServiceDependencyDependencyArgs
    {
        DependentServices = new[]
        {
            new Pagerduty.Inputs.ServiceDependencyDependencyDependentServiceArgs
            {
                Id = "string",
                Type = "string",
            },
        },
        SupportingServices = new[]
        {
            new Pagerduty.Inputs.ServiceDependencyDependencySupportingServiceArgs
            {
                Id = "string",
                Type = "string",
            },
        },
        Type = "string",
    },
});

example, err := pagerduty.NewServiceDependency(ctx, "serviceDependencyResource", &pagerduty.ServiceDependencyArgs{
	Dependency: &pagerduty.ServiceDependencyDependencyArgs{
		DependentServices: pagerduty.ServiceDependencyDependencyDependentServiceArray{
			&pagerduty.ServiceDependencyDependencyDependentServiceArgs{
				Id:   pulumi.String("string"),
				Type: pulumi.String("string"),
			},
		},
		SupportingServices: pagerduty.ServiceDependencyDependencySupportingServiceArray{
			&pagerduty.ServiceDependencyDependencySupportingServiceArgs{
				Id:   pulumi.String("string"),
				Type: pulumi.String("string"),
			},
		},
		Type: pulumi.String("string"),
	},
})

var serviceDependencyResource = new ServiceDependency("serviceDependencyResource", ServiceDependencyArgs.builder()
    .dependency(ServiceDependencyDependencyArgs.builder()
        .dependentServices(ServiceDependencyDependencyDependentServiceArgs.builder()
            .id("string")
            .type("string")
            .build())
        .supportingServices(ServiceDependencyDependencySupportingServiceArgs.builder()
            .id("string")
            .type("string")
            .build())
        .type("string")
        .build())
    .build());

service_dependency_resource = pagerduty.ServiceDependency("serviceDependencyResource", dependency={
    "dependent_services": [{
        "id": "string",
        "type": "string",
    }],
    "supporting_services": [{
        "id": "string",
        "type": "string",
    }],
    "type": "string",
})

const serviceDependencyResource = new pagerduty.ServiceDependency("serviceDependencyResource", {dependency: {
    dependentServices: [{
        id: "string",
        type: "string",
    }],
    supportingServices: [{
        id: "string",
        type: "string",
    }],
    type: "string",
}});

type: pagerduty:ServiceDependency
properties:
    dependency:
        dependentServices:
            - id: string
              type: string
        supportingServices:
            - id: string
              type: string
        type: string