incident.getSeverity

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

// Look up an existing incident severity by name.
const minor = incident.getSeverity({
    name: "Minor",
});
// Create an incident severity.
const criticalSeverity = new incident.Severity("critical", {
    name: "Critical",
    description: "A critical incident that requires an immediate response.",
});
// Reference the incident severity by its ID.
const critical = incident.getSeverityOutput({
    id: criticalSeverity.id,
});

import pulumi
import pulumi_incident as incident

# Look up an existing incident severity by name.
minor = incident.get_severity(name="Minor")
# Create an incident severity.
critical_severity = incident.Severity("critical",
    name="Critical",
    description="A critical incident that requires an immediate response.")
# Reference the incident severity by its ID.
critical = incident.get_severity_output(id=critical_severity.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 existing incident severity by name.
		_, err := incident.LookupSeverity(ctx, &incident.LookupSeverityArgs{
			Name: pulumi.StringRef("Minor"),
		}, nil)
		if err != nil {
			return err
		}
		// Create an incident severity.
		criticalSeverity, err := incident.NewSeverity(ctx, "critical", &incident.SeverityArgs{
			Name:        pulumi.String("Critical"),
			Description: pulumi.String("A critical incident that requires an immediate response."),
		})
		if err != nil {
			return err
		}
		// Reference the incident severity by its ID.
		_ = incident.LookupSeverityOutput(ctx, incident.GetSeverityOutputArgs{
			Id: criticalSeverity.ID(),
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Look up an existing incident severity by name.
    var minor = Incident.GetSeverity.Invoke(new()
    {
        Name = "Minor",
    });

    // Create an incident severity.
    var criticalSeverity = new Incident.Severity("critical", new()
    {
        Name = "Critical",
        Description = "A critical incident that requires an immediate response.",
    });

    // Reference the incident severity by its ID.
    var critical = Incident.GetSeverity.Invoke(new()
    {
        Id = criticalSeverity.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.GetSeverityArgs;
import com.pulumi.incident.Severity;
import com.pulumi.incident.SeverityArgs;
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 existing incident severity by name.
        final var minor = IncidentFunctions.getSeverity(GetSeverityArgs.builder()
            .name("Minor")
            .build());

        // Create an incident severity.
        var criticalSeverity = new Severity("criticalSeverity", SeverityArgs.builder()
            .name("Critical")
            .description("A critical incident that requires an immediate response.")
            .build());

        // Reference the incident severity by its ID.
        final var critical = IncidentFunctions.getSeverity(GetSeverityArgs.builder()
            .id(criticalSeverity.id())
            .build());

    }
}

resources:
  # Create an incident severity.
  criticalSeverity:
    type: incident:Severity
    name: critical
    properties:
      name: Critical
      description: A critical incident that requires an immediate response.
variables:
  # Look up an existing incident severity by name.
  minor:
    fn::invoke:
      function: incident:getSeverity
      arguments:
        name: Minor
  # Reference the incident severity by its ID.
  critical:
    fn::invoke:
      function: incident:getSeverity
      arguments:
        id: ${criticalSeverity.id}

function getSeverity(args: GetSeverityArgs, opts?: InvokeOptions): Promise<GetSeverityResult>
function getSeverityOutput(args: GetSeverityOutputArgs, opts?: InvokeOutputOptions): Output<GetSeverityResult>

def get_severity(id: Optional[str] = None,
                 name: Optional[str] = None,
                 opts: Optional[InvokeOptions] = None) -> GetSeverityResult
def get_severity_output(id: pulumi.Input[Optional[str]] = None,
                 name: pulumi.Input[Optional[str]] = None,
                 opts: Optional[InvokeOutputOptions] = None) -> Output[GetSeverityResult]

func LookupSeverity(ctx *Context, args *LookupSeverityArgs, opts ...InvokeOption) (*LookupSeverityResult, error)
func LookupSeverityOutput(ctx *Context, args *LookupSeverityOutputArgs, opts ...InvokeOption) LookupSeverityResultOutput

public static class GetSeverity 
{
    public static Task<GetSeverityResult> InvokeAsync(GetSeverityArgs args, InvokeOptions? opts = null)
    public static Output<GetSeverityResult> Invoke(GetSeverityInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetSeverityResult> Invoke(GetSeverityInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetSeverityResult> getSeverity(GetSeverityArgs args, InvokeOptions options)
public static Output<GetSeverityResult> getSeverity(GetSeverityArgs args, InvokeOptions options)
public static Output<GetSeverityResult> getSeverity(GetSeverityArgs args, InvokeOutputOptions options)

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

data "incident_get_severity" "name" {
    # arguments
}