@incident-io/pulumi 0.1.0-alpha.1

package/workflow.d.ts

@@ -0,0 +1,736 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as inputs from "./types/input";
+import * as outputs from "./types/output";
+/**
+ * This resource is used to manage Workflows.
+ *
+ * We'd generally recommend building workflows in our [web dashboard](https://app.incident.io/~/workflows), and using the 'Export' flow to generate your Terraform, as it's easier to see what you've configured. You can also make changes to an existing workflow and copy the resulting Terraform without persisting it.
+ *
+ * ## Example - Assign the incident lead when an escalation is acked
+ *
+ * ```typescript
+ * 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",
+ * });
+ * ```
+ *
+ * ## Example - Page execs from a manual workflow, using form fields
+ *
+ * ```typescript
+ * 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",
+ * });
+ * ```
+ *
+ * ## Example - Create the postmortem follow-up when an incident closes
+ *
+ * ```typescript
+ * 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",
+ * });
+ * ```
+ *
+ * ## Example - Invite the security responders to an incident
+ *
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as incident from "@incident-io/pulumi";
+ *
+ * // Users have a data source, so a config doesn't need the ULIDs an export writes
+ * // for them: look people up by the email address they use with incident.io.
+ * const securityLead = incident.getUser({
+ *     email: "security-lead@example.com",
+ * });
+ * // Slack user groups reach the engine through the catalog, as entries of the
+ * // managed "Slack User Group" type. The identifier matches an entry's name,
+ * // external ID or aliases, so the group's handle is enough.
+ * const slackUserGroup = incident.getCatalogType({
+ *     name: "Slack User Group",
+ * });
+ * const securityResponders = slackUserGroup.then(slackUserGroup => incident.getCatalogEntry({
+ *     catalogTypeId: slackUserGroup.id,
+ *     identifier: "security-responders",
+ * }));
+ * // This workflow pulls the security responders into an incident's channel as soon
+ * // as the incident becomes active.
+ * //
+ * // Four steps sound alike but do different things, so pick deliberately:
+ * //
+ * //   slack.invite_user                   invites users and Slack user groups to
+ * //                                       the incident's channel (this one)
+ * //   incident.add_member                 grants access to a private incident, and
+ * //                                       does nothing on a public one
+ * //   incident.assign_role                gives someone an incident role, such as
+ * //                                       Incident Lead
+ * //   incident.subscribe_user_to_incident subscribes someone to updates without
+ * //                                       making them a participant
+ * //
+ * // Narrow this with conditions on whatever marks the incidents you care about -
+ * // a custom field, the incident's type, or its severity.
+ * const inviteSecurityResponders = new incident.Workflow("invite_security_responders", {
+ *     name: "Invite security responders",
+ *     trigger: "incident.updated",
+ *     expressions: [],
+ *     conditionGroups: [{
+ *         conditions: [{
+ *             subject: "incident.status.category",
+ *             operation: "one_of",
+ *             paramBindings: [{
+ *                 arrayValue: [{
+ *                     literal: "active",
+ *                 }],
+ *             }],
+ *         }],
+ *     }],
+ *     steps: [{
+ *         id: "01KFD47KKJS93YXR3W53MQSFVC",
+ *         name: "slack.invite_user",
+ *         paramBindings: [
+ *             {
+ *                 value: {
+ *                     reference: "incident",
+ *                 },
+ *             },
+ *             {
+ *                 arrayValue: [{
+ *                     literal: securityLead.then(securityLead => securityLead.id),
+ *                 }],
+ *             },
+ *             {
+ *                 arrayValue: [{
+ *                     literal: securityResponders.then(securityResponders => securityResponders.id),
+ *                 }],
+ *             },
+ *         ],
+ *     }],
+ *     onceFors: ["incident"],
+ *     privateIncidentScope: "none",
+ *     continueOnStepError: false,
+ *     runsOnIncidents: "newly_created_and_active",
+ *     runsOnIncidentModes: ["standard"],
+ *     state: "draft",
+ * });
+ * ```
+ *
+ * ## Example - Share incident updates with leadership
+ *
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as incident from "@incident-io/pulumi";
+ *
+ * // A message body is a rich text document, so build it from markdown here rather
+ * // than pasting the JSON an export produces. Anything the feature set can't hold
+ * // is dropped and listed in dropped_content, which you can output to see what
+ * // went missing.
+ * const leadershipUpdate = incident.getRichText({
+ *     markdown: `**{{ incident.name }}** — update from {{ update.author }}
+ *
+ * {{ update.message }}
+ *
+ * Now at {{ update.to_status }}, severity {{ update.to_severity }}. Follow along in {{ incident.slack_channel }}.
+ * `,
+ *     featureSet: "mrkdwn",
+ * });
+ * // This workflow mirrors every incident update into a leadership channel.
+ * //
+ * // Three Slack steps send messages, and they take different first parameters:
+ * //
+ * //   slack.post_message     posts to a channel, which is where this one goes
+ * //   slack.send_message     sends a DM to users
+ * //   slack.reply_in_thread  replies to a message already in the scope
+ * //
+ * // On Microsoft Teams the equivalent is ms_teams.post_message, whose channel
+ * // parameter takes a MicrosoftTeamsChatChannel and defaults to
+ * // `incident.ms_teams_channel`. Only the steps for your workspace's primary
+ * // comms platform are available, so a config written for one won't apply to the
+ * // other.
+ * const shareUpdatesWithLeadership = new incident.Workflow("share_updates_with_leadership", {
+ *     name: "Share incident updates with leadership",
+ *     trigger: "incident.update_shared",
+ *     expressions: [],
+ *     conditionGroups: [],
+ *     steps: [{
+ *         id: "01K5TSNDBF7KBZY9AFDKYXJM3M",
+ *         name: "slack.post_message",
+ *         paramBindings: [
+ *             {
+ *                 value: {
+ *                     literal: "C02A1FSNEKC",
+ *                 },
+ *             },
+ *             {
+ *                 value: {
+ *                     literal: leadershipUpdate.then(leadershipUpdate => leadershipUpdate.json),
+ *                 },
+ *             },
+ *             {},
+ *             {
+ *                 value: {
+ *                     literal: "Europe/London",
+ *                 },
+ *             },
+ *         ],
+ *     }],
+ *     onceFors: [],
+ *     privateIncidentScope: "none",
+ *     continueOnStepError: false,
+ *     runsOnIncidents: "newly_created_and_active",
+ *     runsOnIncidentModes: ["standard"],
+ *     state: "draft",
+ * });
+ * ```
+ *
+ * ## Example - Subscribe CSMs to customer-facing incidents
+ *
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as incident from "@incident-io/pulumi";
+ *
+ * // Custom fields and their options both have data sources, so a condition on one
+ * // needs no ULIDs: look the field up by name, and each option by its value.
+ * const affectedCustomers = incident.getCustomField({
+ *     name: "Affected customers",
+ * });
+ * const allCustomers = affectedCustomers.then(affectedCustomers => incident.getCustomFieldOption({
+ *     customFieldId: affectedCustomers.id,
+ *     value: "All customers",
+ * }));
+ * const csmLead = incident.getUser({
+ *     email: "csm-lead@example.com",
+ * });
+ * const csmDeputy = incident.getUser({
+ *     email: "csm-deputy@example.com",
+ * });
+ * // This is the workflow we run ourselves: subscribe the CSM team to every
+ * // Critical incident, and to Major incidents that affect all customers.
+ * //
+ * // It's the clearest example of how condition groups combine. Conditions within
+ * // a group are ANDed, and the groups are ORed with each other, so this reads as:
+ * //
+ * //   severity is Critical
+ * //     OR (severity is Major AND affected customers is All customers)
+ * //
+ * // Two conditions that must both hold go in one group. Two alternatives, as
+ * // here, need a group each - putting all three conditions in a single group
+ * // would subscribe nobody, since no incident is both Critical and Major.
+ * const subscribeCsms = new incident.Workflow("subscribe_csms", {
+ *     name: "Subscribe CSMs to customer-facing incidents",
+ *     trigger: "incident.updated",
+ *     expressions: [],
+ *     conditionGroups: [
+ *         {
+ *             conditions: [{
+ *                 subject: "incident.severity",
+ *                 operation: "one_of",
+ *                 paramBindings: [{
+ *                     arrayValue: [{
+ *                         literal: "01K675152G91VK4S8YYT7NKPAE",
+ *                     }],
+ *                 }],
+ *             }],
+ *         },
+ *         {
+ *             conditions: [
+ *                 {
+ *                     subject: "incident.severity",
+ *                     operation: "one_of",
+ *                     paramBindings: [{
+ *                         arrayValue: [{
+ *                             literal: "01KCZFEB7DPVCQQM262JTKN5RH",
+ *                         }],
+ *                     }],
+ *                 },
+ *                 {
+ *                     subject: affectedCustomers.then(affectedCustomers => `incident.custom_field["${affectedCustomers.id}"]`),
+ *                     operation: "one_of",
+ *                     paramBindings: [{
+ *                         arrayValue: [{
+ *                             literal: allCustomers.then(allCustomers => allCustomers.id),
+ *                         }],
+ *                     }],
+ *                 },
+ *             ],
+ *         },
+ *     ],
+ *     steps: [{
+ *         id: "01KDEMWQCS30P3GHAVNG9VGKWS",
+ *         name: "incident.subscribe_user_to_incident",
+ *         paramBindings: [
+ *             {
+ *                 value: {
+ *                     reference: "incident",
+ *                 },
+ *             },
+ *             {
+ *                 arrayValue: [
+ *                     {
+ *                         literal: csmLead.then(csmLead => csmLead.id),
+ *                     },
+ *                     {
+ *                         literal: csmDeputy.then(csmDeputy => csmDeputy.id),
+ *                     },
+ *                 ],
+ *             },
+ *         ],
+ *     }],
+ *     onceFors: ["incident"],
+ *     privateIncidentScope: "none",
+ *     continueOnStepError: false,
+ *     runsOnIncidents: "newly_created_and_active",
+ *     runsOnIncidentModes: ["standard"],
+ *     state: "draft",
+ * });
+ * ```
+ */
+export declare class Workflow extends pulumi.CustomResource {
+    /**
+     * Get an existing Workflow resource's state with the given name, ID, and optional extra
+     * properties used to qualify the lookup.
+     *
+     * @param name The _unique_ name of the resulting resource.
+     * @param id The _unique_ provider ID of the resource to lookup.
+     * @param state Any extra arguments used during the lookup.
+     * @param opts Optional settings to control the behavior of the CustomResource.
+     */
+    static get(name: string, id: pulumi.Input<pulumi.ID>, state?: WorkflowState, opts?: pulumi.CustomResourceOptions): Workflow;
+    /**
+     * Returns true if the given object is an instance of Workflow.  This is designed to work even
+     * when multiple copies of the Pulumi SDK have been loaded into the same process.
+     */
+    static isInstance(obj: any): obj is Workflow;
+    /**
+     * Groups of prerequisite conditions. All conditions in at least one group must be satisfied
+     */
+    readonly conditionGroups: pulumi.Output<outputs.WorkflowConditionGroup[]>;
+    /**
+     * Whether to continue executing the workflow if a step fails
+     */
+    readonly continueOnStepError: pulumi.Output<boolean>;
+    /**
+     * Configuration controlling workflow delay behaviour
+     */
+    readonly delay: pulumi.Output<outputs.WorkflowDelay | undefined>;
+    /**
+     * The expressions to be prepared for use by steps and conditions
+     */
+    readonly expressions: pulumi.Output<outputs.WorkflowExpression[]>;
+    /**
+     * Folder to display the workflow in
+     */
+    readonly folder: pulumi.Output<string | undefined>;
+    /**
+     * User-configured form fields available in the workflow scope (manual triggers only)
+     */
+    readonly formFields: pulumi.Output<outputs.WorkflowFormField[] | undefined>;
+    /**
+     * Whether to include private escalations
+     */
+    readonly includePrivateEscalations: pulumi.Output<boolean>;
+    /**
+     * DEPRECATED: use `privateIncidentScope` instead. `true` when the workflow runs on private incidents (a `privateIncidentScope` of `all` or `owningTeams`), `false` when the scope is `none`.
+     *
+     * @deprecated Use `privateIncidentScope` instead. When both are set they must agree (include_private_incidents is true for the all and owningTeams scopes, false for none).
+     */
+    readonly includePrivateIncidents: pulumi.Output<boolean>;
+    /**
+     * Name provided by the user when creating the workflow
+     */
+    readonly name: pulumi.Output<string>;
+    /**
+     * This workflow will run 'once for' a list of references
+     */
+    readonly onceFors: pulumi.Output<string[]>;
+    /**
+     * IDs of the teams that own this workflow
+     */
+    readonly owningTeamIds: pulumi.Output<string[] | undefined>;
+    /**
+     * Which private incidents this workflow acts on: every private incident (all), those an owning team can see (owning_teams), or none. Possible values are: `all`, `owningTeams`, `none`.
+     */
+    readonly privateIncidentScope: pulumi.Output<string>;
+    /**
+     * Which incident modes should this workflow run on? By default, workflows only run on standard incidents, but can also be configured to run on test and retrospective incidents. Possible values are: `standard`, `test`, `retrospective`.
+     */
+    readonly runsOnIncidentModes: pulumi.Output<string[]>;
+    /**
+     * Which incidents should the workflow be applied to? Possible values are: `newlyCreated`, `newlyCreatedAndActive`.
+     */
+    readonly runsOnIncidents: pulumi.Output<string>;
+    /**
+     * The shortform used to trigger this workflow (only applicable for manual triggers)
+     */
+    readonly shortform: pulumi.Output<string | undefined>;
+    /**
+     * What state this workflow is in. Possible values are: `active`, `disabled`, `draft`, `error`.
+     */
+    readonly state: pulumi.Output<string>;
+    /**
+     * Steps that are executed as part of the workflow
+     */
+    readonly steps: pulumi.Output<outputs.WorkflowStep[]>;
+    /**
+     * Unique name of the trigger
+     */
+    readonly trigger: pulumi.Output<string>;
+    /**
+     * Create a Workflow resource with the given unique name, arguments, and options.
+     *
+     * @param name The _unique_ name of the resource.
+     * @param args The arguments to use to populate this resource's properties.
+     * @param opts A bag of options that control this resource's behavior.
+     */
+    constructor(name: string, args: WorkflowArgs, opts?: pulumi.CustomResourceOptions);
+}
+/**
+ * Input properties used for looking up and filtering Workflow resources.
+ */
+export interface WorkflowState {
+    /**
+     * Groups of prerequisite conditions. All conditions in at least one group must be satisfied
+     */
+    conditionGroups?: pulumi.Input<pulumi.Input<inputs.WorkflowConditionGroup>[] | undefined>;
+    /**
+     * Whether to continue executing the workflow if a step fails
+     */
+    continueOnStepError?: pulumi.Input<boolean | undefined>;
+    /**
+     * Configuration controlling workflow delay behaviour
+     */
+    delay?: pulumi.Input<inputs.WorkflowDelay | undefined>;
+    /**
+     * The expressions to be prepared for use by steps and conditions
+     */
+    expressions?: pulumi.Input<pulumi.Input<inputs.WorkflowExpression>[] | undefined>;
+    /**
+     * Folder to display the workflow in
+     */
+    folder?: pulumi.Input<string | undefined>;
+    /**
+     * User-configured form fields available in the workflow scope (manual triggers only)
+     */
+    formFields?: pulumi.Input<pulumi.Input<inputs.WorkflowFormField>[] | undefined>;
+    /**
+     * Whether to include private escalations
+     */
+    includePrivateEscalations?: pulumi.Input<boolean | undefined>;
+    /**
+     * DEPRECATED: use `privateIncidentScope` instead. `true` when the workflow runs on private incidents (a `privateIncidentScope` of `all` or `owningTeams`), `false` when the scope is `none`.
+     *
+     * @deprecated Use `privateIncidentScope` instead. When both are set they must agree (include_private_incidents is true for the all and owningTeams scopes, false for none).
+     */
+    includePrivateIncidents?: pulumi.Input<boolean | undefined>;
+    /**
+     * Name provided by the user when creating the workflow
+     */
+    name?: pulumi.Input<string | undefined>;
+    /**
+     * This workflow will run 'once for' a list of references
+     */
+    onceFors?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+    /**
+     * IDs of the teams that own this workflow
+     */
+    owningTeamIds?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+    /**
+     * Which private incidents this workflow acts on: every private incident (all), those an owning team can see (owning_teams), or none. Possible values are: `all`, `owningTeams`, `none`.
+     */
+    privateIncidentScope?: pulumi.Input<string | undefined>;
+    /**
+     * Which incident modes should this workflow run on? By default, workflows only run on standard incidents, but can also be configured to run on test and retrospective incidents. Possible values are: `standard`, `test`, `retrospective`.
+     */
+    runsOnIncidentModes?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+    /**
+     * Which incidents should the workflow be applied to? Possible values are: `newlyCreated`, `newlyCreatedAndActive`.
+     */
+    runsOnIncidents?: pulumi.Input<string | undefined>;
+    /**
+     * The shortform used to trigger this workflow (only applicable for manual triggers)
+     */
+    shortform?: pulumi.Input<string | undefined>;
+    /**
+     * What state this workflow is in. Possible values are: `active`, `disabled`, `draft`, `error`.
+     */
+    state?: pulumi.Input<string | undefined>;
+    /**
+     * Steps that are executed as part of the workflow
+     */
+    steps?: pulumi.Input<pulumi.Input<inputs.WorkflowStep>[] | undefined>;
+    /**
+     * Unique name of the trigger
+     */
+    trigger?: pulumi.Input<string | undefined>;
+}
+/**
+ * The set of arguments for constructing a Workflow resource.
+ */
+export interface WorkflowArgs {
+    /**
+     * Groups of prerequisite conditions. All conditions in at least one group must be satisfied
+     */
+    conditionGroups: pulumi.Input<pulumi.Input<inputs.WorkflowConditionGroup>[]>;
+    /**
+     * Whether to continue executing the workflow if a step fails
+     */
+    continueOnStepError: pulumi.Input<boolean>;
+    /**
+     * Configuration controlling workflow delay behaviour
+     */
+    delay?: pulumi.Input<inputs.WorkflowDelay | undefined>;
+    /**
+     * The expressions to be prepared for use by steps and conditions
+     */
+    expressions: pulumi.Input<pulumi.Input<inputs.WorkflowExpression>[]>;
+    /**
+     * Folder to display the workflow in
+     */
+    folder?: pulumi.Input<string | undefined>;
+    /**
+     * User-configured form fields available in the workflow scope (manual triggers only)
+     */
+    formFields?: pulumi.Input<pulumi.Input<inputs.WorkflowFormField>[] | undefined>;
+    /**
+     * Whether to include private escalations
+     */
+    includePrivateEscalations?: pulumi.Input<boolean | undefined>;
+    /**
+     * DEPRECATED: use `privateIncidentScope` instead. `true` when the workflow runs on private incidents (a `privateIncidentScope` of `all` or `owningTeams`), `false` when the scope is `none`.
+     *
+     * @deprecated Use `privateIncidentScope` instead. When both are set they must agree (include_private_incidents is true for the all and owningTeams scopes, false for none).
+     */
+    includePrivateIncidents?: pulumi.Input<boolean | undefined>;
+    /**
+     * Name provided by the user when creating the workflow
+     */
+    name?: pulumi.Input<string | undefined>;
+    /**
+     * This workflow will run 'once for' a list of references
+     */
+    onceFors: pulumi.Input<pulumi.Input<string>[]>;
+    /**
+     * IDs of the teams that own this workflow
+     */
+    owningTeamIds?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+    /**
+     * Which private incidents this workflow acts on: every private incident (all), those an owning team can see (owning_teams), or none. Possible values are: `all`, `owningTeams`, `none`.
+     */
+    privateIncidentScope?: pulumi.Input<string | undefined>;
+    /**
+     * Which incident modes should this workflow run on? By default, workflows only run on standard incidents, but can also be configured to run on test and retrospective incidents. Possible values are: `standard`, `test`, `retrospective`.
+     */
+    runsOnIncidentModes: pulumi.Input<pulumi.Input<string>[]>;
+    /**
+     * Which incidents should the workflow be applied to? Possible values are: `newlyCreated`, `newlyCreatedAndActive`.
+     */
+    runsOnIncidents: pulumi.Input<string>;
+    /**
+     * The shortform used to trigger this workflow (only applicable for manual triggers)
+     */
+    shortform?: pulumi.Input<string | undefined>;
+    /**
+     * What state this workflow is in. Possible values are: `active`, `disabled`, `draft`, `error`.
+     */
+    state: pulumi.Input<string>;
+    /**
+     * Steps that are executed as part of the workflow
+     */
+    steps: pulumi.Input<pulumi.Input<inputs.WorkflowStep>[]>;
+    /**
+     * Unique name of the trigger
+     */
+    trigger: pulumi.Input<string>;
+}
+//# sourceMappingURL=workflow.d.ts.map