pagerduty.ServiceCustomFieldValue

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

// First, create a service custom field
const environment = new pagerduty.ServiceCustomField("environment", {
    name: "environment",
    displayName: "Environment",
    dataType: "string",
    fieldType: "single_value",
    description: "The environment this service runs in",
});
// Create a service
const example = new pagerduty.Service("example", {
    name: "Example Service",
    autoResolveTimeout: "14400",
    acknowledgementTimeout: "600",
    escalationPolicy: examplePagerdutyEscalationPolicy.id,
});
// Set a custom field value on the service
const exampleServiceCustomFieldValue = new pagerduty.ServiceCustomFieldValue("example", {
    serviceId: example.id,
    customFields: [{
        name: environment.name,
        value: JSON.stringify("production"),
    }],
});
// Set multiple custom field values on a service
const region = new pagerduty.ServiceCustomField("region", {
    name: "region",
    displayName: "Region",
    dataType: "string",
    fieldType: "single_value",
    description: "The region this service is deployed in",
});
const multipleExample = new pagerduty.ServiceCustomFieldValue("multiple_example", {
    serviceId: example.id,
    customFields: [
        {
            name: environment.name,
            value: JSON.stringify("production"),
        },
        {
            name: region.name,
            value: JSON.stringify("us-east-1"),
        },
    ],
});
// Example with a boolean field
const isCritical = new pagerduty.ServiceCustomField("is_critical", {
    name: "is_critical",
    displayName: "Is Critical",
    dataType: "boolean",
    fieldType: "single_value",
    description: "Whether this service is critical",
});
const booleanExample = new pagerduty.ServiceCustomFieldValue("boolean_example", {
    serviceId: example.id,
    customFields: [{
        name: isCritical.name,
        value: JSON.stringify(true),
    }],
});
// Example with a multi-value field
const regions = new pagerduty.ServiceCustomField("regions", {
    name: "regions",
    displayName: "AWS Regions",
    dataType: "string",
    fieldType: "multi_value_fixed",
    description: "AWS regions where this service is deployed",
    fieldOptions: [
        {
            value: "us-east-1",
            dataType: "string",
        },
        {
            value: "us-west-1",
            dataType: "string",
        },
    ],
});
const multiValueExample = new pagerduty.ServiceCustomFieldValue("multi_value_example", {
    serviceId: example.id,
    customFields: [{
        name: regions.name,
        value: JSON.stringify([
            "us-east-1",
            "us-west-1",
        ]),
    }],
});

import pulumi
import json
import pulumi_pagerduty as pagerduty

# First, create a service custom field
environment = pagerduty.ServiceCustomField("environment",
    name="environment",
    display_name="Environment",
    data_type="string",
    field_type="single_value",
    description="The environment this service runs in")
# Create a service
example = pagerduty.Service("example",
    name="Example Service",
    auto_resolve_timeout="14400",
    acknowledgement_timeout="600",
    escalation_policy=example_pagerduty_escalation_policy["id"])
# Set a custom field value on the service
example_service_custom_field_value = pagerduty.ServiceCustomFieldValue("example",
    service_id=example.id,
    custom_fields=[{
        "name": environment.name,
        "value": json.dumps("production"),
    }])
# Set multiple custom field values on a service
region = pagerduty.ServiceCustomField("region",
    name="region",
    display_name="Region",
    data_type="string",
    field_type="single_value",
    description="The region this service is deployed in")
multiple_example = pagerduty.ServiceCustomFieldValue("multiple_example",
    service_id=example.id,
    custom_fields=[
        {
            "name": environment.name,
            "value": json.dumps("production"),
        },
        {
            "name": region.name,
            "value": json.dumps("us-east-1"),
        },
    ])
# Example with a boolean field
is_critical = pagerduty.ServiceCustomField("is_critical",
    name="is_critical",
    display_name="Is Critical",
    data_type="boolean",
    field_type="single_value",
    description="Whether this service is critical")
boolean_example = pagerduty.ServiceCustomFieldValue("boolean_example",
    service_id=example.id,
    custom_fields=[{
        "name": is_critical.name,
        "value": json.dumps(True),
    }])
# Example with a multi-value field
regions = pagerduty.ServiceCustomField("regions",
    name="regions",
    display_name="AWS Regions",
    data_type="string",
    field_type="multi_value_fixed",
    description="AWS regions where this service is deployed",
    field_options=[
        {
            "value": "us-east-1",
            "data_type": "string",
        },
        {
            "value": "us-west-1",
            "data_type": "string",
        },
    ])
multi_value_example = pagerduty.ServiceCustomFieldValue("multi_value_example",
    service_id=example.id,
    custom_fields=[{
        "name": regions.name,
        "value": json.dumps([
            "us-east-1",
            "us-west-1",
        ]),
    }])

package main

import (
	"encoding/json"

	"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 {
		// First, create a service custom field
		environment, err := pagerduty.NewServiceCustomField(ctx, "environment", &pagerduty.ServiceCustomFieldArgs{
			Name:        pulumi.String("environment"),
			DisplayName: pulumi.String("Environment"),
			DataType:    pulumi.String("string"),
			FieldType:   pulumi.String("single_value"),
			Description: pulumi.String("The environment this service runs in"),
		})
		if err != nil {
			return err
		}
		// Create a service
		example, err := pagerduty.NewService(ctx, "example", &pagerduty.ServiceArgs{
			Name:                   pulumi.String("Example Service"),
			AutoResolveTimeout:     pulumi.String("14400"),
			AcknowledgementTimeout: pulumi.String("600"),
			EscalationPolicy:       pulumi.Any(examplePagerdutyEscalationPolicy.Id),
		})
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal("production")
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		// Set a custom field value on the service
		_, err = pagerduty.NewServiceCustomFieldValue(ctx, "example", &pagerduty.ServiceCustomFieldValueArgs{
			ServiceId: example.ID(),
			CustomFields: pagerduty.ServiceCustomFieldValueCustomFieldArray{
				&pagerduty.ServiceCustomFieldValueCustomFieldArgs{
					Name:  environment.Name,
					Value: pulumi.String(json0),
				},
			},
		})
		if err != nil {
			return err
		}
		// Set multiple custom field values on a service
		region, err := pagerduty.NewServiceCustomField(ctx, "region", &pagerduty.ServiceCustomFieldArgs{
			Name:        pulumi.String("region"),
			DisplayName: pulumi.String("Region"),
			DataType:    pulumi.String("string"),
			FieldType:   pulumi.String("single_value"),
			Description: pulumi.String("The region this service is deployed in"),
		})
		if err != nil {
			return err
		}
		tmpJSON1, err := json.Marshal("production")
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		tmpJSON2, err := json.Marshal("us-east-1")
		if err != nil {
			return err
		}
		json2 := string(tmpJSON2)
		_, err = pagerduty.NewServiceCustomFieldValue(ctx, "multiple_example", &pagerduty.ServiceCustomFieldValueArgs{
			ServiceId: example.ID(),
			CustomFields: pagerduty.ServiceCustomFieldValueCustomFieldArray{
				&pagerduty.ServiceCustomFieldValueCustomFieldArgs{
					Name:  environment.Name,
					Value: pulumi.String(json1),
				},
				&pagerduty.ServiceCustomFieldValueCustomFieldArgs{
					Name:  region.Name,
					Value: pulumi.String(json2),
				},
			},
		})
		if err != nil {
			return err
		}
		// Example with a boolean field
		isCritical, err := pagerduty.NewServiceCustomField(ctx, "is_critical", &pagerduty.ServiceCustomFieldArgs{
			Name:        pulumi.String("is_critical"),
			DisplayName: pulumi.String("Is Critical"),
			DataType:    pulumi.String("boolean"),
			FieldType:   pulumi.String("single_value"),
			Description: pulumi.String("Whether this service is critical"),
		})
		if err != nil {
			return err
		}
		tmpJSON3, err := json.Marshal(true)
		if err != nil {
			return err
		}
		json3 := string(tmpJSON3)
		_, err = pagerduty.NewServiceCustomFieldValue(ctx, "boolean_example", &pagerduty.ServiceCustomFieldValueArgs{
			ServiceId: example.ID(),
			CustomFields: pagerduty.ServiceCustomFieldValueCustomFieldArray{
				&pagerduty.ServiceCustomFieldValueCustomFieldArgs{
					Name:  isCritical.Name,
					Value: pulumi.String(json3),
				},
			},
		})
		if err != nil {
			return err
		}
		// Example with a multi-value field
		regions, err := pagerduty.NewServiceCustomField(ctx, "regions", &pagerduty.ServiceCustomFieldArgs{
			Name:        pulumi.String("regions"),
			DisplayName: pulumi.String("AWS Regions"),
			DataType:    pulumi.String("string"),
			FieldType:   pulumi.String("multi_value_fixed"),
			Description: pulumi.String("AWS regions where this service is deployed"),
			FieldOptions: pagerduty.ServiceCustomFieldFieldOptionArray{
				&pagerduty.ServiceCustomFieldFieldOptionArgs{
					Value:    pulumi.String("us-east-1"),
					DataType: pulumi.String("string"),
				},
				&pagerduty.ServiceCustomFieldFieldOptionArgs{
					Value:    pulumi.String("us-west-1"),
					DataType: pulumi.String("string"),
				},
			},
		})
		if err != nil {
			return err
		}
		tmpJSON4, err := json.Marshal([]string{
			"us-east-1",
			"us-west-1",
		})
		if err != nil {
			return err
		}
		json4 := string(tmpJSON4)
		_, err = pagerduty.NewServiceCustomFieldValue(ctx, "multi_value_example", &pagerduty.ServiceCustomFieldValueArgs{
			ServiceId: example.ID(),
			CustomFields: pagerduty.ServiceCustomFieldValueCustomFieldArray{
				&pagerduty.ServiceCustomFieldValueCustomFieldArgs{
					Name:  regions.Name,
					Value: pulumi.String(json4),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // First, create a service custom field
    var environment = new Pagerduty.ServiceCustomField("environment", new()
    {
        Name = "environment",
        DisplayName = "Environment",
        DataType = "string",
        FieldType = "single_value",
        Description = "The environment this service runs in",
    });

    // Create a service
    var example = new Pagerduty.Service("example", new()
    {
        Name = "Example Service",
        AutoResolveTimeout = "14400",
        AcknowledgementTimeout = "600",
        EscalationPolicy = examplePagerdutyEscalationPolicy.Id,
    });

    // Set a custom field value on the service
    var exampleServiceCustomFieldValue = new Pagerduty.ServiceCustomFieldValue("example", new()
    {
        ServiceId = example.Id,
        CustomFields = new[]
        {
            new Pagerduty.Inputs.ServiceCustomFieldValueCustomFieldArgs
            {
                Name = environment.Name,
                Value = JsonSerializer.Serialize("production"),
            },
        },
    });

    // Set multiple custom field values on a service
    var region = new Pagerduty.ServiceCustomField("region", new()
    {
        Name = "region",
        DisplayName = "Region",
        DataType = "string",
        FieldType = "single_value",
        Description = "The region this service is deployed in",
    });

    var multipleExample = new Pagerduty.ServiceCustomFieldValue("multiple_example", new()
    {
        ServiceId = example.Id,
        CustomFields = new[]
        {
            new Pagerduty.Inputs.ServiceCustomFieldValueCustomFieldArgs
            {
                Name = environment.Name,
                Value = JsonSerializer.Serialize("production"),
            },
            new Pagerduty.Inputs.ServiceCustomFieldValueCustomFieldArgs
            {
                Name = region.Name,
                Value = JsonSerializer.Serialize("us-east-1"),
            },
        },
    });

    // Example with a boolean field
    var isCritical = new Pagerduty.ServiceCustomField("is_critical", new()
    {
        Name = "is_critical",
        DisplayName = "Is Critical",
        DataType = "boolean",
        FieldType = "single_value",
        Description = "Whether this service is critical",
    });

    var booleanExample = new Pagerduty.ServiceCustomFieldValue("boolean_example", new()
    {
        ServiceId = example.Id,
        CustomFields = new[]
        {
            new Pagerduty.Inputs.ServiceCustomFieldValueCustomFieldArgs
            {
                Name = isCritical.Name,
                Value = JsonSerializer.Serialize(true),
            },
        },
    });

    // Example with a multi-value field
    var regions = new Pagerduty.ServiceCustomField("regions", new()
    {
        Name = "regions",
        DisplayName = "AWS Regions",
        DataType = "string",
        FieldType = "multi_value_fixed",
        Description = "AWS regions where this service is deployed",
        FieldOptions = new[]
        {
            new Pagerduty.Inputs.ServiceCustomFieldFieldOptionArgs
            {
                Value = "us-east-1",
                DataType = "string",
            },
            new Pagerduty.Inputs.ServiceCustomFieldFieldOptionArgs
            {
                Value = "us-west-1",
                DataType = "string",
            },
        },
    });

    var multiValueExample = new Pagerduty.ServiceCustomFieldValue("multi_value_example", new()
    {
        ServiceId = example.Id,
        CustomFields = new[]
        {
            new Pagerduty.Inputs.ServiceCustomFieldValueCustomFieldArgs
            {
                Name = regions.Name,
                Value = JsonSerializer.Serialize(new[]
                {
                    "us-east-1",
                    "us-west-1",
                }),
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.pagerduty.ServiceCustomField;
import com.pulumi.pagerduty.ServiceCustomFieldArgs;
import com.pulumi.pagerduty.Service;
import com.pulumi.pagerduty.ServiceArgs;
import com.pulumi.pagerduty.ServiceCustomFieldValue;
import com.pulumi.pagerduty.ServiceCustomFieldValueArgs;
import com.pulumi.pagerduty.inputs.ServiceCustomFieldValueCustomFieldArgs;
import com.pulumi.pagerduty.inputs.ServiceCustomFieldFieldOptionArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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) {
        // First, create a service custom field
        var environment = new ServiceCustomField("environment", ServiceCustomFieldArgs.builder()
            .name("environment")
            .displayName("Environment")
            .dataType("string")
            .fieldType("single_value")
            .description("The environment this service runs in")
            .build());

        // Create a service
        var example = new Service("example", ServiceArgs.builder()
            .name("Example Service")
            .autoResolveTimeout("14400")
            .acknowledgementTimeout("600")
            .escalationPolicy(examplePagerdutyEscalationPolicy.id())
            .build());

        // Set a custom field value on the service
        var exampleServiceCustomFieldValue = new ServiceCustomFieldValue("exampleServiceCustomFieldValue", ServiceCustomFieldValueArgs.builder()
            .serviceId(example.id())
            .customFields(ServiceCustomFieldValueCustomFieldArgs.builder()
                .name(environment.name())
                .value(serializeJson(
                    "production"))
                .build())
            .build());

        // Set multiple custom field values on a service
        var region = new ServiceCustomField("region", ServiceCustomFieldArgs.builder()
            .name("region")
            .displayName("Region")
            .dataType("string")
            .fieldType("single_value")
            .description("The region this service is deployed in")
            .build());

        var multipleExample = new ServiceCustomFieldValue("multipleExample", ServiceCustomFieldValueArgs.builder()
            .serviceId(example.id())
            .customFields(            
                ServiceCustomFieldValueCustomFieldArgs.builder()
                    .name(environment.name())
                    .value(serializeJson(
                        "production"))
                    .build(),
                ServiceCustomFieldValueCustomFieldArgs.builder()
                    .name(region.name())
                    .value(serializeJson(
                        "us-east-1"))
                    .build())
            .build());

        // Example with a boolean field
        var isCritical = new ServiceCustomField("isCritical", ServiceCustomFieldArgs.builder()
            .name("is_critical")
            .displayName("Is Critical")
            .dataType("boolean")
            .fieldType("single_value")
            .description("Whether this service is critical")
            .build());

        var booleanExample = new ServiceCustomFieldValue("booleanExample", ServiceCustomFieldValueArgs.builder()
            .serviceId(example.id())
            .customFields(ServiceCustomFieldValueCustomFieldArgs.builder()
                .name(isCritical.name())
                .value(serializeJson(
                    true))
                .build())
            .build());

        // Example with a multi-value field
        var regions = new ServiceCustomField("regions", ServiceCustomFieldArgs.builder()
            .name("regions")
            .displayName("AWS Regions")
            .dataType("string")
            .fieldType("multi_value_fixed")
            .description("AWS regions where this service is deployed")
            .fieldOptions(            
                ServiceCustomFieldFieldOptionArgs.builder()
                    .value("us-east-1")
                    .dataType("string")
                    .build(),
                ServiceCustomFieldFieldOptionArgs.builder()
                    .value("us-west-1")
                    .dataType("string")
                    .build())
            .build());

        var multiValueExample = new ServiceCustomFieldValue("multiValueExample", ServiceCustomFieldValueArgs.builder()
            .serviceId(example.id())
            .customFields(ServiceCustomFieldValueCustomFieldArgs.builder()
                .name(regions.name())
                .value(serializeJson(
                    jsonArray(
                        "us-east-1", 
                        "us-west-1"
                    )))
                .build())
            .build());

    }
}

resources:
  # First, create a service custom field
  environment:
    type: pagerduty:ServiceCustomField
    properties:
      name: environment
      displayName: Environment
      dataType: string
      fieldType: single_value
      description: The environment this service runs in
  # Create a service
  example:
    type: pagerduty:Service
    properties:
      name: Example Service
      autoResolveTimeout: 14400
      acknowledgementTimeout: 600
      escalationPolicy: ${examplePagerdutyEscalationPolicy.id}
  # Set a custom field value on the service
  exampleServiceCustomFieldValue:
    type: pagerduty:ServiceCustomFieldValue
    name: example
    properties:
      serviceId: ${example.id}
      customFields:
        - name: ${environment.name}
          value:
            fn::toJSON: production
  # Set multiple custom field values on a service
  region:
    type: pagerduty:ServiceCustomField
    properties:
      name: region
      displayName: Region
      dataType: string
      fieldType: single_value
      description: The region this service is deployed in
  multipleExample:
    type: pagerduty:ServiceCustomFieldValue
    name: multiple_example
    properties:
      serviceId: ${example.id}
      customFields:
        - name: ${environment.name}
          value:
            fn::toJSON: production
        - name: ${region.name}
          value:
            fn::toJSON: us-east-1
  # Example with a boolean field
  isCritical:
    type: pagerduty:ServiceCustomField
    name: is_critical
    properties:
      name: is_critical
      displayName: Is Critical
      dataType: boolean
      fieldType: single_value
      description: Whether this service is critical
  booleanExample:
    type: pagerduty:ServiceCustomFieldValue
    name: boolean_example
    properties:
      serviceId: ${example.id}
      customFields:
        - name: ${isCritical.name}
          value:
            fn::toJSON: true
  # Example with a multi-value field
  regions:
    type: pagerduty:ServiceCustomField
    properties:
      name: regions
      displayName: AWS Regions
      dataType: string
      fieldType: multi_value_fixed
      description: AWS regions where this service is deployed
      fieldOptions:
        - value: us-east-1
          dataType: string
        - value: us-west-1
          dataType: string
  multiValueExample:
    type: pagerduty:ServiceCustomFieldValue
    name: multi_value_example
    properties:
      serviceId: ${example.id}
      customFields:
        - name: ${regions.name}
          value:
            fn::toJSON:
              - us-east-1
              - us-west-1

var serviceCustomFieldValueResource = new Pagerduty.ServiceCustomFieldValue("serviceCustomFieldValueResource", new()
{
    CustomFields = new[]
    {
        new Pagerduty.Inputs.ServiceCustomFieldValueCustomFieldArgs
        {
            Id = "string",
            Name = "string",
            Value = "string",
        },
    },
    ServiceId = "string",
});

example, err := pagerduty.NewServiceCustomFieldValue(ctx, "serviceCustomFieldValueResource", &pagerduty.ServiceCustomFieldValueArgs{
	CustomFields: pagerduty.ServiceCustomFieldValueCustomFieldArray{
		&pagerduty.ServiceCustomFieldValueCustomFieldArgs{
			Id:    pulumi.String("string"),
			Name:  pulumi.String("string"),
			Value: pulumi.String("string"),
		},
	},
	ServiceId: pulumi.String("string"),
})

var serviceCustomFieldValueResource = new ServiceCustomFieldValue("serviceCustomFieldValueResource", ServiceCustomFieldValueArgs.builder()
    .customFields(ServiceCustomFieldValueCustomFieldArgs.builder()
        .id("string")
        .name("string")
        .value("string")
        .build())
    .serviceId("string")
    .build());

service_custom_field_value_resource = pagerduty.ServiceCustomFieldValue("serviceCustomFieldValueResource",
    custom_fields=[{
        "id": "string",
        "name": "string",
        "value": "string",
    }],
    service_id="string")

const serviceCustomFieldValueResource = new pagerduty.ServiceCustomFieldValue("serviceCustomFieldValueResource", {
    customFields: [{
        id: "string",
        name: "string",
        value: "string",
    }],
    serviceId: "string",
});

type: pagerduty:ServiceCustomFieldValue
properties:
    customFields:
        - id: string
          name: string
          value: string
    serviceId: string