import * as pulumi from "@pulumi/pulumi"; import * as inputs from "../types/input"; export interface AlertGroupingSettingConfig { /** * One of `any` or `all`. This setting is only required and applies when `type` is set to `contentBased` or `contentBasedIntelligent`. Group alerts based on one or all of `fields` value(s). */ aggregate?: pulumi.Input; /** * Alerts will be grouped together if the content of these fields match. This setting is only required and applies when `type` is set to `contentBased` or `contentBasedIntelligent`. */ fields?: pulumi.Input[]>; /** * An array of strings which represent the iag fields with which to intelligently group against. This setting applies only when `type` is set to `intelligent`. Default: ["summary"]. */ iagFields?: pulumi.Input[]>; /** * The maximum amount of time allowed between Alerts. This setting applies only when `type` is set to `intelligent`, `contentBased`, `contentBasedIntelligent`. Value must be between `300` and `3600` or exactly `86400` (86400 is supported only for `contentBased` alert grouping). Any Alerts arriving greater than `timeWindow` seconds apart will not be grouped together. This is a rolling time window and is counted from the most recently grouped alert. The window is extended every time a new alert is added to the group, up to 24 hours. To use the recommended time window leave this value unset or set it to `null`. */ timeWindow?: pulumi.Input; /** * The duration in seconds within which to automatically group incoming alerts. This setting is only required and applies when `type` is set to `time`. To continue grouping alerts until the incident is resolved leave this value unset or set it to `null`. */ timeout?: pulumi.Input; } export interface AutomationActionsActionActionDataReference { /** * The command to execute the script with. */ invocationCommand?: pulumi.Input; /** * The arguments to pass to the Process Automation job execution. */ processAutomationJobArguments?: pulumi.Input; /** * The ID of the Process Automation job to execute. */ processAutomationJobId?: pulumi.Input; /** * The expression that filters on which nodes a Process Automation Job executes [Learn more](https://docs.rundeck.com/docs/manual/05-nodes.html#node-filtering). */ processAutomationNodeFilter?: pulumi.Input; /** * Body of the script to be executed on the Runner. Max length is 16777215 characters. */ script?: pulumi.Input; } export interface EscalationPolicyRule { /** * The number of minutes before an unacknowledged incident escalates away from this rule. */ escalationDelayInMinutes: pulumi.Input; /** * The strategy used to assign the escalation rule to an incident. Documented below. */ escalationRuleAssignmentStrategy?: pulumi.Input; /** * The ID of the escalation policy. */ id?: pulumi.Input; targets: pulumi.Input[]>; } export interface EscalationPolicyRuleEscalationRuleAssignmentStrategy { /** * Can be `roundRobin` or `assignToEveryone`. */ type?: pulumi.Input; } export interface EscalationPolicyRuleTarget { /** * A target ID */ id: pulumi.Input; /** * Can be `userReference` or `scheduleReference`. Defaults to `userReference`. For multiple users as example, repeat the target. */ type?: pulumi.Input; } export interface EventOrchestrationGlobalCacheVariableCondition { /** * A [PCL condition](https://developer.pagerduty.com/docs/ZG9jOjM1NTE0MDc0-pcl-overview) string. */ expression: pulumi.Input; } export interface EventOrchestrationGlobalCacheVariableConfiguration { /** * The type of data that will eventually be set for the Cache Variable via an API request. This field is only used when type is `externalData` */ dataType?: pulumi.Input; /** * A [RE2 regular expression][4] that will be matched against the field specified via the `source` argument. This field is only used when `type` is `recentValue` */ regex?: pulumi.Input; /** * The path to the event field where the `regex` will be applied to extract a value. You can use any valid [PCL path](https://developer.pagerduty.com/docs/ZG9jOjM1NTE0MDc0-pcl-overview#paths). This field is only used when `type` is `recentValue` */ source?: pulumi.Input; /** * The number of seconds indicating how long to count incoming trigger events for. This field is only used when `type` is `triggerEventCount` or `externalData` */ ttlSeconds?: pulumi.Input; /** * The [type of value](https://support.pagerduty.com/docs/event-orchestration-variables) to store into the Cache Variable. Can be one of: `recentValue`, `triggerEventCount` or `externalData`. */ type: pulumi.Input; } export interface EventOrchestrationGlobalCatchAll { /** * These are the actions that will be taken to change the resulting alert and incident. `catchAll` supports all actions described above for `rule` _except_ `routeTo` action. */ actions: pulumi.Input; } export interface EventOrchestrationGlobalCatchAllActions { /** * Add this text as a note on the resulting incident. */ annotate?: pulumi.Input; /** * Create a [Webhook](https://support.pagerduty.com/docs/event-orchestration#webhooks) to be run for certain alert states. */ automationAction?: pulumi.Input; /** * When true, this event will be dropped. Dropped events will not trigger or resolve an alert or an incident. Dropped events will not be evaluated against router rules. */ dropEvent?: pulumi.Input; /** * The ID of the Escalation Policy you want to assign incidents to. Event rules with this action will override the Escalation Policy already set on a Service's settings, with what is configured by this action. */ escalationPolicy?: pulumi.Input; /** * sets whether the resulting alert status is trigger or resolve. Allowed values are: `trigger`, `resolve` */ eventAction?: pulumi.Input; /** * Replace any CEF field or Custom Details object field using custom variables. */ extractions?: pulumi.Input[]>; /** * Assign a custom field to the resulting incident. */ incidentCustomFieldUpdates?: pulumi.Input[]>; /** * The ID of the priority you want to set on resulting incident. Consider using the `pagerduty.getPriority` data source. */ priority?: pulumi.Input; /** * The ID of a Set from this Global Orchestration whose rules you also want to use with events that match this rule. */ routeTo?: pulumi.Input; /** * sets Severity of the resulting alert. Allowed values are: `info`, `error`, `warning`, `critical` */ severity?: pulumi.Input; /** * Set whether the resulting alert is suppressed. Suppressed alerts will not trigger an incident. */ suppress?: pulumi.Input; /** * The number of seconds to suspend the resulting alert before triggering. This effectively pauses incident notifications. If a `resolve` event arrives before the alert triggers then PagerDuty won't create an incident for this alert. */ suspend?: pulumi.Input; /** * Populate variables from event payloads and use those variables in other event actions. */ variables?: pulumi.Input[]>; } export interface EventOrchestrationGlobalCatchAllActionsAutomationAction { /** * When true, PagerDuty's servers will automatically send this webhook request as soon as the resulting incident or alert is created. When false, your incident responder will be able to manually trigger the Webhook via the PagerDuty website and mobile app. */ autoSend?: pulumi.Input; /** * Specify custom key/value pairs that'll be sent with the webhook request as request headers. */ headers?: pulumi.Input[]>; /** * Name of this Webhook. */ name: pulumi.Input; /** * Specify custom key/value pairs that'll be included in the webhook request's JSON payload. */ parameters?: pulumi.Input[]>; /** * The Webhook will be associated (or automatically triggered, if `autoSend` is `true`) with the incident or alert, whenever an alert reaches the specified state. Allowed values are: `["alertTriggered"]`, `["alertSuspended"]`, `["alertSuppressed"]`. NOTE: `autoSend` must be `true` for trigger types of `["alertSuspended"]` and `["alertSuppressed"]` */ triggerTypes?: pulumi.Input; /** * The API endpoint where PagerDuty's servers will send the webhook request. */ url: pulumi.Input; } export interface EventOrchestrationGlobalCatchAllActionsAutomationActionHeader { /** * Name to identify the header */ key: pulumi.Input; /** * Value of this header */ value: pulumi.Input; } export interface EventOrchestrationGlobalCatchAllActionsAutomationActionParameter { /** * Name to identify the parameter */ key: pulumi.Input; /** * Value of this parameter */ value: pulumi.Input; } export interface EventOrchestrationGlobalCatchAllActionsExtraction { /** * A [RE2 regular expression](https://github.com/google/re2/wiki/Syntax) that will be matched against field specified via the `source` argument. If the regex contains one or more capture groups, their values will be extracted and appended together. If it contains no capture groups, the whole match is used. This field can be ignored for `template` based extractions. */ regex?: pulumi.Input; /** * The path to the event field where the `regex` will be applied to extract a value. You can use any valid [PCL path](https://developer.pagerduty.com/docs/ZG9jOjM1NTE0MDc0-pcl-overview#paths) like `event.summary` and you can reference previously-defined variables using a path like `variables.hostname`. This field can be ignored for `template` based extractions. */ source?: pulumi.Input; /** * The PagerDuty Common Event Format [PD-CEF](https://support.pagerduty.com/docs/pd-cef) field that will be set with the value from the `template` or based on `regex` and `source` fields. */ target: pulumi.Input; /** * A string that will be used to populate the `target` field. You can reference variables or event data within your template using double curly braces. For example: * * Use variables named `ip` and `subnet` with a template like: `{{variables.ip}}/{{variables.subnet}}` * * Combine the event severity & summary with template like: `{{event.severity}}:{{event.summary}}` */ template?: pulumi.Input; } export interface EventOrchestrationGlobalCatchAllActionsIncidentCustomFieldUpdate { /** * The custom field id */ id: pulumi.Input; /** * The value to assign to this custom field */ value: pulumi.Input; } export interface EventOrchestrationGlobalCatchAllActionsVariable { /** * The name of the variable */ name: pulumi.Input; /** * Path to a field in an event, in dot-notation. This supports both PagerDuty Common Event Format [PD-CEF](https://support.pagerduty.com/docs/pd-cef) and non-CEF fields. Eg: Use `event.summary` for the `summary` CEF field. Use `raw_event.fieldname` to read from the original event `fieldname` data. You can use any valid [PCL path](https://developer.pagerduty.com/docs/ZG9jOjM1NTE0MDc0-pcl-overview#paths). */ path: pulumi.Input; /** * Only `regex` is supported */ type: pulumi.Input; /** * The Regex expression to match against. Must use valid [RE2 regular expression](https://github.com/google/re2/wiki/Syntax) syntax. */ value: pulumi.Input; } export interface EventOrchestrationGlobalSet { /** * The ID of this set of rules. Rules in other sets can route events into this set using the rule's `routeTo` property. */ id: pulumi.Input; /** * The Global Orchestration evaluates Events against these Rules, one at a time, and applies all the actions for first rule it finds where the event matches the rule's conditions. If no rules are provided as part of Terraform configuration, the API returns empty list of rules. */ rules?: pulumi.Input[]>; } export interface EventOrchestrationGlobalSetRule { /** * Actions that will be taken to change the resulting alert and incident, when an event matches this rule. */ actions: pulumi.Input; /** * Each of these conditions is evaluated to check if an event matches this rule. The rule is considered a match if any of these conditions match. If none are provided, the event will `always` match against the rule. */ conditions?: pulumi.Input[]>; /** * Indicates whether the rule is disabled and would therefore not be evaluated. */ disabled?: pulumi.Input; /** * The ID of the rule within the set. */ id?: pulumi.Input; /** * A description of this rule's purpose. */ label?: pulumi.Input; } export interface EventOrchestrationGlobalSetRuleActions { /** * Add this text as a note on the resulting incident. */ annotate?: pulumi.Input; /** * Create a [Webhook](https://support.pagerduty.com/docs/event-orchestration#webhooks) to be run for certain alert states. */ automationAction?: pulumi.Input; /** * When true, this event will be dropped. Dropped events will not trigger or resolve an alert or an incident. Dropped events will not be evaluated against router rules. */ dropEvent?: pulumi.Input; /** * The ID of the Escalation Policy you want to assign incidents to. Event rules with this action will override the Escalation Policy already set on a Service's settings, with what is configured by this action. */ escalationPolicy?: pulumi.Input; /** * sets whether the resulting alert status is trigger or resolve. Allowed values are: `trigger`, `resolve` */ eventAction?: pulumi.Input; /** * Replace any CEF field or Custom Details object field using custom variables. */ extractions?: pulumi.Input[]>; /** * Assign a custom field to the resulting incident. */ incidentCustomFieldUpdates?: pulumi.Input[]>; /** * The ID of the priority you want to set on resulting incident. Consider using the `pagerduty.getPriority` data source. */ priority?: pulumi.Input; /** * The ID of a Set from this Global Orchestration whose rules you also want to use with events that match this rule. */ routeTo?: pulumi.Input; /** * sets Severity of the resulting alert. Allowed values are: `info`, `error`, `warning`, `critical` */ severity?: pulumi.Input; /** * Set whether the resulting alert is suppressed. Suppressed alerts will not trigger an incident. */ suppress?: pulumi.Input; /** * The number of seconds to suspend the resulting alert before triggering. This effectively pauses incident notifications. If a `resolve` event arrives before the alert triggers then PagerDuty won't create an incident for this alert. */ suspend?: pulumi.Input; /** * Populate variables from event payloads and use those variables in other event actions. */ variables?: pulumi.Input[]>; } export interface EventOrchestrationGlobalSetRuleActionsAutomationAction { /** * When true, PagerDuty's servers will automatically send this webhook request as soon as the resulting incident or alert is created. When false, your incident responder will be able to manually trigger the Webhook via the PagerDuty website and mobile app. */ autoSend?: pulumi.Input; /** * Specify custom key/value pairs that'll be sent with the webhook request as request headers. */ headers?: pulumi.Input[]>; /** * Name of this Webhook. */ name: pulumi.Input; /** * Specify custom key/value pairs that'll be included in the webhook request's JSON payload. */ parameters?: pulumi.Input[]>; /** * The Webhook will be associated (or automatically triggered, if `autoSend` is `true`) with the incident or alert, whenever an alert reaches the specified state. Allowed values are: `["alertTriggered"]`, `["alertSuspended"]`, `["alertSuppressed"]`. NOTE: `autoSend` must be `true` for trigger types of `["alertSuspended"]` and `["alertSuppressed"]` */ triggerTypes?: pulumi.Input; /** * The API endpoint where PagerDuty's servers will send the webhook request. */ url: pulumi.Input; } export interface EventOrchestrationGlobalSetRuleActionsAutomationActionHeader { /** * Name to identify the header */ key: pulumi.Input; /** * Value of this header */ value: pulumi.Input; } export interface EventOrchestrationGlobalSetRuleActionsAutomationActionParameter { /** * Name to identify the parameter */ key: pulumi.Input; /** * Value of this parameter */ value: pulumi.Input; } export interface EventOrchestrationGlobalSetRuleActionsExtraction { /** * A [RE2 regular expression](https://github.com/google/re2/wiki/Syntax) that will be matched against field specified via the `source` argument. If the regex contains one or more capture groups, their values will be extracted and appended together. If it contains no capture groups, the whole match is used. This field can be ignored for `template` based extractions. */ regex?: pulumi.Input; /** * The path to the event field where the `regex` will be applied to extract a value. You can use any valid [PCL path](https://developer.pagerduty.com/docs/ZG9jOjM1NTE0MDc0-pcl-overview#paths) like `event.summary` and you can reference previously-defined variables using a path like `variables.hostname`. This field can be ignored for `template` based extractions. */ source?: pulumi.Input; /** * The PagerDuty Common Event Format [PD-CEF](https://support.pagerduty.com/docs/pd-cef) field that will be set with the value from the `template` or based on `regex` and `source` fields. */ target: pulumi.Input; /** * A string that will be used to populate the `target` field. You can reference variables or event data within your template using double curly braces. For example: * * Use variables named `ip` and `subnet` with a template like: `{{variables.ip}}/{{variables.subnet}}` * * Combine the event severity & summary with template like: `{{event.severity}}:{{event.summary}}` */ template?: pulumi.Input; } export interface EventOrchestrationGlobalSetRuleActionsIncidentCustomFieldUpdate { /** * The custom field id */ id: pulumi.Input; /** * The value to assign to this custom field */ value: pulumi.Input; } export interface EventOrchestrationGlobalSetRuleActionsVariable { /** * The name of the variable */ name: pulumi.Input; /** * Path to a field in an event, in dot-notation. This supports both PagerDuty Common Event Format [PD-CEF](https://support.pagerduty.com/docs/pd-cef) and non-CEF fields. Eg: Use `event.summary` for the `summary` CEF field. Use `raw_event.fieldname` to read from the original event `fieldname` data. You can use any valid [PCL path](https://developer.pagerduty.com/docs/ZG9jOjM1NTE0MDc0-pcl-overview#paths). */ path: pulumi.Input; /** * Only `regex` is supported */ type: pulumi.Input; /** * The Regex expression to match against. Must use valid [RE2 regular expression](https://github.com/google/re2/wiki/Syntax) syntax. */ value: pulumi.Input; } export interface EventOrchestrationGlobalSetRuleCondition { /** * A [PCL condition](https://developer.pagerduty.com/docs/ZG9jOjM1NTE0MDc0-pcl-overview) string. */ expression: pulumi.Input; } export interface EventOrchestrationIntegration { /** * ID of the integration */ id?: pulumi.Input; label?: pulumi.Input; /** * A single-item list containing a parameter object describing the integration */ parameters?: pulumi.Input[]>; } export interface EventOrchestrationIntegrationParameter { /** * Routing key that routes to this Orchestration. */ routingKey?: pulumi.Input; /** * Type of the routing key. `global` is the default type. */ type?: pulumi.Input; } export interface EventOrchestrationRouterCatchAll { /** * These are the actions that will be taken to change the resulting alert and incident. */ actions: pulumi.Input; } export interface EventOrchestrationRouterCatchAllActions { /** * Defines where an alert will be sent if doesn't match any rules. Can either be the ID of a Service _or_ the string `"unrouted"` to send events to the Unrouted Orchestration. */ routeTo: pulumi.Input; } export interface EventOrchestrationRouterSet { /** * ID of the `start` set. Router supports only one set and it's id has to be `start` */ id: pulumi.Input; /** * The Router evaluates Events against these Rules, one at a time, and routes each Event to a specific Service based on the first rule that matches. If no rules are provided as part of Terraform configuration, the API returns empty list of rules. */ rules?: pulumi.Input[]>; } export interface EventOrchestrationRouterSetRule { /** * Actions that will be taken to change the resulting alert and incident, when an event matches this rule. */ actions: pulumi.Input; /** * Each of these conditions is evaluated to check if an event matches this rule. The rule is considered a match if any of these conditions match. If none are provided, the event will _always_ match against the rule. */ conditions?: pulumi.Input[]>; /** * Indicates whether the rule is disabled and would therefore not be evaluated. */ disabled?: pulumi.Input; /** * The ID of the rule within the `start` set. */ id?: pulumi.Input; /** * A description of this rule's purpose. */ label?: pulumi.Input; } export interface EventOrchestrationRouterSetRuleActions { /** * supports the following: */ dynamicRouteTos?: pulumi.Input[]>; routeTo?: pulumi.Input; } export interface EventOrchestrationRouterSetRuleActionsDynamicRouteTo { /** * Indicates whether the extracted value from the source is a service's name or ID. Allowed values are: `serviceName`, `serviceId` * * If an event has a value at the specified `source`, and if the `regex` successfully matches the value, and if the matching portion is valid Service ID or Name, then the event will be routed to that service. Otherwise the event will be checked against any subsequent router rules. */ lookupBy: pulumi.Input; /** * The regular expression, used to extract a value from the source field. Must use valid [RE2 regular expression](https://github.com/google/re2/wiki/Syntax) syntax. */ regex: pulumi.Input; /** * The path to a field in an event. */ source: pulumi.Input; } export interface EventOrchestrationRouterSetRuleCondition { /** * A [PCL condition](https://developer.pagerduty.com/docs/ZG9jOjM1NTE0MDc0-pcl-overview) string. */ expression: pulumi.Input; } export interface EventOrchestrationServiceCacheVariableCondition { /** * A [PCL condition](https://developer.pagerduty.com/docs/ZG9jOjM1NTE0MDc0-pcl-overview) string. */ expression: pulumi.Input; } export interface EventOrchestrationServiceCacheVariableConfiguration { /** * The type of data that will eventually be set for the Cache Variable via an API request. This field is only used when type is `externalData` */ dataType?: pulumi.Input; /** * A [RE2 regular expression][4] that will be matched against the field specified via the `source` argument. This field is only used when `type` is `recentValue` */ regex?: pulumi.Input; /** * The path to the event field where the `regex` will be applied to extract a value. You can use any valid [PCL path](https://developer.pagerduty.com/docs/ZG9jOjM1NTE0MDc0-pcl-overview#paths). This field is only used when `type` is `recentValue` */ source?: pulumi.Input; /** * The number of seconds indicating how long to count incoming trigger events for. This field is only used when `type` is `triggerEventCount` or `externalData` */ ttlSeconds?: pulumi.Input; /** * The [type of value](https://support.pagerduty.com/docs/event-orchestration-variables) to store into the Cache Variable. Can be one of: `recentValue`, `triggerEventCount` or `externalData`. */ type: pulumi.Input; } export interface EventOrchestrationServiceCatchAll { /** * These are the actions that will be taken to change the resulting alert and incident. `catchAll` supports all actions described above for `rule` _except_ `routeTo` action. */ actions: pulumi.Input; } export interface EventOrchestrationServiceCatchAllActions { /** * Add this text as a note on the resulting incident. */ annotate?: pulumi.Input; /** * Create a [Webhook](https://support.pagerduty.com/docs/event-orchestration#webhooks) to be run for certain alert states. */ automationAction?: pulumi.Input; /** * The ID of the Escalation Policy you want to assign incidents to. Event rules with this action will override the Escalation Policy already set on a Service's settings, with what is configured by this action. */ escalationPolicy?: pulumi.Input; /** * sets whether the resulting alert status is trigger or resolve. Allowed values are: `trigger`, `resolve` */ eventAction?: pulumi.Input; /** * Replace any CEF field or Custom Details object field using custom variables. */ extractions?: pulumi.Input[]>; /** * Assign a custom field to the resulting incident. */ incidentCustomFieldUpdates?: pulumi.Input[]>; /** * Configure a [Process Automation](https://support.pagerduty.com/docs/event-orchestration#process-automation) to be run for certain alert states. */ pagerdutyAutomationAction?: pulumi.Input; /** * The ID of the priority you want to set on resulting incident. Consider using the `pagerduty.getPriority` data source. */ priority?: pulumi.Input; /** * The ID of a Set from this Service Orchestration whose rules you also want to use with events that match this rule. * * @deprecated The 'route_to' attribute is no longer supported for catch-all rules. */ routeTo?: pulumi.Input; /** * sets Severity of the resulting alert. Allowed values are: `info`, `error`, `warning`, `critical` */ severity?: pulumi.Input; /** * Set whether the resulting alert is suppressed. Suppressed alerts will not trigger an incident. */ suppress?: pulumi.Input; /** * The number of seconds to suspend the resulting alert before triggering. This effectively pauses incident notifications. If a `resolve` event arrives before the alert triggers then PagerDuty won't create an incident for this alert. */ suspend?: pulumi.Input; /** * Populate variables from event payloads and use those variables in other event actions. */ variables?: pulumi.Input[]>; } export interface EventOrchestrationServiceCatchAllActionsAutomationAction { /** * When true, PagerDuty's servers will automatically send this webhook request as soon as the resulting incident or alert is created. When false, your incident responder will be able to manually trigger the Webhook via the PagerDuty website and mobile app. */ autoSend?: pulumi.Input; /** * Specify custom key/value pairs that'll be sent with the webhook request as request headers. */ headers?: pulumi.Input[]>; /** * Name of this Webhook. */ name: pulumi.Input; /** * Specify custom key/value pairs that'll be included in the webhook request's JSON payload. */ parameters?: pulumi.Input[]>; /** * The Webhook will be associated (or automatically triggered, if `autoSend` is `true`) with the incident or alert, whenever an alert reaches the specified state. Allowed values are: `["alertTriggered"]`, `["alertSuspended"]`, `["alertSuppressed"]`. NOTE: `autoSend` must be `true` for trigger types of `["alertSuspended"]` and `["alertSuppressed"]` */ triggerTypes?: pulumi.Input; /** * The API endpoint where PagerDuty's servers will send the webhook request. */ url: pulumi.Input; } export interface EventOrchestrationServiceCatchAllActionsAutomationActionHeader { /** * Name to identify the header */ key: pulumi.Input; /** * Value of this header */ value: pulumi.Input; } export interface EventOrchestrationServiceCatchAllActionsAutomationActionParameter { /** * Name to identify the parameter */ key: pulumi.Input; /** * Value of this parameter */ value: pulumi.Input; } export interface EventOrchestrationServiceCatchAllActionsExtraction { /** * A [RE2 regular expression](https://github.com/google/re2/wiki/Syntax) that will be matched against field specified via the `source` argument. If the regex contains one or more capture groups, their values will be extracted and appended together. If it contains no capture groups, the whole match is used. This field can be ignored for `template` based extractions. */ regex?: pulumi.Input; /** * The path to the event field where the `regex` will be applied to extract a value. You can use any valid [PCL path](https://developer.pagerduty.com/docs/ZG9jOjM1NTE0MDc0-pcl-overview#paths) like `event.summary` and you can reference previously-defined variables using a path like `variables.hostname`. This field can be ignored for `template` based extractions. */ source?: pulumi.Input; /** * The PagerDuty Common Event Format [PD-CEF](https://support.pagerduty.com/docs/pd-cef) field that will be set with the value from the `template` or based on `regex` and `source` fields. */ target: pulumi.Input; /** * A string that will be used to populate the `target` field. You can reference variables or event data within your template using double curly braces. For example: * * Use variables named `ip` and `subnet` with a template like: `{{variables.ip}}/{{variables.subnet}}` * * Combine the event severity & summary with template like: `{{event.severity}}:{{event.summary}}` */ template?: pulumi.Input; } export interface EventOrchestrationServiceCatchAllActionsIncidentCustomFieldUpdate { /** * The custom field id */ id: pulumi.Input; /** * The value to assign to this custom field */ value: pulumi.Input; } export interface EventOrchestrationServiceCatchAllActionsPagerdutyAutomationAction { /** * Id of the Process Automation action to be triggered. */ actionId: pulumi.Input; /** * The Automation Action will be triggered whenever an alert reaches the specified state. Allowed values are: `["alertTriggered"]`, `["alertSuspended"]`, `["alertSuppressed"]` */ triggerTypes?: pulumi.Input; } export interface EventOrchestrationServiceCatchAllActionsVariable { /** * The name of the variable */ name: pulumi.Input; /** * Path to a field in an event, in dot-notation. This supports both PagerDuty Common Event Format [PD-CEF](https://support.pagerduty.com/docs/pd-cef) and non-CEF fields. Eg: Use `event.summary` for the `summary` CEF field. Use `raw_event.fieldname` to read from the original event `fieldname` data. You can use any valid [PCL path](https://developer.pagerduty.com/docs/ZG9jOjM1NTE0MDc0-pcl-overview#paths). */ path: pulumi.Input; /** * Only `regex` is supported */ type: pulumi.Input; /** * The Regex expression to match against. Must use valid [RE2 regular expression](https://github.com/google/re2/wiki/Syntax) syntax. */ value: pulumi.Input; } export interface EventOrchestrationServiceSet { /** * The ID of this set of rules. Rules in other sets can route events into this set using the rule's `routeTo` property. */ id: pulumi.Input; /** * The service orchestration evaluates Events against these Rules, one at a time, and applies all the actions for first rule it finds where the event matches the rule's conditions. If no rules are provided as part of Terraform configuration, the API returns empty list of rules. */ rules?: pulumi.Input[]>; } export interface EventOrchestrationServiceSetRule { /** * Actions that will be taken to change the resulting alert and incident, when an event matches this rule. */ actions: pulumi.Input; /** * Each of these conditions is evaluated to check if an event matches this rule. The rule is considered a match if any of these conditions match. If none are provided, the event will `always` match against the rule. */ conditions?: pulumi.Input[]>; /** * Indicates whether the rule is disabled and would therefore not be evaluated. */ disabled?: pulumi.Input; /** * The ID of the rule within the set. */ id?: pulumi.Input; /** * A description of this rule's purpose. */ label?: pulumi.Input; } export interface EventOrchestrationServiceSetRuleActions { /** * Add this text as a note on the resulting incident. */ annotate?: pulumi.Input; /** * Create a [Webhook](https://support.pagerduty.com/docs/event-orchestration#webhooks) to be run for certain alert states. */ automationAction?: pulumi.Input; /** * The ID of the Escalation Policy you want to assign incidents to. Event rules with this action will override the Escalation Policy already set on a Service's settings, with what is configured by this action. */ escalationPolicy?: pulumi.Input; /** * sets whether the resulting alert status is trigger or resolve. Allowed values are: `trigger`, `resolve` */ eventAction?: pulumi.Input; /** * Replace any CEF field or Custom Details object field using custom variables. */ extractions?: pulumi.Input[]>; /** * Assign a custom field to the resulting incident. */ incidentCustomFieldUpdates?: pulumi.Input[]>; /** * Configure a [Process Automation](https://support.pagerduty.com/docs/event-orchestration#process-automation) to be run for certain alert states. */ pagerdutyAutomationAction?: pulumi.Input; /** * The ID of the priority you want to set on resulting incident. Consider using the `pagerduty.getPriority` data source. */ priority?: pulumi.Input; /** * The ID of a Set from this Service Orchestration whose rules you also want to use with events that match this rule. */ routeTo?: pulumi.Input; /** * sets Severity of the resulting alert. Allowed values are: `info`, `error`, `warning`, `critical` */ severity?: pulumi.Input; /** * Set whether the resulting alert is suppressed. Suppressed alerts will not trigger an incident. */ suppress?: pulumi.Input; /** * The number of seconds to suspend the resulting alert before triggering. This effectively pauses incident notifications. If a `resolve` event arrives before the alert triggers then PagerDuty won't create an incident for this alert. */ suspend?: pulumi.Input; /** * Populate variables from event payloads and use those variables in other event actions. */ variables?: pulumi.Input[]>; } export interface EventOrchestrationServiceSetRuleActionsAutomationAction { /** * When true, PagerDuty's servers will automatically send this webhook request as soon as the resulting incident or alert is created. When false, your incident responder will be able to manually trigger the Webhook via the PagerDuty website and mobile app. */ autoSend?: pulumi.Input; /** * Specify custom key/value pairs that'll be sent with the webhook request as request headers. */ headers?: pulumi.Input[]>; /** * Name of this Webhook. */ name: pulumi.Input; /** * Specify custom key/value pairs that'll be included in the webhook request's JSON payload. */ parameters?: pulumi.Input[]>; /** * The Webhook will be associated (or automatically triggered, if `autoSend` is `true`) with the incident or alert, whenever an alert reaches the specified state. Allowed values are: `["alertTriggered"]`, `["alertSuspended"]`, `["alertSuppressed"]`. NOTE: `autoSend` must be `true` for trigger types of `["alertSuspended"]` and `["alertSuppressed"]` */ triggerTypes?: pulumi.Input; /** * The API endpoint where PagerDuty's servers will send the webhook request. */ url: pulumi.Input; } export interface EventOrchestrationServiceSetRuleActionsAutomationActionHeader { /** * Name to identify the header */ key: pulumi.Input; /** * Value of this header */ value: pulumi.Input; } export interface EventOrchestrationServiceSetRuleActionsAutomationActionParameter { /** * Name to identify the parameter */ key: pulumi.Input; /** * Value of this parameter */ value: pulumi.Input; } export interface EventOrchestrationServiceSetRuleActionsExtraction { /** * A [RE2 regular expression](https://github.com/google/re2/wiki/Syntax) that will be matched against field specified via the `source` argument. If the regex contains one or more capture groups, their values will be extracted and appended together. If it contains no capture groups, the whole match is used. This field can be ignored for `template` based extractions. */ regex?: pulumi.Input; /** * The path to the event field where the `regex` will be applied to extract a value. You can use any valid [PCL path](https://developer.pagerduty.com/docs/ZG9jOjM1NTE0MDc0-pcl-overview#paths) like `event.summary` and you can reference previously-defined variables using a path like `variables.hostname`. This field can be ignored for `template` based extractions. */ source?: pulumi.Input; /** * The PagerDuty Common Event Format [PD-CEF](https://support.pagerduty.com/docs/pd-cef) field that will be set with the value from the `template` or based on `regex` and `source` fields. */ target: pulumi.Input; /** * A string that will be used to populate the `target` field. You can reference variables or event data within your template using double curly braces. For example: * * Use variables named `ip` and `subnet` with a template like: `{{variables.ip}}/{{variables.subnet}}` * * Combine the event severity & summary with template like: `{{event.severity}}:{{event.summary}}` */ template?: pulumi.Input; } export interface EventOrchestrationServiceSetRuleActionsIncidentCustomFieldUpdate { /** * The custom field id */ id: pulumi.Input; /** * The value to assign to this custom field */ value: pulumi.Input; } export interface EventOrchestrationServiceSetRuleActionsPagerdutyAutomationAction { /** * Id of the Process Automation action to be triggered. */ actionId: pulumi.Input; /** * The Automation Action will be triggered whenever an alert reaches the specified state. Allowed values are: `["alertTriggered"]`, `["alertSuspended"]`, `["alertSuppressed"]` */ triggerTypes?: pulumi.Input; } export interface EventOrchestrationServiceSetRuleActionsVariable { /** * The name of the variable */ name: pulumi.Input; /** * Path to a field in an event, in dot-notation. This supports both PagerDuty Common Event Format [PD-CEF](https://support.pagerduty.com/docs/pd-cef) and non-CEF fields. Eg: Use `event.summary` for the `summary` CEF field. Use `raw_event.fieldname` to read from the original event `fieldname` data. You can use any valid [PCL path](https://developer.pagerduty.com/docs/ZG9jOjM1NTE0MDc0-pcl-overview#paths). */ path: pulumi.Input; /** * Only `regex` is supported */ type: pulumi.Input; /** * The Regex expression to match against. Must use valid [RE2 regular expression](https://github.com/google/re2/wiki/Syntax) syntax. */ value: pulumi.Input; } export interface EventOrchestrationServiceSetRuleCondition { /** * A [PCL condition](https://developer.pagerduty.com/docs/ZG9jOjM1NTE0MDc0-pcl-overview) string. */ expression: pulumi.Input; } export interface EventOrchestrationUnroutedCatchAll { /** * These are the actions that will be taken to change the resulting alert and incident. `catchAll` supports all actions described above for `rule` _except_ `routeTo` action. */ actions: pulumi.Input; } export interface EventOrchestrationUnroutedCatchAllActions { /** * sets whether the resulting alert status is trigger or resolve. Allowed values are: `trigger`, `resolve` */ eventAction?: pulumi.Input; /** * Replace any CEF field or Custom Details object field using custom variables. */ extractions?: pulumi.Input[]>; /** * sets Severity of the resulting alert. Allowed values are: `info`, `error`, `warning`, `critical` */ severity?: pulumi.Input; suppress?: pulumi.Input; /** * Populate variables from event payloads and use those variables in other event actions. */ variables?: pulumi.Input[]>; } export interface EventOrchestrationUnroutedCatchAllActionsExtraction { /** * A [RE2 regular expression](https://github.com/google/re2/wiki/Syntax) that will be matched against field specified via the `source` argument. If the regex contains one or more capture groups, their values will be extracted and appended together. If it contains no capture groups, the whole match is used. This field can be ignored for `template` based extractions. */ regex?: pulumi.Input; /** * The path to the event field where the `regex` will be applied to extract a value. You can use any valid [PCL path](https://developer.pagerduty.com/docs/ZG9jOjM1NTE0MDc0-pcl-overview#paths) like `event.summary` and you can reference previously-defined variables using a path like `variables.hostname`. This field can be ignored for `template` based extractions. */ source?: pulumi.Input; /** * The PagerDuty Common Event Format [PD-CEF](https://support.pagerduty.com/docs/pd-cef) field that will be set with the value from the `template` or based on `regex` and `source` fields. */ target: pulumi.Input; /** * A string that will be used to populate the `target` field. You can reference variables or event data within your template using double curly braces. For example: * * Use variables named `ip` and `subnet` with a template like: `{{variables.ip}}/{{variables.subnet}}` * * Combine the event severity & summary with template like: `{{event.severity}}:{{event.summary}}` */ template?: pulumi.Input; } export interface EventOrchestrationUnroutedCatchAllActionsVariable { /** * The name of the variable */ name: pulumi.Input; /** * Path to a field in an event, in dot-notation. This supports both [PD-CEF](https://support.pagerduty.com/docs/pd-cef) and non-CEF fields. Eg: Use `event.summary` for the `summary` CEF field. Use `raw_event.fieldname` to read from the original event `fieldname` data. */ path: pulumi.Input; /** * Only `regex` is supported */ type: pulumi.Input; /** * The Regex expression to match against. Must use valid [RE2 regular expression](https://github.com/google/re2/wiki/Syntax) syntax. */ value: pulumi.Input; } export interface EventOrchestrationUnroutedSet { /** * The ID of this set of rules. Rules in other sets can route events into this set using the rule's `routeTo` property. */ id: pulumi.Input; /** * The Unrouted Orchestration evaluates Events against these Rules, one at a time, and applies all the actions for first rule it finds where the event matches the rule's conditions. If no rules are provided as part of Terraform configuration, the API returns empty list of rules. */ rules?: pulumi.Input[]>; } export interface EventOrchestrationUnroutedSetRule { /** * Actions that will be taken to change the resulting alert and incident, when an event matches this rule. */ actions: pulumi.Input; /** * Each of these conditions is evaluated to check if an event matches this rule. The rule is considered a match if any of these conditions match. If none are provided, the event will `always` match against the rule. */ conditions?: pulumi.Input[]>; /** * Indicates whether the rule is disabled and would therefore not be evaluated. */ disabled?: pulumi.Input; /** * The ID of the rule within the set. */ id?: pulumi.Input; /** * A description of this rule's purpose. */ label?: pulumi.Input; } export interface EventOrchestrationUnroutedSetRuleActions { /** * sets whether the resulting alert status is trigger or resolve. Allowed values are: `trigger`, `resolve` */ eventAction?: pulumi.Input; /** * Replace any CEF field or Custom Details object field using custom variables. */ extractions?: pulumi.Input[]>; /** * The ID of a Set from this Unrouted Orchestration whose rules you also want to use with events that match this rule. */ routeTo?: pulumi.Input; /** * sets Severity of the resulting alert. Allowed values are: `info`, `error`, `warning`, `critical` */ severity?: pulumi.Input; /** * Populate variables from event payloads and use those variables in other event actions. */ variables?: pulumi.Input[]>; } export interface EventOrchestrationUnroutedSetRuleActionsExtraction { /** * A [RE2 regular expression](https://github.com/google/re2/wiki/Syntax) that will be matched against field specified via the `source` argument. If the regex contains one or more capture groups, their values will be extracted and appended together. If it contains no capture groups, the whole match is used. This field can be ignored for `template` based extractions. */ regex?: pulumi.Input; /** * The path to the event field where the `regex` will be applied to extract a value. You can use any valid [PCL path](https://developer.pagerduty.com/docs/ZG9jOjM1NTE0MDc0-pcl-overview#paths) like `event.summary` and you can reference previously-defined variables using a path like `variables.hostname`. This field can be ignored for `template` based extractions. */ source?: pulumi.Input; /** * The PagerDuty Common Event Format [PD-CEF](https://support.pagerduty.com/docs/pd-cef) field that will be set with the value from the `template` or based on `regex` and `source` fields. */ target: pulumi.Input; /** * A string that will be used to populate the `target` field. You can reference variables or event data within your template using double curly braces. For example: * * Use variables named `ip` and `subnet` with a template like: `{{variables.ip}}/{{variables.subnet}}` * * Combine the event severity & summary with template like: `{{event.severity}}:{{event.summary}}` */ template?: pulumi.Input; } export interface EventOrchestrationUnroutedSetRuleActionsVariable { /** * The name of the variable */ name: pulumi.Input; /** * Path to a field in an event, in dot-notation. This supports both [PD-CEF](https://support.pagerduty.com/docs/pd-cef) and non-CEF fields. Eg: Use `event.summary` for the `summary` CEF field. Use `raw_event.fieldname` to read from the original event `fieldname` data. */ path: pulumi.Input; /** * Only `regex` is supported */ type: pulumi.Input; /** * The Regex expression to match against. Must use valid [RE2 regular expression](https://github.com/google/re2/wiki/Syntax) syntax. */ value: pulumi.Input; } export interface EventOrchestrationUnroutedSetRuleCondition { /** * A [PCL condition](https://developer.pagerduty.com/docs/ZG9jOjM1NTE0MDc0-pcl-overview) string. */ expression: pulumi.Input; } export interface GetAlertGroupingSettingConfig { /** * One of `any` or `all`. This setting is only required and applies when `type` is set to `contentBased` or `contentBasedIntelligent`. Group alerts based on one or all of `fields` value(s). */ aggregate?: string; /** * Alerts will be grouped together if the content of these fields match. This setting is only required and applies when `type` is set to `contentBased` or `contentBasedIntelligent`. */ fields?: string[]; /** * An array of strings which represent the iag fields with which to intelligently group against. */ iagFields?: string[]; /** * The maximum amount of time allowed between Alerts. This setting applies only when `type` is set to `intelligent`, `contentBased`, `contentBasedIntelligent`. Value must be between `300` and `3600` or exactly `86400` (86400 is supported only for `contentBased` alert grouping). Any Alerts arriving greater than `timeWindow` seconds apart will not be grouped together. This is a rolling time window and is counted from the most recently grouped alert. The window is extended every time a new alert is added to the group, up to 24 hours. To use the recommended time window leave this value unset or set it to `null`. */ timeWindow?: number; /** * The duration in minutes within which to automatically group incoming alerts. This setting is only required and applies when `type` is set to `time`. To continue grouping alerts until the incident is resolved leave this value unset or set it to `null`. */ timeout?: number; } export interface GetAlertGroupingSettingConfigArgs { /** * One of `any` or `all`. This setting is only required and applies when `type` is set to `contentBased` or `contentBasedIntelligent`. Group alerts based on one or all of `fields` value(s). */ aggregate?: pulumi.Input; /** * Alerts will be grouped together if the content of these fields match. This setting is only required and applies when `type` is set to `contentBased` or `contentBasedIntelligent`. */ fields?: pulumi.Input[]>; /** * An array of strings which represent the iag fields with which to intelligently group against. */ iagFields?: pulumi.Input[]>; /** * The maximum amount of time allowed between Alerts. This setting applies only when `type` is set to `intelligent`, `contentBased`, `contentBasedIntelligent`. Value must be between `300` and `3600` or exactly `86400` (86400 is supported only for `contentBased` alert grouping). Any Alerts arriving greater than `timeWindow` seconds apart will not be grouped together. This is a rolling time window and is counted from the most recently grouped alert. The window is extended every time a new alert is added to the group, up to 24 hours. To use the recommended time window leave this value unset or set it to `null`. */ timeWindow?: pulumi.Input; /** * The duration in minutes within which to automatically group incoming alerts. This setting is only required and applies when `type` is set to `time`. To continue grouping alerts until the incident is resolved leave this value unset or set it to `null`. */ timeout?: pulumi.Input; } export interface GetEventOrchestrationIntegrationDetail { /** * ID of the integration */ id?: string; label?: string; /** * A single-item list containing a parameter object describing the integration */ parameters?: inputs.GetEventOrchestrationIntegrationDetailParameter[]; } export interface GetEventOrchestrationIntegrationDetailArgs { /** * ID of the integration */ id?: pulumi.Input; label?: pulumi.Input; /** * A single-item list containing a parameter object describing the integration */ parameters?: pulumi.Input[]>; } export interface GetEventOrchestrationIntegrationDetailParameter { /** * Routing key that routes to this Orchestration. */ routingKey?: string; /** * Type of the routing key. `global` is the default type. */ type?: string; } export interface GetEventOrchestrationIntegrationDetailParameterArgs { /** * Routing key that routes to this Orchestration. */ routingKey?: pulumi.Input; /** * Type of the routing key. `global` is the default type. */ type?: pulumi.Input; } export interface IncidentWorkflowStep { /** * The action id for the workflow step, including the version. A list of actions available can be retrieved using the [PagerDuty API](https://developer.pagerduty.com/api-reference/aa192a25fac39-list-actions). */ action: pulumi.Input; /** * The ID of the incident workflow. */ id?: pulumi.Input; /** * The list of inputs that contain a series of inline steps for the workflow action. */ inlineStepsInputs?: pulumi.Input[]>; /** * The list of standard inputs for the workflow action. */ inputs?: pulumi.Input[]>; /** * The name of the workflow step. */ name: pulumi.Input; } export interface IncidentWorkflowStepInlineStepsInput { /** * The name of the input. */ name: pulumi.Input; /** * The inline steps of the input. An inline step adheres to the step schema described above. */ steps?: pulumi.Input[]>; } export interface IncidentWorkflowStepInlineStepsInputStep { /** * The action id for the workflow step, including the version. A list of actions available can be retrieved using the [PagerDuty API](https://developer.pagerduty.com/api-reference/aa192a25fac39-list-actions). */ action: pulumi.Input; /** * The list of standard inputs for the workflow action. */ inputs?: pulumi.Input[]>; /** * The name of the workflow step. */ name: pulumi.Input; } export interface IncidentWorkflowStepInlineStepsInputStepInput { generated?: pulumi.Input; /** * The name of the input. */ name: pulumi.Input; /** * The value of the input. */ value: pulumi.Input; } export interface IncidentWorkflowStepInput { generated?: pulumi.Input; /** * The name of the input. */ name: pulumi.Input; /** * The value of the input. */ value: pulumi.Input; } export interface IncidentWorkflowTriggerPermissions { /** * If `true`, indicates that the Trigger can only be started by authorized Users. If `false` (default), any user can start this Trigger. Applicable only to `manual`-type triggers. */ restricted?: pulumi.Input; /** * The ID of the Team whose members can manually start this Trigger. Required and allowed only if `restricted` is `true`. */ teamId?: pulumi.Input; } export interface JiraCloudAccountMappingRuleConfig { /** * Synchronization settings. */ jira?: pulumi.Input; /** * [Updating can cause a resource replacement] The ID of the linked PagerDuty service. */ service: pulumi.Input; } export interface JiraCloudAccountMappingRuleConfigJira { /** * JQL query to automatically create PagerDuty incidents when matching Jira issues are created. Leave empty to disable this feature. */ autocreateJql?: pulumi.Input; /** * When enabled, automatically creates a Jira issue whenever a PagerDuty incident is triggered. */ createIssueOnIncidentTrigger?: pulumi.Input; /** * Defines how Jira fields are populated when a Jira Issue is created from a PagerDuty Incident. */ customFields?: pulumi.Input[]>; /** * Specifies the Jira issue type to be created or synchronized with PagerDuty incidents. */ issueType?: pulumi.Input; /** * Maps PagerDuty incident priorities to Jira issue priorities for synchronization. */ priorities?: pulumi.Input[]>; /** * [Updating can cause a resource replacement] Defines the Jira project where issues will be created or synchronized. */ project?: pulumi.Input; /** * Maps PagerDuty incident statuses to corresponding Jira issue statuses for synchronization. */ statusMapping?: pulumi.Input; /** * ID of the PagerDuty user for syncing notes and comments between Jira issues and PagerDuty incidents. If not provided, note synchronization is disabled. */ syncNotesUser?: pulumi.Input; } export interface JiraCloudAccountMappingRuleConfigJiraCustomField { /** * The PagerDuty incident field from which the value will be extracted (only applicable if `type` is `attribute`); one of `incidentNumber`, `incidentTitle`, `incidentDescription`, `incidentStatus`, `incidentCreatedAt`, `incidentService`, `incidentEscalationPolicy`, `incidentImpactedServices`, `incidentHtmlUrl`, `incidentAssignees`, `incidentAcknowledgers`, `incidentLastStatusChangeAt`, `incidentLastStatusChangeBy`, `incidentUrgency` or `incidentPriority`. */ sourceIncidentField?: pulumi.Input; /** * The unique identifier key of the Jira field that will be set. */ targetIssueField: pulumi.Input; /** * The human-readable name of the Jira field. */ targetIssueFieldName: pulumi.Input; /** * The type of the value that will be set; one of `attribute`, `const` or `jiraValue`. */ type: pulumi.Input; /** * The value to be set for the Jira field (only applicable if `type` is `const` or `jiraValue`). It must be set as a JSON string. */ value?: pulumi.Input; } export interface JiraCloudAccountMappingRuleConfigJiraIssueType { /** * Unique identifier for the Jira issue type. */ id: pulumi.Input; /** * The name of the Jira issue type. */ name: pulumi.Input; } export interface JiraCloudAccountMappingRuleConfigJiraPriority { /** * The ID of the Jira priority. */ jiraId: pulumi.Input; /** * The ID of the PagerDuty priority. */ pagerdutyId: pulumi.Input; } export interface JiraCloudAccountMappingRuleConfigJiraProject { /** * Unique identifier for the Jira project. */ id: pulumi.Input; /** * The short key name of the Jira project. */ key: pulumi.Input; /** * The name of the Jira project. */ name: pulumi.Input; } export interface JiraCloudAccountMappingRuleConfigJiraStatusMapping { /** * Jira status that maps to the PagerDuty `acknowledged` status. */ acknowledged?: pulumi.Input; /** * Jira status that maps to the PagerDuty `resolved` status. */ resolved?: pulumi.Input; /** * Jira status that maps to the PagerDuty `triggered` status. */ triggered?: pulumi.Input; } export interface JiraCloudAccountMappingRuleConfigJiraStatusMappingAcknowledged { /** * Unique identifier for the Jira status. */ id?: pulumi.Input; /** * Name of the Jira status. */ name?: pulumi.Input; } export interface JiraCloudAccountMappingRuleConfigJiraStatusMappingResolved { /** * Unique identifier for the Jira status. */ id?: pulumi.Input; /** * Name of the Jira status. */ name?: pulumi.Input; } export interface JiraCloudAccountMappingRuleConfigJiraStatusMappingTriggered { /** * Unique identifier for the Jira status. */ id: pulumi.Input; /** * Name of the Jira status. */ name: pulumi.Input; } export interface ProviderUseAppOauthScopedToken { pdClientId?: pulumi.Input; pdClientSecret?: pulumi.Input; pdSubdomain?: pulumi.Input; } export interface ResponsePlayResponder { /** * Description of escalation policy */ description?: pulumi.Input; /** * The escalation rules */ escalationRules?: pulumi.Input[]>; /** * ID of the user defined as the responder */ id?: pulumi.Input; /** * Name of the escalation policy */ name?: pulumi.Input; /** * The number of times the escalation policy will repeat after reaching the end of its escalation. */ numLoops?: pulumi.Input; /** * Determines how on call handoff notifications will be sent for users on the escalation policy. Defaults to "ifHasServices". Could be "ifHasServices", "always */ onCallHandoffNotifications?: pulumi.Input; /** * There can be multiple services associated with a policy. */ services?: pulumi.Input[]>; /** * Teams associated with the policy. Account must have the `teams` ability to use this parameter. There can be multiple teams associated with a policy. */ teams?: pulumi.Input[]>; /** * Should be set as `escalationPolicy` for escalation policy responders. */ type?: pulumi.Input; } export interface ResponsePlayResponderEscalationRule { /** * The number of minutes before an unacknowledged incident escalates away from this rule. */ escalationDelayInMinutes?: pulumi.Input; /** * The ID of the response play. */ id?: pulumi.Input; /** * The targets an incident should be assigned to upon reaching this rule. */ targets: pulumi.Input[]>; } export interface ResponsePlayResponderEscalationRuleTarget { /** * The ID of the response play. */ id?: pulumi.Input; /** * Type of object of the target. Supported types are `userReference`, `scheduleReference`. */ type?: pulumi.Input; } export interface ResponsePlayResponderService { /** * The ID of the response play. */ id?: pulumi.Input; /** * A string that determines the schema of the object. If not set, the default value is "responsePlay". */ type?: pulumi.Input; } export interface ResponsePlayResponderTeam { /** * The ID of the response play. */ id?: pulumi.Input; /** * A string that determines the schema of the object. If not set, the default value is "responsePlay". */ type: pulumi.Input; } export interface ResponsePlaySubscriber { /** * The ID of the response play. */ id?: pulumi.Input; /** * A string that determines the schema of the object. If not set, the default value is "responsePlay". */ type?: pulumi.Input; } export interface RulesetRuleActions { /** * Note added to the event. */ annotates?: pulumi.Input[]>; /** * An object with a single `value` field. The value sets whether the resulting alert status is `trigger` or `resolve`. */ eventActions?: pulumi.Input[]>; /** * Allows you to copy important data from one event field to another. Extraction objects may use *either* of the following field structures: */ extractions?: pulumi.Input[]>; /** * The ID of the priority applied to the event. */ priorities?: pulumi.Input[]>; /** * The ID of the service where the event will be routed. */ routes?: pulumi.Input[]>; /** * The [severity level](https://support.pagerduty.com/docs/rulesets#section-set-severity-with-event-rules) of the event. Can be either `info`,`warning`,`error`, or `critical`. */ severities?: pulumi.Input[]>; /** * Controls whether an alert is [suppressed](https://support.pagerduty.com/docs/rulesets#section-suppress-but-create-triggering-thresholds-with-event-rules) (does not create an incident). Note: If a threshold is set, the rule must also have a `route` action. */ suppresses?: pulumi.Input[]>; /** * An object with a single `value` field. The value sets the length of time to suspend the resulting alert before triggering. Note: A rule with a `suspend` action must also have a `route` action. */ suspends?: pulumi.Input[]>; } export interface RulesetRuleActionsAnnotate { /** * Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met. */ value?: pulumi.Input; } export interface RulesetRuleActionsEventAction { /** * Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met. */ value?: pulumi.Input; } export interface RulesetRuleActionsExtraction { /** * The conditions that need to be met for the extraction to happen. Must use valid [RE2 regular expression syntax](https://github.com/google/re2/wiki/Syntax). * * *- **OR** -* */ regex?: pulumi.Input; /** * Field where the data is being copied from. Must be a [PagerDuty Common Event Format (PD-CEF)](https://support.pagerduty.com/docs/pd-cef) field. */ source?: pulumi.Input; /** * Field where the data is being copied to. Must be a [PagerDuty Common Event Format (PD-CEF)](https://support.pagerduty.com/docs/pd-cef) field. * * *NOTE: A rule can have multiple `extraction` objects attributed to it.* */ target?: pulumi.Input; /** * A customized field message. This can also include variables extracted from the payload by using string interpolation. */ template?: pulumi.Input; } export interface RulesetRuleActionsPriority { /** * Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met. */ value?: pulumi.Input; } export interface RulesetRuleActionsRoute { /** * Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met. */ value?: pulumi.Input; } export interface RulesetRuleActionsSeverity { /** * Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met. */ value?: pulumi.Input; } export interface RulesetRuleActionsSuppress { /** * The number value of the `thresholdTimeUnit` before an incident is created. Must be greater than 0. */ thresholdTimeAmount?: pulumi.Input; /** * The `seconds`,`minutes`, or `hours` the `thresholdTimeAmount` should be measured. */ thresholdTimeUnit?: pulumi.Input; /** * The number of alerts that should be suppressed. Must be greater than 0. */ thresholdValue?: pulumi.Input; /** * Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met. */ value?: pulumi.Input; } export interface RulesetRuleActionsSuspend { /** * Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met. */ value?: pulumi.Input; } export interface RulesetRuleConditions { /** * Operator to combine sub-conditions. Can be `and` or `or`. */ operator?: pulumi.Input; /** * List of sub-conditions that define the condition. */ subconditions?: pulumi.Input[]>; } export interface RulesetRuleConditionsSubcondition { /** * Type of operator to apply to the sub-condition. Can be `exists`,`nexists`,`equals`,`nequals`,`contains`,`ncontains`,`matches`, or `nmatches`. */ operator?: pulumi.Input; /** * Parameter for the sub-condition. It requires both a `path` and `value` to be set. */ parameters?: pulumi.Input[]>; } export interface RulesetRuleConditionsSubconditionParameter { path?: pulumi.Input; /** * Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met. */ value?: pulumi.Input; } export interface RulesetRuleTimeFrame { /** * Values for executing the rule during a specific time period. */ activeBetweens?: pulumi.Input[]>; /** * Values for executing the rule on a recurring schedule. */ scheduledWeeklies?: pulumi.Input[]>; } export interface RulesetRuleTimeFrameActiveBetween { endTime?: pulumi.Input; /** * A Unix timestamp in milliseconds which is combined with the `timezone` to determine the time this rule will start on each specified `weekday`. Note that the _date_ of the timestamp you specify does **not** matter, except that it lets you determine whether daylight saving time is in effect so that you use the correct UTC offset for the timezone you specify. In practice, you may want to use the `timeStatic` resource to generate this value, as demonstrated in the `resource.pagerduty_ruleset_rule.foo` code example at the top of this page. To generate this timestamp manually, if you want your rule to apply starting at 9:30am in the `America/New_York` timezone, use your programing language of choice to determine a Unix timestamp that represents 9:30am in that timezone, like [1554989400000](https://www.epochconverter.com/timezones?q=1554989400000&tz=America%2FNew_York). */ startTime?: pulumi.Input; } export interface RulesetRuleTimeFrameScheduledWeekly { /** * Length of time the schedule will be active in milliseconds. For example `duration = 2 * 60 * 60 * 1000` if you want your rule to apply for 2 hours, from the specified `startTime`. */ duration?: pulumi.Input; /** * A Unix timestamp in milliseconds which is combined with the `timezone` to determine the time this rule will start on each specified `weekday`. Note that the _date_ of the timestamp you specify does **not** matter, except that it lets you determine whether daylight saving time is in effect so that you use the correct UTC offset for the timezone you specify. In practice, you may want to use the `timeStatic` resource to generate this value, as demonstrated in the `resource.pagerduty_ruleset_rule.foo` code example at the top of this page. To generate this timestamp manually, if you want your rule to apply starting at 9:30am in the `America/New_York` timezone, use your programing language of choice to determine a Unix timestamp that represents 9:30am in that timezone, like [1554989400000](https://www.epochconverter.com/timezones?q=1554989400000&tz=America%2FNew_York). */ startTime?: pulumi.Input; /** * [The name of the timezone](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) for the given schedule, which will be used to determine UTC offset including adjustment for daylight saving time. For example: `timezone = "America/Toronto"` */ timezone?: pulumi.Input; /** * An integer array representing which days during the week the rule executes. For example `weekdays = [1,3,7]` would execute on Monday, Wednesday and Sunday. */ weekdays?: pulumi.Input[]>; } export interface RulesetRuleVariable { name?: pulumi.Input; parameters?: pulumi.Input[]>; type?: pulumi.Input; } export interface RulesetRuleVariableParameter { path?: pulumi.Input; /** * Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met. */ value?: pulumi.Input; } export interface RulesetTeam { /** * The ID of the ruleset. */ id: pulumi.Input; } export interface ScheduleFinalSchedule { /** * The name of the schedule. */ name?: pulumi.Input; renderedCoveragePercentage?: pulumi.Input; } export interface ScheduleLayer { /** * The end time of the schedule layer. If not specified, the layer does not end. */ end?: pulumi.Input; /** * The ID of the schedule. */ id?: pulumi.Input; /** * The name of the schedule layer. */ name?: pulumi.Input; renderedCoveragePercentage?: pulumi.Input; /** * A schedule layer restriction block. Restriction blocks documented below. */ restrictions?: pulumi.Input[]>; /** * The duration of each on-call shift in `seconds`. */ rotationTurnLengthSeconds: pulumi.Input; /** * The effective start time of the schedule layer. This can be before the start time of the schedule. */ rotationVirtualStart: pulumi.Input; /** * The start time of the schedule layer. */ start: pulumi.Input; /** * The ordered list of users on this layer. The position of the user on the list determines their order in the layer. */ users: pulumi.Input[]>; } export interface ScheduleLayerRestriction { /** * The duration of the restriction in `seconds`. */ durationSeconds: pulumi.Input; /** * Number of the day when restriction starts. From 1 to 7 where 1 is Monday and 7 is Sunday. */ startDayOfWeek?: pulumi.Input; /** * The start time in `HH:mm:ss` format. */ startTimeOfDay: pulumi.Input; /** * Can be `dailyRestriction` or `weeklyRestriction`. */ type: pulumi.Input; } export interface Schedulev2Rotation { /** * One or more event blocks defining on-call periods within this rotation. Events documented below. */ events?: pulumi.Input[]>; /** * The ID of the schedule. * * `rotation.*.id` - The ID of each rotation. * * `rotation.*.event.*.id` - The ID of each event within a rotation. */ id?: pulumi.Input; } export interface Schedulev2RotationEvent { /** * A block defining how on-call responsibility is assigned. Assignment strategy documented below. */ assignmentStrategies?: pulumi.Input[]>; /** * When this event configuration begins producing shifts (ISO-8601 UTC). The API adjusts past values to the current time. */ effectiveSince: pulumi.Input; /** * When this event configuration stops producing shifts (ISO-8601 UTC). Omit for an indefinite schedule. */ effectiveUntil?: pulumi.Input; /** * The shift end time in ISO-8601 format. The v3 API normalizes this to UTC. */ endTime: pulumi.Input; /** * The ID of the schedule. * * `rotation.*.id` - The ID of each rotation. * * `rotation.*.event.*.id` - The ID of each event within a rotation. */ id?: pulumi.Input; /** * The name of the event. Maximum 255 characters. */ name: pulumi.Input; /** * List of RFC 5545 recurrence rule strings. Must contain exactly one `RRULE` entry. May optionally include one or more `EXDATE` entries (dates to exclude) and one or more `RDATE` entries (additional dates to include). Example: `["RRULE:FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR"]`. You can generate RRULE strings interactively using tools like [RRULE Tool](https://icalendar.org/rrule-tool.html). */ recurrences: pulumi.Input[]>; /** * The shift start time in ISO-8601 format (e.g. `2026-06-01T09:00:00Z`). The v3 API normalizes this to UTC. */ startTime: pulumi.Input; } export interface Schedulev2RotationEventAssignmentStrategy { /** * One or more member blocks identifying who is on call. Required for both strategy types. Maximum 20 members. Members documented below. */ members?: pulumi.Input[]>; /** * Number of consecutive shift occurrences each member covers before rotating. Minimum value: `1`. Required when `type` is `"rotatingMemberAssignmentStrategy"`. */ shiftsPerMember?: pulumi.Input; /** * The assignment strategy type. Supported values: * * `"rotatingMemberAssignmentStrategy"` — listed members rotate in sequence. Each member covers `shiftsPerMember` consecutive shift periods before the next member takes over. * * `"everyMemberAssignmentStrategy"` — all listed members are on-call simultaneously for every occurrence. * * > **Breaking change:** The previous value `"userAssignmentStrategy"` is no longer valid. Use `"rotatingMemberAssignmentStrategy"` instead. */ type: pulumi.Input; } export interface Schedulev2RotationEventAssignmentStrategyMember { /** * The member type. Supported values: `"userMember"`, `"emptyMember"`. */ type: pulumi.Input; /** * The ID of the user to assign. Required when `type` is `"userMember"`. */ userId?: pulumi.Input; } export interface ServiceAlertGroupingParameters { /** * Alert grouping parameters dependent on `type`. If `type` is set to `intelligent` or empty then `config` can be empty. */ config?: pulumi.Input; /** * The type of alert grouping; one of `intelligent`, `time` or `contentBased`. */ type?: pulumi.Input; } export interface ServiceAlertGroupingParametersConfig { /** * One of `any` or `all`. This setting applies only when `type` is set to `contentBased`. Group alerts based on one or all of `fields` value(s). */ aggregate?: pulumi.Input; /** * Alerts will be grouped together if the content of these fields match. This setting applies only when `type` is set to `contentBased`. */ fields?: pulumi.Input[]>; /** * The maximum amount of time allowed between Alerts. This setting applies only when `type` is set to `intelligent` or `contentBased`. Value must be between `300` and `3600` or exactly `86400` (86400 is supported only for `contentBased` alert grouping). Any Alerts arriving greater than `timeWindow` seconds apart will not be grouped together. This is a rolling time window and is counted from the most recently grouped alert. The window is extended every time a new alert is added to the group, up to 24 hours. */ timeWindow?: pulumi.Input; /** * The duration in minutes within which to automatically group incoming alerts. This setting applies only when `type` is set to `time`. To continue grouping alerts until the incident is resolved, set this value to `0`. */ timeout?: pulumi.Input; } export interface ServiceAutoPauseNotificationsParameters { /** * Indicates whether alerts should be automatically suspended when identified as transient. If not passed in, will default to 'false'. */ enabled?: pulumi.Input; /** * Indicates in seconds how long alerts should be suspended before triggering. Allowed values: `120`, `180`, `300`, `600`, `900` if `enabled` is `true`. Must be omitted or set to `null` if `enabled` is `false`. */ timeout?: pulumi.Input; } export interface ServiceCustomFieldFieldOption { /** * Must be `string`. */ dataType: pulumi.Input; /** * The ID of the service custom field. */ id?: pulumi.Input; /** * The value of the option. */ value: pulumi.Input; } export interface ServiceCustomFieldValueCustomField { /** * The ID of the custom field. Either `id` or `name` must be provided. */ id: pulumi.Input; /** * The name of the custom field. Either `id` or `name` must be provided. */ name: pulumi.Input; /** * The value to set for the custom field. Must be provided as a JSON-encoded string matching the field's data type. Use the `jsonencode()` function to ensure proper formatting. */ value: pulumi.Input; } export interface ServiceDependencyDependency { /** * The service that dependents on the supporting service. Dependency dependent service documented below. One and only one `dependentService` dependency block must be defined. */ dependentServices: pulumi.Input[]>; /** * The service that supports the dependent service. Dependency supporting service documented below. One and only one `supportingService` dependency block must be defined. */ supportingServices: pulumi.Input[]>; /** * Can be `businessService`, `service`, `businessServiceReference` or `technicalServiceReference`. */ type?: pulumi.Input; } export interface ServiceDependencyDependencyDependentService { /** * The ID of the service dependency. */ id: pulumi.Input; /** * Can be `businessService`, `service`, `businessServiceReference` or `technicalServiceReference`. */ type: pulumi.Input; } export interface ServiceDependencyDependencySupportingService { /** * The ID of the service dependency. */ id: pulumi.Input; /** * Can be `businessService`, `service`, `businessServiceReference` or `technicalServiceReference`. */ type: pulumi.Input; } export interface ServiceEventRuleActions { /** * Note added to the event. */ annotates?: pulumi.Input[]>; /** * An object with a single `value` field. The value sets whether the resulting alert status is `trigger` or `resolve`. */ eventActions?: pulumi.Input[]>; /** * Allows you to copy important data from one event field to another. Extraction objects may use *either* of the following field structures: */ extractions?: pulumi.Input[]>; /** * The ID of the priority applied to the event. */ priorities?: pulumi.Input[]>; /** * The [severity level](https://support.pagerduty.com/docs/rulesets#section-set-severity-with-event-rules) of the event. Can be either `info`,`error`,`warning`, or `critical`. */ severities?: pulumi.Input[]>; /** * Controls whether an alert is [suppressed](https://support.pagerduty.com/docs/rulesets#section-suppress-but-create-triggering-thresholds-with-event-rules) (does not create an incident). */ suppresses?: pulumi.Input[]>; /** * An object with a single `value` field. The value sets the length of time to suspend the resulting alert before triggering. */ suspends?: pulumi.Input[]>; } export interface ServiceEventRuleActionsAnnotate { value?: pulumi.Input; } export interface ServiceEventRuleActionsEventAction { value?: pulumi.Input; } export interface ServiceEventRuleActionsExtraction { /** * The conditions that need to be met for the extraction to happen. Must use valid [RE2 regular expression syntax](https://github.com/google/re2/wiki/Syntax). * * *- **OR** -* */ regex?: pulumi.Input; /** * Field where the data is being copied from. Must be a [PagerDuty Common Event Format (PD-CEF)](https://support.pagerduty.com/docs/pd-cef) field. */ source?: pulumi.Input; /** * Field where the data is being copied to. Must be a [PagerDuty Common Event Format (PD-CEF)](https://support.pagerduty.com/docs/pd-cef) field. * * *NOTE: A rule can have multiple `extraction` objects attributed to it.* */ target?: pulumi.Input; /** * A customized field message. This can also include variables extracted from the payload by using string interpolation. */ template?: pulumi.Input; } export interface ServiceEventRuleActionsPriority { value?: pulumi.Input; } export interface ServiceEventRuleActionsSeverity { value?: pulumi.Input; } export interface ServiceEventRuleActionsSuppress { /** * The number value of the `thresholdTimeUnit` before an incident is created. */ thresholdTimeAmount?: pulumi.Input; /** * The `seconds`,`minutes`, or `hours` the `thresholdTimeAmount` should be measured. */ thresholdTimeUnit?: pulumi.Input; /** * The number of alerts that should be suppressed. */ thresholdValue?: pulumi.Input; /** * Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met. */ value?: pulumi.Input; } export interface ServiceEventRuleActionsSuspend { value?: pulumi.Input; } export interface ServiceEventRuleConditions { /** * Operator to combine sub-conditions. Can be `and` or `or`. */ operator?: pulumi.Input; /** * List of sub-conditions that define the condition. */ subconditions?: pulumi.Input[]>; } export interface ServiceEventRuleConditionsSubcondition { /** * Type of operator to apply to the sub-condition. Can be `exists`,`nexists`,`equals`,`nequals`,`contains`,`ncontains`,`matches`, or `nmatches`. */ operator?: pulumi.Input; /** * Parameter for the sub-condition. It requires both a `path` and `value` to be set. The `path` value must be a [PagerDuty Common Event Format (PD-CEF)](https://support.pagerduty.com/docs/pd-cef) field. */ parameters?: pulumi.Input[]>; } export interface ServiceEventRuleConditionsSubconditionParameter { /** * Path to a field in an event, in dot-notation. For Event Rules on a Service, this will have to be a [PD-CEF field](https://support.pagerduty.com/docs/pd-cef). */ path?: pulumi.Input; value?: pulumi.Input; } export interface ServiceEventRuleTimeFrame { /** * Values for executing the rule during a specific time period. */ activeBetweens?: pulumi.Input[]>; /** * Values for executing the rule on a recurring schedule. */ scheduledWeeklies?: pulumi.Input[]>; } export interface ServiceEventRuleTimeFrameActiveBetween { /** * Ending of the scheduled time when the rule should execute. Unix timestamp in milliseconds. */ endTime?: pulumi.Input; /** * Beginning of the scheduled time when the rule should execute. Unix timestamp in milliseconds. */ startTime?: pulumi.Input; } export interface ServiceEventRuleTimeFrameScheduledWeekly { /** * Length of time the schedule will be active. Unix timestamp in milliseconds. */ duration?: pulumi.Input; /** * Time when the schedule will start. Unix timestamp in milliseconds. For example, if you have a rule with a `startTime` of `0` and a `duration` of `60,000` then that rule would be active from `00:00` to `00:01`. If the `startTime` was `3,600,000` the it would be active starting at `01:00`. */ startTime?: pulumi.Input; /** * Timezone for the given schedule. */ timezone?: pulumi.Input; /** * An integer array representing which days during the week the rule executes. For example `weekdays = [1,3,7]` would execute on Monday, Wednesday and Sunday. */ weekdays?: pulumi.Input[]>; } export interface ServiceEventRuleVariable { /** * The name of the variable. */ name?: pulumi.Input; /** * The parameters for performing the operation to populate the variable. */ parameters?: pulumi.Input[]>; /** * Type of operation to populate the variable. Usually `regex`. */ type?: pulumi.Input; } export interface ServiceEventRuleVariableParameter { /** * Path to a field in an event, in dot-notation. For Event Rules on a Service, this will have to be a [PD-CEF field](https://support.pagerduty.com/docs/pd-cef). */ path?: pulumi.Input; value?: pulumi.Input; } export interface ServiceIncidentUrgencyRule { /** * Incidents' urgency during support hours. */ duringSupportHours?: pulumi.Input; /** * Incidents' urgency outside support hours. */ outsideSupportHours?: pulumi.Input; /** * The type of incident urgency: `constant` or `useSupportHours` (when depending on specific support hours; see `supportHours`). */ type: pulumi.Input; /** * The urgency: `low` Notify responders (does not escalate), `high` (follows escalation rules) or `severityBased` Set's the urgency of the incident based on the severity set by the triggering monitoring tool. */ urgency?: pulumi.Input; } export interface ServiceIncidentUrgencyRuleDuringSupportHours { /** * The type of object. The value returned will be `service`. Can be used for passing to a service dependency. */ type?: pulumi.Input; /** * The urgency: `low` Notify responders (does not escalate), `high` (follows escalation rules) or `severityBased` Set's the urgency of the incident based on the severity set by the triggering monitoring tool. */ urgency?: pulumi.Input; } export interface ServiceIncidentUrgencyRuleOutsideSupportHours { /** * The type of object. The value returned will be `service`. Can be used for passing to a service dependency. */ type?: pulumi.Input; /** * The urgency: `low` Notify responders (does not escalate), `high` (follows escalation rules) or `severityBased` Set's the urgency of the incident based on the severity set by the triggering monitoring tool. */ urgency?: pulumi.Input; } export interface ServiceIntegrationEmailFilter { /** * Can be `always`, `match` or `no-match`. */ bodyMode?: pulumi.Input; /** * Should be a valid regex or `null` */ bodyRegex?: pulumi.Input; /** * Can be `always`, `match` or `no-match`. */ fromEmailMode?: pulumi.Input; /** * Should be a valid regex or `null` */ fromEmailRegex?: pulumi.Input; /** * The ID of the service integration. */ id?: pulumi.Input; /** * Can be `always`, `match` or `no-match`. */ subjectMode?: pulumi.Input; /** * Should be a valid regex or `null` */ subjectRegex?: pulumi.Input; } export interface ServiceIntegrationEmailParser { /** * Can be `resolve` or `trigger`. */ action: pulumi.Input; /** * The ID of the service integration. */ id?: pulumi.Input; matchPredicate: pulumi.Input; valueExtractors?: pulumi.Input[]>; } export interface ServiceIntegrationEmailParserMatchPredicate { predicates?: pulumi.Input[]>; /** * Can be `any` or `all`. */ type: pulumi.Input; } export interface ServiceIntegrationEmailParserMatchPredicatePredicate { /** * Predicate value or valid regex. */ matcher?: pulumi.Input; /** * Can be `subject`, `body` or `fromAddresses`. */ part?: pulumi.Input; predicates?: pulumi.Input[]>; /** * Can be `contains`, `exactly`, `regex` or `not`. If type is `not` predicate should contain child predicate with all parameters. */ type: pulumi.Input; } export interface ServiceIntegrationEmailParserMatchPredicatePredicatePredicate { /** * Predicate value or valid regex. */ matcher: pulumi.Input; /** * Can be `subject`, `body` or `fromAddresses`. */ part: pulumi.Input; /** * Can be `contains`, `exactly`, `regex` or `not`. If type is `not` predicate should contain child predicate with all parameters. */ type: pulumi.Input; } export interface ServiceIntegrationEmailParserValueExtractor { endsBefore?: pulumi.Input; /** * Can be `subject` or `body`. */ part: pulumi.Input; /** * If `type` has value `regex` this value should contain valid regex. * * **Note:** You can use the `pagerduty.getVendor` data source to locate the appropriate vendor ID. */ regex?: pulumi.Input; startsAfter?: pulumi.Input; /** * Can be `between`, `entire` or `regex`. */ type: pulumi.Input; /** * First value extractor should have name `incidentKey` other value extractors should contain custom names. */ valueName: pulumi.Input; } export interface ServiceScheduledAction { /** * A block representing when the scheduled action will occur. */ ats?: pulumi.Input[]>; /** * The urgency to change to: `low` (does not escalate), or `high` (follows escalation rules). */ toUrgency?: pulumi.Input; /** * The type of scheduled action. Currently, this must be set to `urgencyChange`. */ type?: pulumi.Input; } export interface ServiceScheduledActionAt { /** * Designates either the start or the end of the scheduled action. Can be `supportHoursStart` or `supportHoursEnd`. * * Note that it is currently only possible to define the scheduled action when urgency is set to `high` for `duringSupportHours` and to `low` for `outsideSupportHours` in `incidentUrgencyRule`. * * Below is an example for a `pagerduty.Service` resource with `incidentUrgencyRules` with `type = "useSupportHours"`, `supportHours` and a default `scheduledAction` as well. * * ```typescript * import * as pulumi from "@pulumi/pulumi"; * import * as pagerduty from "@pulumi/pagerduty"; * * const foo = new pagerduty.Service("foo", { * name: "bar", * description: "bar bar bar", * autoResolveTimeout: "3600", * acknowledgementTimeout: "3600", * escalationPolicy: fooPagerdutyEscalationPolicy.id, * incidentUrgencyRule: { * type: "use_support_hours", * duringSupportHours: { * type: "constant", * urgency: "high", * }, * outsideSupportHours: { * type: "constant", * urgency: "low", * }, * }, * supportHours: { * type: "fixed_time_per_day", * timeZone: "America/Lima", * startTime: "09:00:00", * endTime: "17:00:00", * daysOfWeeks: [ * 1, * 2, * 3, * 4, * 5, * ], * }, * scheduledActions: [{ * type: "urgency_change", * toUrgency: "high", * ats: [{ * type: "named_time", * name: "support_hours_start", * }], * }], * }); * ``` */ name?: pulumi.Input; /** * The type of time specification. Currently, this must be set to `namedTime`. */ type?: pulumi.Input; } export interface ServiceSupportHours { /** * Array of days of week as integers. `1` to `7`, `1` being * Monday and `7` being Sunday. */ daysOfWeeks?: pulumi.Input[]>; /** * The support hours' ending time of day. */ endTime?: pulumi.Input; /** * The support hours' starting time of day. */ startTime?: pulumi.Input; /** * The time zone for the support hours. */ timeZone?: pulumi.Input; /** * The type of support hours. Can be `fixedTimePerDay`. */ type?: pulumi.Input; } export interface SlackConnectionConfig { /** * A list of strings to filter events by PagerDuty event type. `"incident.triggered"` is required. The follow event types are also possible: * - `incident.acknowledged` * - `incident.escalated` * - `incident.resolved` * - `incident.reassigned` * - `incident.annotated` * - `incident.unacknowledged` * - `incident.delegated` * - `incident.priority_updated` * - `incident.responder.added` * - `incident.responder.replied` * - `incident.status_update_published` * - `incident.reopened` */ events: pulumi.Input[]>; /** * Allows you to filter events by priority. Needs to be an array of PagerDuty priority IDs. Available through pagerduty.getPriority data source. * - When omitted or set to an empty array (`[]`) in the configuration for a Slack Connection, its default behavior is to set `priorities` to `No Priority` value. * - When set to `["*"]` its corresponding value for `priorities` in Slack Connection's configuration will be `Any Priority`. */ priorities?: pulumi.Input[]>; /** * Allows you to filter events by urgency. Either `high`, `low` or `null` for Any urgency. Default is `null`. */ urgency?: pulumi.Input; } export interface UserHandoffNotificationRuleContactMethod { /** * The ID of the contact method. */ id: pulumi.Input; /** * The type of the contact method. May be (`emailContactMethod`, `emailContactMethodReference`, `phoneContactMethod`, `phoneContactMethodReference`, `pushNotificationContactMethod`, `pushNotificationContactMethodReference`, `smsContactMethod`, `smsContactMethodReference`). */ type: pulumi.Input; } export interface UserNotificationRuleContactMethod { /** * The id of the referenced contact method. */ id: pulumi.Input; /** * The type of contact method. Can be `emailContactMethod`, `phoneContactMethod`, `pushNotificationContactMethod`, `smsContactMethod` or `whatsappContactMethod`. */ type: pulumi.Input; } export interface WebhookSubscriptionDeliveryMethod { /** * The customHeader of a webhook subscription define any optional headers that will be passed along with the payload to the destination URL. */ customHeaders?: pulumi.Input[]>; /** * Whether this webhook subscription is temporarily disabled. Becomes true if the delivery method URL is repeatedly rejected by the server. */ temporarilyDisabled?: pulumi.Input; /** * Indicates the type of the delivery method. Allowed and default value: `httpDeliveryMethod`. */ type?: pulumi.Input; /** * The destination URL for webhook delivery. */ url?: pulumi.Input; } export interface WebhookSubscriptionDeliveryMethodCustomHeader { name: pulumi.Input; value: pulumi.Input; } export interface WebhookSubscriptionFilter { /** * The id of the object being used as the filter. This field is required for all filter types except account_reference. */ id?: pulumi.Input; /** * The type of object being used as the filter. Allowed values are `accountReference`, `serviceReference`, and `teamReference`. */ type: pulumi.Input; } export declare namespace config { }