incident.Workflow

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

// Teams are catalog entries, so an owning team is resolved through the catalog
// rather than by pasting in its ID. The identifier is matched against entry
// names, external IDs and aliases, so the team's name is enough.
const team = incident.getCatalogType({
    name: "Team",
});
const platform = team.then(team => incident.getCatalogEntry({
    catalogTypeId: team.id,
    identifier: "Platform",
}));
// Look the incident lead role up by name, rather than pinning its ID into the
// workflow below. The ID differs between workspaces, so a name keeps the config
// portable.
const incidentLead = incident.getIncidentRole({
    name: "Incident Lead",
});
// This is a workflow that automatically assigns the incident lead role to the user who acked an escalation.
const autoassignIncidentLead = new incident.Workflow("autoassign_incident_lead", {
    name: "Auto-assign incident leader",
    trigger: "escalation.acked",
    expressions: [],
    conditionGroups: [{
        conditions: [{
            subject: "user",
            operation: "is_set",
            paramBindings: [],
        }],
    }],
    steps: [{
        id: "01HY0QG9WT62CEYJN8JD74MJNR",
        name: "incident.assign_role",
        paramBindings: [
            {
                value: {
                    reference: "incident",
                },
            },
            {
                value: {
                    literal: incidentLead.then(incidentLead => incidentLead.id),
                },
            },
            {
                value: {
                    reference: "user",
                },
            },
        ],
    }],
    onceFors: ["incident"],
    owningTeamIds: [platform.then(platform => platform.id)],
    privateIncidentScope: "none",
    continueOnStepError: false,
    runsOnIncidents: "newly_created_and_active",
    runsOnIncidentModes: ["standard"],
    state: "draft",
});

import pulumi
import pulumi_incident as incident

# Teams are catalog entries, so an owning team is resolved through the catalog
# rather than by pasting in its ID. The identifier is matched against entry
# names, external IDs and aliases, so the team's name is enough.
team = incident.get_catalog_type(name="Team")
platform = incident.get_catalog_entry(catalog_type_id=team.id,
    identifier="Platform")
# Look the incident lead role up by name, rather than pinning its ID into the
# workflow below. The ID differs between workspaces, so a name keeps the config
# portable.
incident_lead = incident.get_incident_role(name="Incident Lead")
# This is a workflow that automatically assigns the incident lead role to the user who acked an escalation.
autoassign_incident_lead = incident.Workflow("autoassign_incident_lead",
    name="Auto-assign incident leader",
    trigger="escalation.acked",
    expressions=[],
    condition_groups=[{
        "conditions": [{
            "subject": "user",
            "operation": "is_set",
            "param_bindings": [],
        }],
    }],
    steps=[{
        "id": "01HY0QG9WT62CEYJN8JD74MJNR",
        "name": "incident.assign_role",
        "param_bindings": [
            {
                "value": {
                    "reference": "incident",
                },
            },
            {
                "value": {
                    "literal": incident_lead.id,
                },
            },
            {
                "value": {
                    "reference": "user",
                },
            },
        ],
    }],
    once_fors=["incident"],
    owning_team_ids=[platform.id],
    private_incident_scope="none",
    continue_on_step_error=False,
    runs_on_incidents="newly_created_and_active",
    runs_on_incident_modes=["standard"],
    state="draft")

package main

import (
	"github.com/incident-io/pulumi-incident/sdk/go/incident"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Teams are catalog entries, so an owning team is resolved through the catalog
		// rather than by pasting in its ID. The identifier is matched against entry
		// names, external IDs and aliases, so the team's name is enough.
		team, err := incident.GetCatalogType(ctx, &incident.LookupCatalogTypeArgs{
			Name: pulumi.StringRef("Team"),
		}, nil)
		if err != nil {
			return err
		}
		platform, err := incident.GetCatalogEntry(ctx, &incident.LookupCatalogEntryArgs{
			CatalogTypeId: team.Id,
			Identifier:    "Platform",
		}, nil)
		if err != nil {
			return err
		}
		// Look the incident lead role up by name, rather than pinning its ID into the
		// workflow below. The ID differs between workspaces, so a name keeps the config
		// portable.
		incidentLead, err := incident.GetIncidentRole(ctx, &incident.LookupIncidentRoleArgs{
			Name: pulumi.StringRef("Incident Lead"),
		}, nil)
		if err != nil {
			return err
		}
		// This is a workflow that automatically assigns the incident lead role to the user who acked an escalation.
		_, err = incident.NewWorkflow(ctx, "autoassign_incident_lead", &incident.WorkflowArgs{
			Name:        pulumi.String("Auto-assign incident leader"),
			Trigger:     pulumi.String("escalation.acked"),
			Expressions: incident.WorkflowExpressionArray{},
			ConditionGroups: incident.WorkflowConditionGroupArray{
				&incident.WorkflowConditionGroupArgs{
					Conditions: incident.WorkflowConditionGroupConditionArray{
						&incident.WorkflowConditionGroupConditionArgs{
							Subject:       pulumi.String("user"),
							Operation:     pulumi.String("is_set"),
							ParamBindings: incident.WorkflowConditionGroupConditionParamBindingArray{},
						},
					},
				},
			},
			Steps: incident.WorkflowStepArray{
				&incident.WorkflowStepArgs{
					Id:   pulumi.String("01HY0QG9WT62CEYJN8JD74MJNR"),
					Name: pulumi.String("incident.assign_role"),
					ParamBindings: incident.WorkflowStepParamBindingArray{
						&incident.WorkflowStepParamBindingArgs{
							Value: &incident.WorkflowStepParamBindingValueArgs{
								Reference: pulumi.String("incident"),
							},
						},
						&incident.WorkflowStepParamBindingArgs{
							Value: &incident.WorkflowStepParamBindingValueArgs{
								Literal: pulumi.String(incidentLead.Id),
							},
						},
						&incident.WorkflowStepParamBindingArgs{
							Value: &incident.WorkflowStepParamBindingValueArgs{
								Reference: pulumi.String("user"),
							},
						},
					},
				},
			},
			OnceFors: pulumi.StringArray{
				pulumi.String("incident"),
			},
			OwningTeamIds: pulumi.StringArray{
				pulumi.String(platform.Id),
			},
			PrivateIncidentScope: pulumi.String("none"),
			ContinueOnStepError:  pulumi.Bool(false),
			RunsOnIncidents:      pulumi.String("newly_created_and_active"),
			RunsOnIncidentModes: pulumi.StringArray{
				pulumi.String("standard"),
			},
			State: pulumi.String("draft"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Teams are catalog entries, so an owning team is resolved through the catalog
    // rather than by pasting in its ID. The identifier is matched against entry
    // names, external IDs and aliases, so the team's name is enough.
    var team = Incident.GetCatalogType.Invoke(new()
    {
        Name = "Team",
    });

    var platform = Incident.GetCatalogEntry.Invoke(new()
    {
        CatalogTypeId = team.Apply(getCatalogTypeResult => getCatalogTypeResult.Id),
        Identifier = "Platform",
    });

    // Look the incident lead role up by name, rather than pinning its ID into the
    // workflow below. The ID differs between workspaces, so a name keeps the config
    // portable.
    var incidentLead = Incident.GetIncidentRole.Invoke(new()
    {
        Name = "Incident Lead",
    });

    // This is a workflow that automatically assigns the incident lead role to the user who acked an escalation.
    var autoassignIncidentLead = new Incident.Workflow("autoassign_incident_lead", new()
    {
        Name = "Auto-assign incident leader",
        Trigger = "escalation.acked",
        Expressions = new[] {},
        ConditionGroups = new[]
        {
            new Incident.Inputs.WorkflowConditionGroupArgs
            {
                Conditions = new[]
                {
                    new Incident.Inputs.WorkflowConditionGroupConditionArgs
                    {
                        Subject = "user",
                        Operation = "is_set",
                        ParamBindings = new() { },
                    },
                },
            },
        },
        Steps = new[]
        {
            new Incident.Inputs.WorkflowStepArgs
            {
                Id = "01HY0QG9WT62CEYJN8JD74MJNR",
                Name = "incident.assign_role",
                ParamBindings = new[]
                {
                    new Incident.Inputs.WorkflowStepParamBindingArgs
                    {
                        Value = new Incident.Inputs.WorkflowStepParamBindingValueArgs
                        {
                            Reference = "incident",
                        },
                    },
                    new Incident.Inputs.WorkflowStepParamBindingArgs
                    {
                        Value = new Incident.Inputs.WorkflowStepParamBindingValueArgs
                        {
                            Literal = incidentLead.Apply(getIncidentRoleResult => getIncidentRoleResult.Id),
                        },
                    },
                    new Incident.Inputs.WorkflowStepParamBindingArgs
                    {
                        Value = new Incident.Inputs.WorkflowStepParamBindingValueArgs
                        {
                            Reference = "user",
                        },
                    },
                },
            },
        },
        OnceFors = new[]
        {
            "incident",
        },
        OwningTeamIds = new[]
        {
            platform.Apply(getCatalogEntryResult => getCatalogEntryResult.Id),
        },
        PrivateIncidentScope = "none",
        ContinueOnStepError = false,
        RunsOnIncidents = "newly_created_and_active",
        RunsOnIncidentModes = new[]
        {
            "standard",
        },
        State = "draft",
    });

});

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.GetCatalogTypeArgs;
import com.pulumi.incident.inputs.GetCatalogEntryArgs;
import com.pulumi.incident.inputs.GetIncidentRoleArgs;
import com.pulumi.incident.Workflow;
import com.pulumi.incident.WorkflowArgs;
import com.pulumi.incident.inputs.WorkflowConditionGroupArgs;
import com.pulumi.incident.inputs.WorkflowConditionGroupConditionArgs;
import com.pulumi.incident.inputs.WorkflowStepArgs;
import com.pulumi.incident.inputs.WorkflowStepParamBindingArgs;
import com.pulumi.incident.inputs.WorkflowStepParamBindingValueArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        // Teams are catalog entries, so an owning team is resolved through the catalog
        // rather than by pasting in its ID. The identifier is matched against entry
        // names, external IDs and aliases, so the team's name is enough.
        final var team = IncidentFunctions.getCatalogType(GetCatalogTypeArgs.builder()
            .name("Team")
            .build());

        final var platform = IncidentFunctions.getCatalogEntry(GetCatalogEntryArgs.builder()
            .catalogTypeId(team.id())
            .identifier("Platform")
            .build());

        // Look the incident lead role up by name, rather than pinning its ID into the
        // workflow below. The ID differs between workspaces, so a name keeps the config
        // portable.
        final var incidentLead = IncidentFunctions.getIncidentRole(GetIncidentRoleArgs.builder()
            .name("Incident Lead")
            .build());

        // This is a workflow that automatically assigns the incident lead role to the user who acked an escalation.
        var autoassignIncidentLead = new Workflow("autoassignIncidentLead", WorkflowArgs.builder()
            .name("Auto-assign incident leader")
            .trigger("escalation.acked")
            .expressions()
            .conditionGroups(WorkflowConditionGroupArgs.builder()
                .conditions(WorkflowConditionGroupConditionArgs.builder()
                    .subject("user")
                    .operation("is_set")
                    .paramBindings()
                    .build())
                .build())
            .steps(WorkflowStepArgs.builder()
                .id("01HY0QG9WT62CEYJN8JD74MJNR")
                .name("incident.assign_role")
                .paramBindings(                
                    WorkflowStepParamBindingArgs.builder()
                        .value(WorkflowStepParamBindingValueArgs.builder()
                            .reference("incident")
                            .build())
                        .build(),
                    WorkflowStepParamBindingArgs.builder()
                        .value(WorkflowStepParamBindingValueArgs.builder()
                            .literal(incidentLead.id())
                            .build())
                        .build(),
                    WorkflowStepParamBindingArgs.builder()
                        .value(WorkflowStepParamBindingValueArgs.builder()
                            .reference("user")
                            .build())
                        .build())
                .build())
            .onceFors("incident")
            .owningTeamIds(platform.id())
            .privateIncidentScope("none")
            .continueOnStepError(false)
            .runsOnIncidents("newly_created_and_active")
            .runsOnIncidentModes("standard")
            .state("draft")
            .build());

    }
}

resources:
  # This is a workflow that automatically assigns the incident lead role to the user who acked an escalation.
  autoassignIncidentLead:
    type: incident:Workflow
    name: autoassign_incident_lead
    properties:
      name: Auto-assign incident leader
      trigger: escalation.acked
      expressions: []
      conditionGroups:
        - conditions:
            - subject: user
              operation: is_set
              paramBindings: []
      steps:
        - id: 01HY0QG9WT62CEYJN8JD74MJNR
          name: incident.assign_role
          paramBindings:
            - value:
                reference: incident
            - value:
                literal: ${incidentLead.id}
            - value:
                reference: user
      onceFors:
        - incident
      owningTeamIds:
        - ${platform.id}
      privateIncidentScope: none
      continueOnStepError: false
      runsOnIncidents: newly_created_and_active
      runsOnIncidentModes:
        - standard
      state: draft
variables:
  # Teams are catalog entries, so an owning team is resolved through the catalog
  # rather than by pasting in its ID. The identifier is matched against entry
  # names, external IDs and aliases, so the team's name is enough.
  team:
    fn::invoke:
      function: incident:getCatalogType
      arguments:
        name: Team
  platform:
    fn::invoke:
      function: incident:getCatalogEntry
      arguments:
        catalogTypeId: ${team.id}
        identifier: Platform
  # Look the incident lead role up by name, rather than pinning its ID into the
  # workflow below. The ID differs between workspaces, so a name keeps the config
  # portable.
  incidentLead:
    fn::invoke:
      function: incident:getIncidentRole
      arguments:
        name: Incident Lead

pulumi {
  required_providers {
    incident = {
      source = "pulumi/incident"
    }
  }
}

data "incident_getcatalogtype" "team" {
  name = "Team"
}
data "incident_getcatalogentry" "platform" {
  catalog_type_id = data.incident_getcatalogtype.team.id
  identifier      = "Platform"
}
data "incident_getincidentrole" "incidentLead" {
  name = "Incident Lead"
}

# This is a workflow that automatically assigns the incident lead role to the user who acked an escalation.
resource "incident_workflow" "autoassign_incident_lead" {
  name    = "Auto-assign incident leader"
  trigger = "escalation.acked"
  condition_groups {
    conditions {
      subject   = "user"
      operation = "is_set"
    }
  }
  steps {
    id   = "01HY0QG9WT62CEYJN8JD74MJNR"
    name = "incident.assign_role"
    param_bindings {
      value = {
        reference = "incident"
      }
    }
    param_bindings {
      value = {
        literal = data.incident_getincidentrole.incidentLead.id
      }
    }
    param_bindings {
      value = {
        reference = "user"
      }
    }
  }
  once_fors              = ["incident"]
  owning_team_ids        = [data.incident_getcatalogentry.platform.id]
  private_incident_scope = "none"
  continue_on_step_error = false
  runs_on_incidents      = "newly_created_and_active"
  runs_on_incident_modes = ["standard"]
  state                  = "draft"
}
# Teams are catalog entries, so an owning team is resolved through the catalog
# rather than by pasting in its ID. The identifier is matched against entry
# names, external IDs and aliases, so the team's name is enough.
# Look the incident lead role up by name, rather than pinning its ID into the
# workflow below. The ID differs between workspaces, so a name keeps the config
# portable.

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

// Rich text fields hold a document, not a string, so build one from markdown
// rather than writing the JSON by hand. Variables written as {{ }} become
// references into the workflow scope when the message is sent - a plain string
// literal is stored as literal text and won't interpolate. The feature set must
// match the field it's going into: a Slack message is "mrkdwn".
const execPage = incident.getRichText({
    markdown: `**Exec page for {{ incident.name }}**

{{ form.reason }}

Join the incident channel: {{ incident.slack_channel }}`,
    featureSet: "mrkdwn",
});
// This is a manually triggered workflow that collects information from the user
// via form fields when they run it. Each field's value is available in the
// workflow scope as `form.<key>`, for both conditions and steps to bind
// against - as the message below does with `form.reason`. That's the prefix the
// dashboard shows as "Form → <title>".
//
// The order of the list is the order the fields appear in the form. Either
// form_fields = [] or omitting the attribute clears any existing fields.
//
// A field's `id` is computed, never written: the provider correlates fields
// across applies by `key`, so retitling a field keeps its identity (and any
// in-flight runs), while changing its key replaces it. That's also why the key,
// not the title, is what the scope reference uses.
const pageExecs = new incident.Workflow("page_execs", {
    name: "Page execs",
    trigger: "manual",
    expressions: [],
    conditionGroups: [],
    steps: [{
        id: "01KG1326KD7DT1Z785SYVXXP98",
        name: "slack.send_message",
        paramBindings: [
            {
                arrayValue: [{
                    reference: "form.execs",
                }],
            },
            {
                value: {
                    literal: execPage.then(execPage => execPage.json),
                },
            },
            {},
        ],
    }],
    formFields: [
        {
            key: "reason",
            title: "Reason for paging",
            type: "String",
            description: "Why are we paging the execs?",
            array: false,
            required: true,
        },
        {
            key: "execs",
            title: "Who should we page?",
            type: "User",
            description: "The execs to message. Leave the on-call exec out, they're paged already.",
            array: true,
            required: true,
        },
    ],
    onceFors: ["incident"],
    privateIncidentScope: "none",
    continueOnStepError: false,
    runsOnIncidents: "newly_created_and_active",
    runsOnIncidentModes: ["standard"],
    state: "draft",
});

import pulumi
import pulumi_incident as incident

# Rich text fields hold a document, not a string, so build one from markdown
# rather than writing the JSON by hand. Variables written as {{ }} become
# references into the workflow scope when the message is sent - a plain string
# literal is stored as literal text and won't interpolate. The feature set must
# match the field it's going into: a Slack message is "mrkdwn".
exec_page = incident.get_rich_text(markdown="""**Exec page for {{ incident.name }}**

{{ form.reason }}

Join the incident channel: {{ incident.slack_channel }}""",
    feature_set="mrkdwn")
# This is a manually triggered workflow that collects information from the user
# via form fields when they run it. Each field's value is available in the
# workflow scope as `form.<key>`, for both conditions and steps to bind
# against - as the message below does with `form.reason`. That's the prefix the
# dashboard shows as "Form → <title>".
#
# The order of the list is the order the fields appear in the form. Either
# form_fields = [] or omitting the attribute clears any existing fields.
#
# A field's `id` is computed, never written: the provider correlates fields
# across applies by `key`, so retitling a field keeps its identity (and any
# in-flight runs), while changing its key replaces it. That's also why the key,
# not the title, is what the scope reference uses.
page_execs = incident.Workflow("page_execs",
    name="Page execs",
    trigger="manual",
    expressions=[],
    condition_groups=[],
    steps=[{
        "id": "01KG1326KD7DT1Z785SYVXXP98",
        "name": "slack.send_message",
        "param_bindings": [
            {
                "array_value": [{
                    "reference": "form.execs",
                }],
            },
            {
                "value": {
                    "literal": exec_page.json,
                },
            },
            {},
        ],
    }],
    form_fields=[
        {
            "key": "reason",
            "title": "Reason for paging",
            "type": "String",
            "description": "Why are we paging the execs?",
            "array": False,
            "required": True,
        },
        {
            "key": "execs",
            "title": "Who should we page?",
            "type": "User",
            "description": "The execs to message. Leave the on-call exec out, they're paged already.",
            "array": True,
            "required": True,
        },
    ],
    once_fors=["incident"],
    private_incident_scope="none",
    continue_on_step_error=False,
    runs_on_incidents="newly_created_and_active",
    runs_on_incident_modes=["standard"],
    state="draft")

package main

import (
	"github.com/incident-io/pulumi-incident/sdk/go/incident"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Rich text fields hold a document, not a string, so build one from markdown
		// rather than writing the JSON by hand. Variables written as {{ }} become
		// references into the workflow scope when the message is sent - a plain string
		// literal is stored as literal text and won't interpolate. The feature set must
		// match the field it's going into: a Slack message is "mrkdwn".
		execPage, err := incident.GetRichText(ctx, &incident.GetRichTextArgs{
			Markdown:   "**Exec page for {{ incident.name }}**\n\n{{ form.reason }}\n\nJoin the incident channel: {{ incident.slack_channel }}",
			FeatureSet: "mrkdwn",
		}, nil)
		if err != nil {
			return err
		}
		// This is a manually triggered workflow that collects information from the user
		// via form fields when they run it. Each field's value is available in the
		// workflow scope as `form.<key>`, for both conditions and steps to bind
		// against - as the message below does with `form.reason`. That's the prefix the
		// dashboard shows as "Form → <title>".
		//
		// The order of the list is the order the fields appear in the form. Either
		// form_fields = [] or omitting the attribute clears any existing fields.
		//
		// A field's `id` is computed, never written: the provider correlates fields
		// across applies by `key`, so retitling a field keeps its identity (and any
		// in-flight runs), while changing its key replaces it. That's also why the key,
		// not the title, is what the scope reference uses.
		_, err = incident.NewWorkflow(ctx, "page_execs", &incident.WorkflowArgs{
			Name:            pulumi.String("Page execs"),
			Trigger:         pulumi.String("manual"),
			Expressions:     incident.WorkflowExpressionArray{},
			ConditionGroups: incident.WorkflowConditionGroupArray{},
			Steps: incident.WorkflowStepArray{
				&incident.WorkflowStepArgs{
					Id:   pulumi.String("01KG1326KD7DT1Z785SYVXXP98"),
					Name: pulumi.String("slack.send_message"),
					ParamBindings: incident.WorkflowStepParamBindingArray{
						&incident.WorkflowStepParamBindingArgs{
							ArrayValue: []map[string]string{
								{
									"reference": "form.execs",
								},
							},
						},
						&incident.WorkflowStepParamBindingArgs{
							Value: &incident.WorkflowStepParamBindingValueArgs{
								Literal: pulumi.String(execPage.Json),
							},
						},
						&incident.WorkflowStepParamBindingArgs{},
					},
				},
			},
			FormFields: incident.WorkflowFormFieldArray{
				&incident.WorkflowFormFieldArgs{
					Key:         pulumi.String("reason"),
					Title:       pulumi.String("Reason for paging"),
					Type:        pulumi.String("String"),
					Description: pulumi.String("Why are we paging the execs?"),
					Array:       pulumi.Bool(false),
					Required:    pulumi.Bool(true),
				},
				&incident.WorkflowFormFieldArgs{
					Key:         pulumi.String("execs"),
					Title:       pulumi.String("Who should we page?"),
					Type:        pulumi.String("User"),
					Description: pulumi.String("The execs to message. Leave the on-call exec out, they're paged already."),
					Array:       pulumi.Bool(true),
					Required:    pulumi.Bool(true),
				},
			},
			OnceFors: pulumi.StringArray{
				pulumi.String("incident"),
			},
			PrivateIncidentScope: pulumi.String("none"),
			ContinueOnStepError:  pulumi.Bool(false),
			RunsOnIncidents:      pulumi.String("newly_created_and_active"),
			RunsOnIncidentModes: pulumi.StringArray{
				pulumi.String("standard"),
			},
			State: pulumi.String("draft"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Rich text fields hold a document, not a string, so build one from markdown
    // rather than writing the JSON by hand. Variables written as {{ }} become
    // references into the workflow scope when the message is sent - a plain string
    // literal is stored as literal text and won't interpolate. The feature set must
    // match the field it's going into: a Slack message is "mrkdwn".
    var execPage = Incident.GetRichText.Invoke(new()
    {
        Markdown = @"**Exec page for {{ incident.name }}**

{{ form.reason }}

Join the incident channel: {{ incident.slack_channel }}",
        FeatureSet = "mrkdwn",
    });

    // This is a manually triggered workflow that collects information from the user
    // via form fields when they run it. Each field's value is available in the
    // workflow scope as `form.<key>`, for both conditions and steps to bind
    // against - as the message below does with `form.reason`. That's the prefix the
    // dashboard shows as "Form → <title>".
    //
    // The order of the list is the order the fields appear in the form. Either
    // form_fields = [] or omitting the attribute clears any existing fields.
    //
    // A field's `id` is computed, never written: the provider correlates fields
    // across applies by `key`, so retitling a field keeps its identity (and any
    // in-flight runs), while changing its key replaces it. That's also why the key,
    // not the title, is what the scope reference uses.
    var pageExecs = new Incident.Workflow("page_execs", new()
    {
        Name = "Page execs",
        Trigger = "manual",
        Expressions = new[] {},
        ConditionGroups = new[] {},
        Steps = new[]
        {
            new Incident.Inputs.WorkflowStepArgs
            {
                Id = "01KG1326KD7DT1Z785SYVXXP98",
                Name = "slack.send_message",
                ParamBindings = new[]
                {
                    new Incident.Inputs.WorkflowStepParamBindingArgs
                    {
                        ArrayValue = new[]
                        {
                            
                            {
                                { "reference", "form.execs" },
                            },
                        },
                    },
                    new Incident.Inputs.WorkflowStepParamBindingArgs
                    {
                        Value = new Incident.Inputs.WorkflowStepParamBindingValueArgs
                        {
                            Literal = execPage.Apply(getRichTextResult => getRichTextResult.Json),
                        },
                    },
                    null,
                },
            },
        },
        FormFields = new[]
        {
            new Incident.Inputs.WorkflowFormFieldArgs
            {
                Key = "reason",
                Title = "Reason for paging",
                Type = "String",
                Description = "Why are we paging the execs?",
                Array = false,
                Required = true,
            },
            new Incident.Inputs.WorkflowFormFieldArgs
            {
                Key = "execs",
                Title = "Who should we page?",
                Type = "User",
                Description = "The execs to message. Leave the on-call exec out, they're paged already.",
                Array = true,
                Required = true,
            },
        },
        OnceFors = new[]
        {
            "incident",
        },
        PrivateIncidentScope = "none",
        ContinueOnStepError = false,
        RunsOnIncidents = "newly_created_and_active",
        RunsOnIncidentModes = new[]
        {
            "standard",
        },
        State = "draft",
    });

});

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.GetRichTextArgs;
import com.pulumi.incident.Workflow;
import com.pulumi.incident.WorkflowArgs;
import com.pulumi.incident.inputs.WorkflowStepArgs;
import com.pulumi.incident.inputs.WorkflowStepParamBindingArgs;
import com.pulumi.incident.inputs.WorkflowStepParamBindingValueArgs;
import com.pulumi.incident.inputs.WorkflowFormFieldArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        // Rich text fields hold a document, not a string, so build one from markdown
        // rather than writing the JSON by hand. Variables written as {{ }} become
        // references into the workflow scope when the message is sent - a plain string
        // literal is stored as literal text and won't interpolate. The feature set must
        // match the field it's going into: a Slack message is "mrkdwn".
        final var execPage = IncidentFunctions.getRichText(GetRichTextArgs.builder()
            .markdown("""
**Exec page for {{ incident.name }}**

{{ form.reason }}

Join the incident channel: {{ incident.slack_channel }}            """)
            .featureSet("mrkdwn")
            .build());

        // This is a manually triggered workflow that collects information from the user
        // via form fields when they run it. Each field's value is available in the
        // workflow scope as `form.<key>`, for both conditions and steps to bind
        // against - as the message below does with `form.reason`. That's the prefix the
        // dashboard shows as "Form → <title>".
        //
        // The order of the list is the order the fields appear in the form. Either
        // form_fields = [] or omitting the attribute clears any existing fields.
        //
        // A field's `id` is computed, never written: the provider correlates fields
        // across applies by `key`, so retitling a field keeps its identity (and any
        // in-flight runs), while changing its key replaces it. That's also why the key,
        // not the title, is what the scope reference uses.
        var pageExecs = new Workflow("pageExecs", WorkflowArgs.builder()
            .name("Page execs")
            .trigger("manual")
            .expressions()
            .conditionGroups()
            .steps(WorkflowStepArgs.builder()
                .id("01KG1326KD7DT1Z785SYVXXP98")
                .name("slack.send_message")
                .paramBindings(                
                    WorkflowStepParamBindingArgs.builder()
                        .arrayValue(Arrays.asList(Map.of("reference", "form.execs")))
                        .build(),
                    WorkflowStepParamBindingArgs.builder()
                        .value(WorkflowStepParamBindingValueArgs.builder()
                            .literal(execPage.json())
                            .build())
                        .build(),
                    WorkflowStepParamBindingArgs.builder()
                        .build())
                .build())
            .formFields(            
                WorkflowFormFieldArgs.builder()
                    .key("reason")
                    .title("Reason for paging")
                    .type("String")
                    .description("Why are we paging the execs?")
                    .array(false)
                    .required(true)
                    .build(),
                WorkflowFormFieldArgs.builder()
                    .key("execs")
                    .title("Who should we page?")
                    .type("User")
                    .description("The execs to message. Leave the on-call exec out, they're paged already.")
                    .array(true)
                    .required(true)
                    .build())
            .onceFors("incident")
            .privateIncidentScope("none")
            .continueOnStepError(false)
            .runsOnIncidents("newly_created_and_active")
            .runsOnIncidentModes("standard")
            .state("draft")
            .build());

    }
}

resources:
  # This is a manually triggered workflow that collects information from the user
  # via form fields when they run it. Each field's value is available in the
  # workflow scope as `form.<key>`, for both conditions and steps to bind
  # against - as the message below does with `form.reason`. That's the prefix the
  # dashboard shows as "Form → <title>".
  #
  # The order of the list is the order the fields appear in the form. Either
  # form_fields = [] or omitting the attribute clears any existing fields.
  #
  # A field's `id` is computed, never written: the provider correlates fields
  # across applies by `key`, so retitling a field keeps its identity (and any
  # in-flight runs), while changing its key replaces it. That's also why the key,
  # not the title, is what the scope reference uses.
  pageExecs:
    type: incident:Workflow
    name: page_execs
    properties:
      name: Page execs
      trigger: manual
      expressions: []
      conditionGroups: []
      steps:
        - id: 01KG1326KD7DT1Z785SYVXXP98
          name: slack.send_message
          paramBindings:
            - arrayValue:
                - reference: form.execs
            - value:
                literal: ${execPage.json}
            - {}
      formFields:
        - key: reason
          title: Reason for paging
          type: String
          description: Why are we paging the execs?
          array: false
          required: true
        - key: execs
          title: Who should we page?
          type: User
          description: The execs to message. Leave the on-call exec out, they're paged already.
          array: true
          required: true
      onceFors:
        - incident
      privateIncidentScope: none
      continueOnStepError: false
      runsOnIncidents: newly_created_and_active
      runsOnIncidentModes:
        - standard
      state: draft
variables:
  # Rich text fields hold a document, not a string, so build one from markdown
  # rather than writing the JSON by hand. Variables written as {{ }} become
  # references into the workflow scope when the message is sent - a plain string
  # literal is stored as literal text and won't interpolate. The feature set must
  # match the field it's going into: a Slack message is "mrkdwn".
  execPage:
    fn::invoke:
      function: incident:getRichText
      arguments:
        markdown: |-
          **Exec page for {{ incident.name }}**

          {{ form.reason }}

          Join the incident channel: {{ incident.slack_channel }}
        featureSet: mrkdwn

pulumi {
  required_providers {
    incident = {
      source = "pulumi/incident"
    }
  }
}

data "incident_getrichtext" "execPage" {
  markdown    = "**Exec page for {{ incident.name }}**\n\n{{ form.reason }}\n\nJoin the incident channel: {{ incident.slack_channel }}"
  feature_set = "mrkdwn"
}

# This is a manually triggered workflow that collects information from the user
# via form fields when they run it. Each field's value is available in the
# workflow scope as `form.<key>`, for both conditions and steps to bind
# against - as the message below does with `form.reason`. That's the prefix the
# dashboard shows as "Form → <title>".
#
# The order of the list is the order the fields appear in the form. Either
# form_fields = [] or omitting the attribute clears any existing fields.
#
# A field's `id` is computed, never written: the provider correlates fields
# across applies by `key`, so retitling a field keeps its identity (and any
# in-flight runs), while changing its key replaces it. That's also why the key,
# not the title, is what the scope reference uses.
resource "incident_workflow" "page_execs" {
  name    = "Page execs"
  trigger = "manual"
  steps {
    id   = "01KG1326KD7DT1Z785SYVXXP98"
    name = "slack.send_message"
    param_bindings {
      array_value = [{
        "reference" = "form.execs"
      }]
    }
    param_bindings {
      value = {
        literal = data.incident_getrichtext.execPage.json
      }
    }
    param_bindings {
    }
  }
  form_fields {
    key         = "reason"
    title       = "Reason for paging"
    type        = "String"
    description = "Why are we paging the execs?"
    array       = false
    required    = true
  }
  form_fields {
    key         = "execs"
    title       = "Who should we page?"
    type        = "User"
    description = "The execs to message. Leave the on-call exec out, they're paged already."
    array       = true
    required    = true
  }
  once_fors              = ["incident"]
  private_incident_scope = "none"
  continue_on_step_error = false
  runs_on_incidents      = "newly_created_and_active"
  runs_on_incident_modes = ["standard"]
  state                  = "draft"
}
# Rich text fields hold a document, not a string, so build one from markdown
# rather than writing the JSON by hand. Variables written as {{ }} become
# references into the workflow scope when the message is sent - a plain string
# literal is stored as literal text and won't interpolate. The feature set must
# match the field it's going into: a Slack message is "mrkdwn".

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

// Statuses are managed by incident.io, so look one up by name rather than pasting
// the ULID an export gives you: the ID differs between workspaces, the name is
// what you see in the dashboard.
const closed = incident.getStatus({
    name: "Closed",
});
// This workflow runs when someone moves an incident into Closed, and creates the
// postmortem follow-up assigned to whoever closed it.
//
// The trigger's scope carries three references to bind against: "incident",
// "previous-status" (the status the incident moved out of) and
// "user-who-changed-the-status".
//
// Note that building this in the dashboard pre-fills a "status category is
// Active" condition, which would stop this workflow ever running, Closed not
// being an active category. Terraform writes conditions explicitly so there's
// nothing to remove here, but check for that condition if you export a
// status-driven workflow from the dashboard.
const postmortemWhenClosed = new incident.Workflow("postmortem_when_closed", {
    name: "Create the postmortem follow-up when an incident closes",
    trigger: "incident.status-changed",
    expressions: [],
    conditionGroups: [{
        conditions: [{
            subject: "incident.status",
            operation: "one_of",
            paramBindings: [{
                arrayValue: [{
                    literal: closed.then(closed => closed.id),
                }],
            }],
        }],
    }],
    steps: [{
        id: "01KT8B9QQH67GF9S6SW4A7DNEX",
        name: "incident.create_follow_ups",
        paramBindings: [
            {
                value: {
                    reference: "incident",
                },
            },
            {
                arrayValue: [{
                    literal: "Write the postmortem",
                }],
            },
            {
                value: {
                    reference: "user-who-changed-the-status",
                },
            },
            {},
            {},
            {},
        ],
    }],
    onceFors: ["incident"],
    privateIncidentScope: "none",
    continueOnStepError: false,
    runsOnIncidents: "newly_created_and_active",
    runsOnIncidentModes: ["standard"],
    state: "draft",
});

import pulumi
import pulumi_incident as incident

# Statuses are managed by incident.io, so look one up by name rather than pasting
# the ULID an export gives you: the ID differs between workspaces, the name is
# what you see in the dashboard.
closed = incident.get_status(name="Closed")
# This workflow runs when someone moves an incident into Closed, and creates the
# postmortem follow-up assigned to whoever closed it.
#
# The trigger's scope carries three references to bind against: "incident",
# "previous-status" (the status the incident moved out of) and
# "user-who-changed-the-status".
#
# Note that building this in the dashboard pre-fills a "status category is
# Active" condition, which would stop this workflow ever running, Closed not
# being an active category. Terraform writes conditions explicitly so there's
# nothing to remove here, but check for that condition if you export a
# status-driven workflow from the dashboard.
postmortem_when_closed = incident.Workflow("postmortem_when_closed",
    name="Create the postmortem follow-up when an incident closes",
    trigger="incident.status-changed",
    expressions=[],
    condition_groups=[{
        "conditions": [{
            "subject": "incident.status",
            "operation": "one_of",
            "param_bindings": [{
                "array_value": [{
                    "literal": closed.id,
                }],
            }],
        }],
    }],
    steps=[{
        "id": "01KT8B9QQH67GF9S6SW4A7DNEX",
        "name": "incident.create_follow_ups",
        "param_bindings": [
            {
                "value": {
                    "reference": "incident",
                },
            },
            {
                "array_value": [{
                    "literal": "Write the postmortem",
                }],
            },
            {
                "value": {
                    "reference": "user-who-changed-the-status",
                },
            },
            {},
            {},
            {},
        ],
    }],
    once_fors=["incident"],
    private_incident_scope="none",
    continue_on_step_error=False,
    runs_on_incidents="newly_created_and_active",
    runs_on_incident_modes=["standard"],
    state="draft")

package main

import (
	"github.com/incident-io/pulumi-incident/sdk/go/incident"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Statuses are managed by incident.io, so look one up by name rather than pasting
		// the ULID an export gives you: the ID differs between workspaces, the name is
		// what you see in the dashboard.
		closed, err := incident.GetStatus(ctx, &incident.LookupStatusArgs{
			Name: pulumi.StringRef("Closed"),
		}, nil)
		if err != nil {
			return err
		}
		// This workflow runs when someone moves an incident into Closed, and creates the
		// postmortem follow-up assigned to whoever closed it.
		//
		// The trigger's scope carries three references to bind against: "incident",
		// "previous-status" (the status the incident moved out of) and
		// "user-who-changed-the-status".
		//
		// Note that building this in the dashboard pre-fills a "status category is
		// Active" condition, which would stop this workflow ever running, Closed not
		// being an active category. Terraform writes conditions explicitly so there's
		// nothing to remove here, but check for that condition if you export a
		// status-driven workflow from the dashboard.
		_, err = incident.NewWorkflow(ctx, "postmortem_when_closed", &incident.WorkflowArgs{
			Name:        pulumi.String("Create the postmortem follow-up when an incident closes"),
			Trigger:     pulumi.String("incident.status-changed"),
			Expressions: incident.WorkflowExpressionArray{},
			ConditionGroups: incident.WorkflowConditionGroupArray{
				&incident.WorkflowConditionGroupArgs{
					Conditions: incident.WorkflowConditionGroupConditionArray{
						&incident.WorkflowConditionGroupConditionArgs{
							Subject:   pulumi.String("incident.status"),
							Operation: pulumi.String("one_of"),
							ParamBindings: incident.WorkflowConditionGroupConditionParamBindingArray{
								&incident.WorkflowConditionGroupConditionParamBindingArgs{
									ArrayValue: []map[string]interface{}{
										map[string]interface{}{
											"literal": closed.Id,
										},
									},
								},
							},
						},
					},
				},
			},
			Steps: incident.WorkflowStepArray{
				&incident.WorkflowStepArgs{
					Id:   pulumi.String("01KT8B9QQH67GF9S6SW4A7DNEX"),
					Name: pulumi.String("incident.create_follow_ups"),
					ParamBindings: incident.WorkflowStepParamBindingArray{
						&incident.WorkflowStepParamBindingArgs{
							Value: &incident.WorkflowStepParamBindingValueArgs{
								Reference: pulumi.String("incident"),
							},
						},
						&incident.WorkflowStepParamBindingArgs{
							ArrayValue: []map[string]string{
								{
									"literal": "Write the postmortem",
								},
							},
						},
						&incident.WorkflowStepParamBindingArgs{
							Value: &incident.WorkflowStepParamBindingValueArgs{
								Reference: pulumi.String("user-who-changed-the-status"),
							},
						},
						&incident.WorkflowStepParamBindingArgs{},
						&incident.WorkflowStepParamBindingArgs{},
						&incident.WorkflowStepParamBindingArgs{},
					},
				},
			},
			OnceFors: pulumi.StringArray{
				pulumi.String("incident"),
			},
			PrivateIncidentScope: pulumi.String("none"),
			ContinueOnStepError:  pulumi.Bool(false),
			RunsOnIncidents:      pulumi.String("newly_created_and_active"),
			RunsOnIncidentModes: pulumi.StringArray{
				pulumi.String("standard"),
			},
			State: pulumi.String("draft"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}