incident.getIncidentType

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

// Look up an incident type by name. Incident types are configured in your
// settings rather than created from Terraform, so this is how you get hold of
// one's ID.
const productionOutage = incident.getIncidentType({
    name: "Production Outage",
});
// Or by ID, if you already have one.
const byId = incident.getIncidentType({
    id: "01FCNDV6P870EA6S7TK1DSYDG0",
});
export const productionOutageId = productionOutage.then(productionOutage => productionOutage.id);

import pulumi
import pulumi_incident as incident

# Look up an incident type by name. Incident types are configured in your
# settings rather than created from Terraform, so this is how you get hold of
# one's ID.
production_outage = incident.get_incident_type(name="Production Outage")
# Or by ID, if you already have one.
by_id = incident.get_incident_type(id="01FCNDV6P870EA6S7TK1DSYDG0")
pulumi.export("productionOutageId", production_outage.id)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Look up an incident type by name. Incident types are configured in your
		// settings rather than created from Terraform, so this is how you get hold of
		// one's ID.
		productionOutage, err := incident.GetIncidentType(ctx, &incident.GetIncidentTypeArgs{
			Name: pulumi.StringRef("Production Outage"),
		}, nil)
		if err != nil {
			return err
		}
		// Or by ID, if you already have one.
		_, err = incident.GetIncidentType(ctx, &incident.GetIncidentTypeArgs{
			Id: pulumi.StringRef("01FCNDV6P870EA6S7TK1DSYDG0"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("productionOutageId", productionOutage.Id)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Look up an incident type by name. Incident types are configured in your
    // settings rather than created from Terraform, so this is how you get hold of
    // one's ID.
    var productionOutage = Incident.GetIncidentType.Invoke(new()
    {
        Name = "Production Outage",
    });

    // Or by ID, if you already have one.
    var byId = Incident.GetIncidentType.Invoke(new()
    {
        Id = "01FCNDV6P870EA6S7TK1DSYDG0",
    });

    return new Dictionary<string, object?>
    {
        ["productionOutageId"] = productionOutage.Apply(getIncidentTypeResult => getIncidentTypeResult.Id),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.incident.IncidentFunctions;
import com.pulumi.incident.inputs.GetIncidentTypeArgs;
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) {
        // Look up an incident type by name. Incident types are configured in your
        // settings rather than created from Terraform, so this is how you get hold of
        // one's ID.
        final var productionOutage = IncidentFunctions.getIncidentType(GetIncidentTypeArgs.builder()
            .name("Production Outage")
            .build());

        // Or by ID, if you already have one.
        final var byId = IncidentFunctions.getIncidentType(GetIncidentTypeArgs.builder()
            .id("01FCNDV6P870EA6S7TK1DSYDG0")
            .build());

        ctx.export("productionOutageId", productionOutage.id());
    }
}

variables:
  # Look up an incident type by name. Incident types are configured in your
  # settings rather than created from Terraform, so this is how you get hold of
  # one's ID.
  productionOutage:
    fn::invoke:
      function: incident:getIncidentType
      arguments:
        name: Production Outage
  # Or by ID, if you already have one.
  byId:
    fn::invoke:
      function: incident:getIncidentType
      arguments:
        id: 01FCNDV6P870EA6S7TK1DSYDG0
outputs:
  productionOutageId: ${productionOutage.id}

function getIncidentType(args: GetIncidentTypeArgs, opts?: InvokeOptions): Promise<GetIncidentTypeResult>
function getIncidentTypeOutput(args: GetIncidentTypeOutputArgs, opts?: InvokeOutputOptions): Output<GetIncidentTypeResult>

def get_incident_type(id: Optional[str] = None,
                      name: Optional[str] = None,
                      opts: Optional[InvokeOptions] = None) -> GetIncidentTypeResult
def get_incident_type_output(id: pulumi.Input[Optional[str]] = None,
                      name: pulumi.Input[Optional[str]] = None,
                      opts: Optional[InvokeOutputOptions] = None) -> Output[GetIncidentTypeResult]

func GetIncidentType(ctx *Context, args *GetIncidentTypeArgs, opts ...InvokeOption) (*GetIncidentTypeResult, error)
func GetIncidentTypeOutput(ctx *Context, args *GetIncidentTypeOutputArgs, opts ...InvokeOption) GetIncidentTypeResultOutput

public static class GetIncidentType 
{
    public static Task<GetIncidentTypeResult> InvokeAsync(GetIncidentTypeArgs args, InvokeOptions? opts = null)
    public static Output<GetIncidentTypeResult> Invoke(GetIncidentTypeInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetIncidentTypeResult> Invoke(GetIncidentTypeInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetIncidentTypeResult> getIncidentType(GetIncidentTypeArgs args, InvokeOptions options)
public static Output<GetIncidentTypeResult> getIncidentType(GetIncidentTypeArgs args, InvokeOptions options)
public static Output<GetIncidentTypeResult> getIncidentType(GetIncidentTypeArgs args, InvokeOutputOptions options)

fn::invoke:
  function: incident:index/getIncidentType:getIncidentType
  arguments:
    # arguments dictionary

data "incident_get_incident_type" "name" {
    # arguments
}