1. Packages
  2. Opsgenie Provider
  3. API Docs
  4. IntegrationAction
Opsgenie v1.3.12 published on Wednesday, Oct 16, 2024 by Pulumi

opsgenie.IntegrationAction

Explore with Pulumi AI

opsgenie logo
Opsgenie v1.3.12 published on Wednesday, Oct 16, 2024 by Pulumi

    Manages advanced actions for Integrations within Opsgenie. This applies for the following resources:

    • opsgenie.ApiIntegration
    • opsgenie.EmailIntegration

    The actions that are supported are:

    • create
    • close
    • acknowledge
    • add_note
    • ignore

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
    import * as opsgenie from "@pulumi/opsgenie";
    import * as std from "@pulumi/std";
    
    const testAction = new opsgenie.IntegrationAction("test_action", {
        integrationId: testOpsgenieApiIntegration.id,
        creates: [
            {
                name: "create action",
                tags: [
                    "CRITICAL",
                    "SEV-0",
                ],
                user: "Example-service",
                note: "{{note}}",
                alias: "{{alias}}",
                source: "{{source}}",
                message: "{{message}}",
                description: "{{description}}",
                entity: "{{entity}}",
                alertActions: ["Runbook ID#342"],
                filters: [{
                    type: "match-all-conditions",
                    conditions: [{
                        field: "priority",
                        operation: "equals",
                        expectedValue: "P1",
                    }],
                }],
                responders: [{
                    id: test.id,
                    type: "team",
                }],
            },
            {
                name: "create action with multiline description",
                message: "{{message}}",
                description: std.chomp({
                    input: `This
    is a multiline
    description.
    `,
                }).then(invoke => invoke.result),
                filters: [{
                    type: "match-all-conditions",
                    conditions: [{
                        field: "priority",
                        operation: "equals",
                        expectedValue: "P1",
                    }],
                }],
            },
            {
                name: "Create medium priority alerts",
                tags: [
                    "SEVERE",
                    "SEV-1",
                ],
                priority: "P3",
                filters: [{
                    type: "match-all-conditions",
                    conditions: [{
                        field: "priority",
                        operation: "equals",
                        expectedValue: "P2",
                    }],
                }],
            },
            {
                name: "Create alert with priority from message",
                customPriority: "{{message.substringAfter(\"[custom]\")}}",
                filters: [{
                    type: "match-all-conditions",
                    conditions: [
                        {
                            field: "tags",
                            operation: "contains",
                            expectedValue: "P5",
                        },
                        {
                            field: "message",
                            operation: "starts-with",
                            expectedValue: "[custom]",
                        },
                    ],
                }],
            },
        ],
        closes: [{
            name: "Low priority alerts",
            filters: [{
                type: "match-any-condition",
                conditions: [
                    {
                        field: "priority",
                        operation: "equals",
                        expectedValue: "P5",
                    },
                    {
                        field: "message",
                        operation: "contains",
                        expectedValue: "DEBUG",
                    },
                ],
            }],
        }],
        acknowledges: [{
            name: "Auto-ack test alerts",
            filters: [{
                type: "match-all-conditions",
                conditions: [
                    {
                        field: "message",
                        not: true,
                        operation: "contains",
                        expectedValue: "TEST",
                    },
                    {
                        field: "priority",
                        operation: "equals",
                        expectedValue: "P5",
                    },
                ],
            }],
        }],
        addNotes: [{
            name: "Add note to all alerts",
            note: "Created from test integration",
            filters: [{
                type: "match-all",
            }],
        }],
        ignores: [{
            name: "Ignore alerts with ignore tag",
            filters: [{
                type: "match-all-conditions",
                conditions: [{
                    field: "tags",
                    operation: "contains",
                    expectedValue: "ignore",
                }],
            }],
        }],
    });
    
    import pulumi
    import pulumi_opsgenie as opsgenie
    import pulumi_std as std
    
    test_action = opsgenie.IntegrationAction("test_action",
        integration_id=test_opsgenie_api_integration["id"],
        creates=[
            {
                "name": "create action",
                "tags": [
                    "CRITICAL",
                    "SEV-0",
                ],
                "user": "Example-service",
                "note": "{{note}}",
                "alias": "{{alias}}",
                "source": "{{source}}",
                "message": "{{message}}",
                "description": "{{description}}",
                "entity": "{{entity}}",
                "alert_actions": ["Runbook ID#342"],
                "filters": [{
                    "type": "match-all-conditions",
                    "conditions": [{
                        "field": "priority",
                        "operation": "equals",
                        "expected_value": "P1",
                    }],
                }],
                "responders": [{
                    "id": test["id"],
                    "type": "team",
                }],
            },
            {
                "name": "create action with multiline description",
                "message": "{{message}}",
                "description": std.chomp(input="""This
    is a multiline
    description.
    """).result,
                "filters": [{
                    "type": "match-all-conditions",
                    "conditions": [{
                        "field": "priority",
                        "operation": "equals",
                        "expected_value": "P1",
                    }],
                }],
            },
            {
                "name": "Create medium priority alerts",
                "tags": [
                    "SEVERE",
                    "SEV-1",
                ],
                "priority": "P3",
                "filters": [{
                    "type": "match-all-conditions",
                    "conditions": [{
                        "field": "priority",
                        "operation": "equals",
                        "expected_value": "P2",
                    }],
                }],
            },
            {
                "name": "Create alert with priority from message",
                "custom_priority": "{{message.substringAfter(\"[custom]\")}}",
                "filters": [{
                    "type": "match-all-conditions",
                    "conditions": [
                        {
                            "field": "tags",
                            "operation": "contains",
                            "expected_value": "P5",
                        },
                        {
                            "field": "message",
                            "operation": "starts-with",
                            "expected_value": "[custom]",
                        },
                    ],
                }],
            },
        ],
        closes=[{
            "name": "Low priority alerts",
            "filters": [{
                "type": "match-any-condition",
                "conditions": [
                    {
                        "field": "priority",
                        "operation": "equals",
                        "expected_value": "P5",
                    },
                    {
                        "field": "message",
                        "operation": "contains",
                        "expected_value": "DEBUG",
                    },
                ],
            }],
        }],
        acknowledges=[{
            "name": "Auto-ack test alerts",
            "filters": [{
                "type": "match-all-conditions",
                "conditions": [
                    {
                        "field": "message",
                        "not_": True,
                        "operation": "contains",
                        "expected_value": "TEST",
                    },
                    {
                        "field": "priority",
                        "operation": "equals",
                        "expected_value": "P5",
                    },
                ],
            }],
        }],
        add_notes=[{
            "name": "Add note to all alerts",
            "note": "Created from test integration",
            "filters": [{
                "type": "match-all",
            }],
        }],
        ignores=[{
            "name": "Ignore alerts with ignore tag",
            "filters": [{
                "type": "match-all-conditions",
                "conditions": [{
                    "field": "tags",
                    "operation": "contains",
                    "expected_value": "ignore",
                }],
            }],
        }])
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
    	"github.com/pulumi/pulumi-std/sdk/go/std"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		invokeChomp, err := std.Chomp(ctx, &std.ChompArgs{
    			Input: "This\nis a multiline\ndescription.\n",
    		}, nil)
    		if err != nil {
    			return err
    		}
    		_, err = opsgenie.NewIntegrationAction(ctx, "test_action", &opsgenie.IntegrationActionArgs{
    			IntegrationId: pulumi.Any(testOpsgenieApiIntegration.Id),
    			Creates: opsgenie.IntegrationActionCreateArray{
    				&opsgenie.IntegrationActionCreateArgs{
    					Name: pulumi.String("create action"),
    					Tags: pulumi.StringArray{
    						pulumi.String("CRITICAL"),
    						pulumi.String("SEV-0"),
    					},
    					User:        pulumi.String("Example-service"),
    					Note:        pulumi.String("{{note}}"),
    					Alias:       pulumi.String("{{alias}}"),
    					Source:      pulumi.String("{{source}}"),
    					Message:     pulumi.String("{{message}}"),
    					Description: pulumi.String("{{description}}"),
    					Entity:      pulumi.String("{{entity}}"),
    					AlertActions: pulumi.StringArray{
    						pulumi.String("Runbook ID#342"),
    					},
    					Filters: opsgenie.IntegrationActionCreateFilterArray{
    						&opsgenie.IntegrationActionCreateFilterArgs{
    							Type: pulumi.String("match-all-conditions"),
    							Conditions: opsgenie.IntegrationActionCreateFilterConditionArray{
    								&opsgenie.IntegrationActionCreateFilterConditionArgs{
    									Field:         pulumi.String("priority"),
    									Operation:     pulumi.String("equals"),
    									ExpectedValue: pulumi.String("P1"),
    								},
    							},
    						},
    					},
    					Responders: opsgenie.IntegrationActionCreateResponderArray{
    						&opsgenie.IntegrationActionCreateResponderArgs{
    							Id:   pulumi.Any(test.Id),
    							Type: pulumi.String("team"),
    						},
    					},
    				},
    				&opsgenie.IntegrationActionCreateArgs{
    					Name:        pulumi.String("create action with multiline description"),
    					Message:     pulumi.String("{{message}}"),
    					Description: pulumi.String(invokeChomp.Result),
    					Filters: opsgenie.IntegrationActionCreateFilterArray{
    						&opsgenie.IntegrationActionCreateFilterArgs{
    							Type: pulumi.String("match-all-conditions"),
    							Conditions: opsgenie.IntegrationActionCreateFilterConditionArray{
    								&opsgenie.IntegrationActionCreateFilterConditionArgs{
    									Field:         pulumi.String("priority"),
    									Operation:     pulumi.String("equals"),
    									ExpectedValue: pulumi.String("P1"),
    								},
    							},
    						},
    					},
    				},
    				&opsgenie.IntegrationActionCreateArgs{
    					Name: pulumi.String("Create medium priority alerts"),
    					Tags: pulumi.StringArray{
    						pulumi.String("SEVERE"),
    						pulumi.String("SEV-1"),
    					},
    					Priority: pulumi.String("P3"),
    					Filters: opsgenie.IntegrationActionCreateFilterArray{
    						&opsgenie.IntegrationActionCreateFilterArgs{
    							Type: pulumi.String("match-all-conditions"),
    							Conditions: opsgenie.IntegrationActionCreateFilterConditionArray{
    								&opsgenie.IntegrationActionCreateFilterConditionArgs{
    									Field:         pulumi.String("priority"),
    									Operation:     pulumi.String("equals"),
    									ExpectedValue: pulumi.String("P2"),
    								},
    							},
    						},
    					},
    				},
    				&opsgenie.IntegrationActionCreateArgs{
    					Name:           pulumi.String("Create alert with priority from message"),
    					CustomPriority: pulumi.String("{{message.substringAfter(\"[custom]\")}}"),
    					Filters: opsgenie.IntegrationActionCreateFilterArray{
    						&opsgenie.IntegrationActionCreateFilterArgs{
    							Type: pulumi.String("match-all-conditions"),
    							Conditions: opsgenie.IntegrationActionCreateFilterConditionArray{
    								&opsgenie.IntegrationActionCreateFilterConditionArgs{
    									Field:         pulumi.String("tags"),
    									Operation:     pulumi.String("contains"),
    									ExpectedValue: pulumi.String("P5"),
    								},
    								&opsgenie.IntegrationActionCreateFilterConditionArgs{
    									Field:         pulumi.String("message"),
    									Operation:     pulumi.String("starts-with"),
    									ExpectedValue: pulumi.String("[custom]"),
    								},
    							},
    						},
    					},
    				},
    			},
    			Closes: opsgenie.IntegrationActionCloseArray{
    				&opsgenie.IntegrationActionCloseArgs{
    					Name: pulumi.String("Low priority alerts"),
    					Filters: opsgenie.IntegrationActionCloseFilterArray{
    						&opsgenie.IntegrationActionCloseFilterArgs{
    							Type: pulumi.String("match-any-condition"),
    							Conditions: opsgenie.IntegrationActionCloseFilterConditionArray{
    								&opsgenie.IntegrationActionCloseFilterConditionArgs{
    									Field:         pulumi.String("priority"),
    									Operation:     pulumi.String("equals"),
    									ExpectedValue: pulumi.String("P5"),
    								},
    								&opsgenie.IntegrationActionCloseFilterConditionArgs{
    									Field:         pulumi.String("message"),
    									Operation:     pulumi.String("contains"),
    									ExpectedValue: pulumi.String("DEBUG"),
    								},
    							},
    						},
    					},
    				},
    			},
    			Acknowledges: opsgenie.IntegrationActionAcknowledgeArray{
    				&opsgenie.IntegrationActionAcknowledgeArgs{
    					Name: pulumi.String("Auto-ack test alerts"),
    					Filters: opsgenie.IntegrationActionAcknowledgeFilterArray{
    						&opsgenie.IntegrationActionAcknowledgeFilterArgs{
    							Type: pulumi.String("match-all-conditions"),
    							Conditions: opsgenie.IntegrationActionAcknowledgeFilterConditionArray{
    								&opsgenie.IntegrationActionAcknowledgeFilterConditionArgs{
    									Field:         pulumi.String("message"),
    									Not:           pulumi.Bool(true),
    									Operation:     pulumi.String("contains"),
    									ExpectedValue: pulumi.String("TEST"),
    								},
    								&opsgenie.IntegrationActionAcknowledgeFilterConditionArgs{
    									Field:         pulumi.String("priority"),
    									Operation:     pulumi.String("equals"),
    									ExpectedValue: pulumi.String("P5"),
    								},
    							},
    						},
    					},
    				},
    			},
    			AddNotes: opsgenie.IntegrationActionAddNoteArray{
    				&opsgenie.IntegrationActionAddNoteArgs{
    					Name: pulumi.String("Add note to all alerts"),
    					Note: pulumi.String("Created from test integration"),
    					Filters: opsgenie.IntegrationActionAddNoteFilterArray{
    						&opsgenie.IntegrationActionAddNoteFilterArgs{
    							Type: pulumi.String("match-all"),
    						},
    					},
    				},
    			},
    			Ignores: opsgenie.IntegrationActionIgnoreArray{
    				&opsgenie.IntegrationActionIgnoreArgs{
    					Name: pulumi.String("Ignore alerts with ignore tag"),
    					Filters: opsgenie.IntegrationActionIgnoreFilterArray{
    						&opsgenie.IntegrationActionIgnoreFilterArgs{
    							Type: pulumi.String("match-all-conditions"),
    							Conditions: opsgenie.IntegrationActionIgnoreFilterConditionArray{
    								&opsgenie.IntegrationActionIgnoreFilterConditionArgs{
    									Field:         pulumi.String("tags"),
    									Operation:     pulumi.String("contains"),
    									ExpectedValue: pulumi.String("ignore"),
    								},
    							},
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Opsgenie = Pulumi.Opsgenie;
    using Std = Pulumi.Std;
    
    return await Deployment.RunAsync(() => 
    {
        var testAction = new Opsgenie.IntegrationAction("test_action", new()
        {
            IntegrationId = testOpsgenieApiIntegration.Id,
            Creates = new[]
            {
                new Opsgenie.Inputs.IntegrationActionCreateArgs
                {
                    Name = "create action",
                    Tags = new[]
                    {
                        "CRITICAL",
                        "SEV-0",
                    },
                    User = "Example-service",
                    Note = "{{note}}",
                    Alias = "{{alias}}",
                    Source = "{{source}}",
                    Message = "{{message}}",
                    Description = "{{description}}",
                    Entity = "{{entity}}",
                    AlertActions = new[]
                    {
                        "Runbook ID#342",
                    },
                    Filters = new[]
                    {
                        new Opsgenie.Inputs.IntegrationActionCreateFilterArgs
                        {
                            Type = "match-all-conditions",
                            Conditions = new[]
                            {
                                new Opsgenie.Inputs.IntegrationActionCreateFilterConditionArgs
                                {
                                    Field = "priority",
                                    Operation = "equals",
                                    ExpectedValue = "P1",
                                },
                            },
                        },
                    },
                    Responders = new[]
                    {
                        new Opsgenie.Inputs.IntegrationActionCreateResponderArgs
                        {
                            Id = test.Id,
                            Type = "team",
                        },
                    },
                },
                new Opsgenie.Inputs.IntegrationActionCreateArgs
                {
                    Name = "create action with multiline description",
                    Message = "{{message}}",
                    Description = Std.Chomp.Invoke(new()
                    {
                        Input = @"This
    is a multiline
    description.
    ",
                    }).Apply(invoke => invoke.Result),
                    Filters = new[]
                    {
                        new Opsgenie.Inputs.IntegrationActionCreateFilterArgs
                        {
                            Type = "match-all-conditions",
                            Conditions = new[]
                            {
                                new Opsgenie.Inputs.IntegrationActionCreateFilterConditionArgs
                                {
                                    Field = "priority",
                                    Operation = "equals",
                                    ExpectedValue = "P1",
                                },
                            },
                        },
                    },
                },
                new Opsgenie.Inputs.IntegrationActionCreateArgs
                {
                    Name = "Create medium priority alerts",
                    Tags = new[]
                    {
                        "SEVERE",
                        "SEV-1",
                    },
                    Priority = "P3",
                    Filters = new[]
                    {
                        new Opsgenie.Inputs.IntegrationActionCreateFilterArgs
                        {
                            Type = "match-all-conditions",
                            Conditions = new[]
                            {
                                new Opsgenie.Inputs.IntegrationActionCreateFilterConditionArgs
                                {
                                    Field = "priority",
                                    Operation = "equals",
                                    ExpectedValue = "P2",
                                },
                            },
                        },
                    },
                },
                new Opsgenie.Inputs.IntegrationActionCreateArgs
                {
                    Name = "Create alert with priority from message",
                    CustomPriority = "{{message.substringAfter(\"[custom]\")}}",
                    Filters = new[]
                    {
                        new Opsgenie.Inputs.IntegrationActionCreateFilterArgs
                        {
                            Type = "match-all-conditions",
                            Conditions = new[]
                            {
                                new Opsgenie.Inputs.IntegrationActionCreateFilterConditionArgs
                                {
                                    Field = "tags",
                                    Operation = "contains",
                                    ExpectedValue = "P5",
                                },
                                new Opsgenie.Inputs.IntegrationActionCreateFilterConditionArgs
                                {
                                    Field = "message",
                                    Operation = "starts-with",
                                    ExpectedValue = "[custom]",
                                },
                            },
                        },
                    },
                },
            },
            Closes = new[]
            {
                new Opsgenie.Inputs.IntegrationActionCloseArgs
                {
                    Name = "Low priority alerts",
                    Filters = new[]
                    {
                        new Opsgenie.Inputs.IntegrationActionCloseFilterArgs
                        {
                            Type = "match-any-condition",
                            Conditions = new[]
                            {
                                new Opsgenie.Inputs.IntegrationActionCloseFilterConditionArgs
                                {
                                    Field = "priority",
                                    Operation = "equals",
                                    ExpectedValue = "P5",
                                },
                                new Opsgenie.Inputs.IntegrationActionCloseFilterConditionArgs
                                {
                                    Field = "message",
                                    Operation = "contains",
                                    ExpectedValue = "DEBUG",
                                },
                            },
                        },
                    },
                },
            },
            Acknowledges = new[]
            {
                new Opsgenie.Inputs.IntegrationActionAcknowledgeArgs
                {
                    Name = "Auto-ack test alerts",
                    Filters = new[]
                    {
                        new Opsgenie.Inputs.IntegrationActionAcknowledgeFilterArgs
                        {
                            Type = "match-all-conditions",
                            Conditions = new[]
                            {
                                new Opsgenie.Inputs.IntegrationActionAcknowledgeFilterConditionArgs
                                {
                                    Field = "message",
                                    Not = true,
                                    Operation = "contains",
                                    ExpectedValue = "TEST",
                                },
                                new Opsgenie.Inputs.IntegrationActionAcknowledgeFilterConditionArgs
                                {
                                    Field = "priority",
                                    Operation = "equals",
                                    ExpectedValue = "P5",
                                },
                            },
                        },
                    },
                },
            },
            AddNotes = new[]
            {
                new Opsgenie.Inputs.IntegrationActionAddNoteArgs
                {
                    Name = "Add note to all alerts",
                    Note = "Created from test integration",
                    Filters = new[]
                    {
                        new Opsgenie.Inputs.IntegrationActionAddNoteFilterArgs
                        {
                            Type = "match-all",
                        },
                    },
                },
            },
            Ignores = new[]
            {
                new Opsgenie.Inputs.IntegrationActionIgnoreArgs
                {
                    Name = "Ignore alerts with ignore tag",
                    Filters = new[]
                    {
                        new Opsgenie.Inputs.IntegrationActionIgnoreFilterArgs
                        {
                            Type = "match-all-conditions",
                            Conditions = new[]
                            {
                                new Opsgenie.Inputs.IntegrationActionIgnoreFilterConditionArgs
                                {
                                    Field = "tags",
                                    Operation = "contains",
                                    ExpectedValue = "ignore",
                                },
                            },
                        },
                    },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.opsgenie.IntegrationAction;
    import com.pulumi.opsgenie.IntegrationActionArgs;
    import com.pulumi.opsgenie.inputs.IntegrationActionCreateArgs;
    import com.pulumi.opsgenie.inputs.IntegrationActionCloseArgs;
    import com.pulumi.opsgenie.inputs.IntegrationActionAcknowledgeArgs;
    import com.pulumi.opsgenie.inputs.IntegrationActionAddNoteArgs;
    import com.pulumi.opsgenie.inputs.IntegrationActionIgnoreArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var testAction = new IntegrationAction("testAction", IntegrationActionArgs.builder()
                .integrationId(testOpsgenieApiIntegration.id())
                .creates(            
                    IntegrationActionCreateArgs.builder()
                        .name("create action")
                        .tags(                    
                            "CRITICAL",
                            "SEV-0")
                        .user("Example-service")
                        .note("{{note}}")
                        .alias("{{alias}}")
                        .source("{{source}}")
                        .message("{{message}}")
                        .description("{{description}}")
                        .entity("{{entity}}")
                        .alertActions("Runbook ID#342")
                        .filters(IntegrationActionCreateFilterArgs.builder()
                            .type("match-all-conditions")
                            .conditions(IntegrationActionCreateFilterConditionArgs.builder()
                                .field("priority")
                                .operation("equals")
                                .expectedValue("P1")
                                .build())
                            .build())
                        .responders(IntegrationActionCreateResponderArgs.builder()
                            .id(test.id())
                            .type("team")
                            .build())
                        .build(),
                    IntegrationActionCreateArgs.builder()
                        .name("create action with multiline description")
                        .message("{{message}}")
                        .description(StdFunctions.chomp(ChompArgs.builder()
                            .input("""
    This
    is a multiline
    description.
                            """)
                            .build()).result())
                        .filters(IntegrationActionCreateFilterArgs.builder()
                            .type("match-all-conditions")
                            .conditions(IntegrationActionCreateFilterConditionArgs.builder()
                                .field("priority")
                                .operation("equals")
                                .expectedValue("P1")
                                .build())
                            .build())
                        .build(),
                    IntegrationActionCreateArgs.builder()
                        .name("Create medium priority alerts")
                        .tags(                    
                            "SEVERE",
                            "SEV-1")
                        .priority("P3")
                        .filters(IntegrationActionCreateFilterArgs.builder()
                            .type("match-all-conditions")
                            .conditions(IntegrationActionCreateFilterConditionArgs.builder()
                                .field("priority")
                                .operation("equals")
                                .expectedValue("P2")
                                .build())
                            .build())
                        .build(),
                    IntegrationActionCreateArgs.builder()
                        .name("Create alert with priority from message")
                        .customPriority("{{message.substringAfter(\"[custom]\")}}")
                        .filters(IntegrationActionCreateFilterArgs.builder()
                            .type("match-all-conditions")
                            .conditions(                        
                                IntegrationActionCreateFilterConditionArgs.builder()
                                    .field("tags")
                                    .operation("contains")
                                    .expectedValue("P5")
                                    .build(),
                                IntegrationActionCreateFilterConditionArgs.builder()
                                    .field("message")
                                    .operation("starts-with")
                                    .expectedValue("[custom]")
                                    .build())
                            .build())
                        .build())
                .closes(IntegrationActionCloseArgs.builder()
                    .name("Low priority alerts")
                    .filters(IntegrationActionCloseFilterArgs.builder()
                        .type("match-any-condition")
                        .conditions(                    
                            IntegrationActionCloseFilterConditionArgs.builder()
                                .field("priority")
                                .operation("equals")
                                .expectedValue("P5")
                                .build(),
                            IntegrationActionCloseFilterConditionArgs.builder()
                                .field("message")
                                .operation("contains")
                                .expectedValue("DEBUG")
                                .build())
                        .build())
                    .build())
                .acknowledges(IntegrationActionAcknowledgeArgs.builder()
                    .name("Auto-ack test alerts")
                    .filters(IntegrationActionAcknowledgeFilterArgs.builder()
                        .type("match-all-conditions")
                        .conditions(                    
                            IntegrationActionAcknowledgeFilterConditionArgs.builder()
                                .field("message")
                                .not(true)
                                .operation("contains")
                                .expectedValue("TEST")
                                .build(),
                            IntegrationActionAcknowledgeFilterConditionArgs.builder()
                                .field("priority")
                                .operation("equals")
                                .expectedValue("P5")
                                .build())
                        .build())
                    .build())
                .addNotes(IntegrationActionAddNoteArgs.builder()
                    .name("Add note to all alerts")
                    .note("Created from test integration")
                    .filters(IntegrationActionAddNoteFilterArgs.builder()
                        .type("match-all")
                        .build())
                    .build())
                .ignores(IntegrationActionIgnoreArgs.builder()
                    .name("Ignore alerts with ignore tag")
                    .filters(IntegrationActionIgnoreFilterArgs.builder()
                        .type("match-all-conditions")
                        .conditions(IntegrationActionIgnoreFilterConditionArgs.builder()
                            .field("tags")
                            .operation("contains")
                            .expectedValue("ignore")
                            .build())
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      testAction:
        type: opsgenie:IntegrationAction
        name: test_action
        properties:
          integrationId: ${testOpsgenieApiIntegration.id}
          creates:
            - name: create action
              tags:
                - CRITICAL
                - SEV-0
              user: Example-service
              note: '{{note}}'
              alias: '{{alias}}'
              source: '{{source}}'
              message: '{{message}}'
              description: '{{description}}'
              entity: '{{entity}}'
              alertActions:
                - Runbook ID#342
              filters:
                - type: match-all-conditions
                  conditions:
                    - field: priority
                      operation: equals
                      expectedValue: P1
              responders:
                - id: ${test.id}
                  type: team
            - name: create action with multiline description
              message: '{{message}}'
              description:
                fn::invoke:
                  Function: std:chomp
                  Arguments:
                    input: |
                      This
                      is a multiline
                      description.                  
                  Return: result
              filters:
                - type: match-all-conditions
                  conditions:
                    - field: priority
                      operation: equals
                      expectedValue: P1
            - name: Create medium priority alerts
              tags:
                - SEVERE
                - SEV-1
              priority: P3
              filters:
                - type: match-all-conditions
                  conditions:
                    - field: priority
                      operation: equals
                      expectedValue: P2
            - name: Create alert with priority from message
              customPriority: '{{message.substringAfter("[custom]")}}'
              filters:
                - type: match-all-conditions
                  conditions:
                    - field: tags
                      operation: contains
                      expectedValue: P5
                    - field: message
                      operation: starts-with
                      expectedValue: '[custom]'
          closes:
            - name: Low priority alerts
              filters:
                - type: match-any-condition
                  conditions:
                    - field: priority
                      operation: equals
                      expectedValue: P5
                    - field: message
                      operation: contains
                      expectedValue: DEBUG
          acknowledges:
            - name: Auto-ack test alerts
              filters:
                - type: match-all-conditions
                  conditions:
                    - field: message
                      not: true
                      operation: contains
                      expectedValue: TEST
                    - field: priority
                      operation: equals
                      expectedValue: P5
          addNotes:
            - name: Add note to all alerts
              note: Created from test integration
              filters:
                - type: match-all
          ignores:
            - name: Ignore alerts with ignore tag
              filters:
                - type: match-all-conditions
                  conditions:
                    - field: tags
                      operation: contains
                      expectedValue: ignore
    

    Create IntegrationAction Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new IntegrationAction(name: string, args: IntegrationActionArgs, opts?: CustomResourceOptions);
    @overload
    def IntegrationAction(resource_name: str,
                          args: IntegrationActionArgs,
                          opts: Optional[ResourceOptions] = None)
    
    @overload
    def IntegrationAction(resource_name: str,
                          opts: Optional[ResourceOptions] = None,
                          integration_id: Optional[str] = None,
                          acknowledges: Optional[Sequence[IntegrationActionAcknowledgeArgs]] = None,
                          add_notes: Optional[Sequence[IntegrationActionAddNoteArgs]] = None,
                          closes: Optional[Sequence[IntegrationActionCloseArgs]] = None,
                          creates: Optional[Sequence[IntegrationActionCreateArgs]] = None,
                          ignores: Optional[Sequence[IntegrationActionIgnoreArgs]] = None)
    func NewIntegrationAction(ctx *Context, name string, args IntegrationActionArgs, opts ...ResourceOption) (*IntegrationAction, error)
    public IntegrationAction(string name, IntegrationActionArgs args, CustomResourceOptions? opts = null)
    public IntegrationAction(String name, IntegrationActionArgs args)
    public IntegrationAction(String name, IntegrationActionArgs args, CustomResourceOptions options)
    
    type: opsgenie:IntegrationAction
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    

    Parameters

    name string
    The unique name of the resource.
    args IntegrationActionArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args IntegrationActionArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args IntegrationActionArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args IntegrationActionArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args IntegrationActionArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var integrationActionResource = new Opsgenie.IntegrationAction("integrationActionResource", new()
    {
        IntegrationId = "string",
        Acknowledges = new[]
        {
            new Opsgenie.Inputs.IntegrationActionAcknowledgeArgs
            {
                Name = "string",
                Alias = "string",
                Filters = new[]
                {
                    new Opsgenie.Inputs.IntegrationActionAcknowledgeFilterArgs
                    {
                        Type = "string",
                        Conditions = new[]
                        {
                            new Opsgenie.Inputs.IntegrationActionAcknowledgeFilterConditionArgs
                            {
                                Field = "string",
                                Operation = "string",
                                ExpectedValue = "string",
                                Key = "string",
                                Not = false,
                                Order = 0,
                            },
                        },
                    },
                },
                Note = "string",
                Order = 0,
                Type = "string",
                User = "string",
            },
        },
        AddNotes = new[]
        {
            new Opsgenie.Inputs.IntegrationActionAddNoteArgs
            {
                Name = "string",
                Alias = "string",
                Filters = new[]
                {
                    new Opsgenie.Inputs.IntegrationActionAddNoteFilterArgs
                    {
                        Type = "string",
                        Conditions = new[]
                        {
                            new Opsgenie.Inputs.IntegrationActionAddNoteFilterConditionArgs
                            {
                                Field = "string",
                                Operation = "string",
                                ExpectedValue = "string",
                                Key = "string",
                                Not = false,
                                Order = 0,
                            },
                        },
                    },
                },
                Note = "string",
                Order = 0,
                Type = "string",
                User = "string",
            },
        },
        Closes = new[]
        {
            new Opsgenie.Inputs.IntegrationActionCloseArgs
            {
                Name = "string",
                Alias = "string",
                Filters = new[]
                {
                    new Opsgenie.Inputs.IntegrationActionCloseFilterArgs
                    {
                        Type = "string",
                        Conditions = new[]
                        {
                            new Opsgenie.Inputs.IntegrationActionCloseFilterConditionArgs
                            {
                                Field = "string",
                                Operation = "string",
                                ExpectedValue = "string",
                                Key = "string",
                                Not = false,
                                Order = 0,
                            },
                        },
                    },
                },
                Note = "string",
                Order = 0,
                Type = "string",
                User = "string",
            },
        },
        Creates = new[]
        {
            new Opsgenie.Inputs.IntegrationActionCreateArgs
            {
                Name = "string",
                IgnoreRespondersFromPayload = false,
                CustomPriority = "string",
                IgnoreTeamsFromPayload = false,
                Description = "string",
                Entity = "string",
                ExtraProperties = 
                {
                    { "string", "string" },
                },
                Filters = new[]
                {
                    new Opsgenie.Inputs.IntegrationActionCreateFilterArgs
                    {
                        Type = "string",
                        Conditions = new[]
                        {
                            new Opsgenie.Inputs.IntegrationActionCreateFilterConditionArgs
                            {
                                Field = "string",
                                Operation = "string",
                                ExpectedValue = "string",
                                Key = "string",
                                Not = false,
                                Order = 0,
                            },
                        },
                    },
                },
                IgnoreAlertActionsFromPayload = false,
                Message = "string",
                AlertActions = new[]
                {
                    "string",
                },
                User = "string",
                AppendAttachments = false,
                IgnoreExtraPropertiesFromPayload = false,
                Alias = "string",
                Note = "string",
                Order = 0,
                Priority = "string",
                Responders = new[]
                {
                    new Opsgenie.Inputs.IntegrationActionCreateResponderArgs
                    {
                        Id = "string",
                        Type = "string",
                    },
                },
                Source = "string",
                Tags = new[]
                {
                    "string",
                },
                Type = "string",
                IgnoreTagsFromPayload = false,
            },
        },
        Ignores = new[]
        {
            new Opsgenie.Inputs.IntegrationActionIgnoreArgs
            {
                Name = "string",
                Filters = new[]
                {
                    new Opsgenie.Inputs.IntegrationActionIgnoreFilterArgs
                    {
                        Type = "string",
                        Conditions = new[]
                        {
                            new Opsgenie.Inputs.IntegrationActionIgnoreFilterConditionArgs
                            {
                                Field = "string",
                                Operation = "string",
                                ExpectedValue = "string",
                                Key = "string",
                                Not = false,
                                Order = 0,
                            },
                        },
                    },
                },
                Order = 0,
                Type = "string",
            },
        },
    });
    
    example, err := opsgenie.NewIntegrationAction(ctx, "integrationActionResource", &opsgenie.IntegrationActionArgs{
    	IntegrationId: pulumi.String("string"),
    	Acknowledges: opsgenie.IntegrationActionAcknowledgeArray{
    		&opsgenie.IntegrationActionAcknowledgeArgs{
    			Name:  pulumi.String("string"),
    			Alias: pulumi.String("string"),
    			Filters: opsgenie.IntegrationActionAcknowledgeFilterArray{
    				&opsgenie.IntegrationActionAcknowledgeFilterArgs{
    					Type: pulumi.String("string"),
    					Conditions: opsgenie.IntegrationActionAcknowledgeFilterConditionArray{
    						&opsgenie.IntegrationActionAcknowledgeFilterConditionArgs{
    							Field:         pulumi.String("string"),
    							Operation:     pulumi.String("string"),
    							ExpectedValue: pulumi.String("string"),
    							Key:           pulumi.String("string"),
    							Not:           pulumi.Bool(false),
    							Order:         pulumi.Int(0),
    						},
    					},
    				},
    			},
    			Note:  pulumi.String("string"),
    			Order: pulumi.Int(0),
    			Type:  pulumi.String("string"),
    			User:  pulumi.String("string"),
    		},
    	},
    	AddNotes: opsgenie.IntegrationActionAddNoteArray{
    		&opsgenie.IntegrationActionAddNoteArgs{
    			Name:  pulumi.String("string"),
    			Alias: pulumi.String("string"),
    			Filters: opsgenie.IntegrationActionAddNoteFilterArray{
    				&opsgenie.IntegrationActionAddNoteFilterArgs{
    					Type: pulumi.String("string"),
    					Conditions: opsgenie.IntegrationActionAddNoteFilterConditionArray{
    						&opsgenie.IntegrationActionAddNoteFilterConditionArgs{
    							Field:         pulumi.String("string"),
    							Operation:     pulumi.String("string"),
    							ExpectedValue: pulumi.String("string"),
    							Key:           pulumi.String("string"),
    							Not:           pulumi.Bool(false),
    							Order:         pulumi.Int(0),
    						},
    					},
    				},
    			},
    			Note:  pulumi.String("string"),
    			Order: pulumi.Int(0),
    			Type:  pulumi.String("string"),
    			User:  pulumi.String("string"),
    		},
    	},
    	Closes: opsgenie.IntegrationActionCloseArray{
    		&opsgenie.IntegrationActionCloseArgs{
    			Name:  pulumi.String("string"),
    			Alias: pulumi.String("string"),
    			Filters: opsgenie.IntegrationActionCloseFilterArray{
    				&opsgenie.IntegrationActionCloseFilterArgs{
    					Type: pulumi.String("string"),
    					Conditions: opsgenie.IntegrationActionCloseFilterConditionArray{
    						&opsgenie.IntegrationActionCloseFilterConditionArgs{
    							Field:         pulumi.String("string"),
    							Operation:     pulumi.String("string"),
    							ExpectedValue: pulumi.String("string"),
    							Key:           pulumi.String("string"),
    							Not:           pulumi.Bool(false),
    							Order:         pulumi.Int(0),
    						},
    					},
    				},
    			},
    			Note:  pulumi.String("string"),
    			Order: pulumi.Int(0),
    			Type:  pulumi.String("string"),
    			User:  pulumi.String("string"),
    		},
    	},
    	Creates: opsgenie.IntegrationActionCreateArray{
    		&opsgenie.IntegrationActionCreateArgs{
    			Name:                        pulumi.String("string"),
    			IgnoreRespondersFromPayload: pulumi.Bool(false),
    			CustomPriority:              pulumi.String("string"),
    			IgnoreTeamsFromPayload:      pulumi.Bool(false),
    			Description:                 pulumi.String("string"),
    			Entity:                      pulumi.String("string"),
    			ExtraProperties: pulumi.StringMap{
    				"string": pulumi.String("string"),
    			},
    			Filters: opsgenie.IntegrationActionCreateFilterArray{
    				&opsgenie.IntegrationActionCreateFilterArgs{
    					Type: pulumi.String("string"),
    					Conditions: opsgenie.IntegrationActionCreateFilterConditionArray{
    						&opsgenie.IntegrationActionCreateFilterConditionArgs{
    							Field:         pulumi.String("string"),
    							Operation:     pulumi.String("string"),
    							ExpectedValue: pulumi.String("string"),
    							Key:           pulumi.String("string"),
    							Not:           pulumi.Bool(false),
    							Order:         pulumi.Int(0),
    						},
    					},
    				},
    			},
    			IgnoreAlertActionsFromPayload: pulumi.Bool(false),
    			Message:                       pulumi.String("string"),
    			AlertActions: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			User:                             pulumi.String("string"),
    			AppendAttachments:                pulumi.Bool(false),
    			IgnoreExtraPropertiesFromPayload: pulumi.Bool(false),
    			Alias:                            pulumi.String("string"),
    			Note:                             pulumi.String("string"),
    			Order:                            pulumi.Int(0),
    			Priority:                         pulumi.String("string"),
    			Responders: opsgenie.IntegrationActionCreateResponderArray{
    				&opsgenie.IntegrationActionCreateResponderArgs{
    					Id:   pulumi.String("string"),
    					Type: pulumi.String("string"),
    				},
    			},
    			Source: pulumi.String("string"),
    			Tags: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			Type:                  pulumi.String("string"),
    			IgnoreTagsFromPayload: pulumi.Bool(false),
    		},
    	},
    	Ignores: opsgenie.IntegrationActionIgnoreArray{
    		&opsgenie.IntegrationActionIgnoreArgs{
    			Name: pulumi.String("string"),
    			Filters: opsgenie.IntegrationActionIgnoreFilterArray{
    				&opsgenie.IntegrationActionIgnoreFilterArgs{
    					Type: pulumi.String("string"),
    					Conditions: opsgenie.IntegrationActionIgnoreFilterConditionArray{
    						&opsgenie.IntegrationActionIgnoreFilterConditionArgs{
    							Field:         pulumi.String("string"),
    							Operation:     pulumi.String("string"),
    							ExpectedValue: pulumi.String("string"),
    							Key:           pulumi.String("string"),
    							Not:           pulumi.Bool(false),
    							Order:         pulumi.Int(0),
    						},
    					},
    				},
    			},
    			Order: pulumi.Int(0),
    			Type:  pulumi.String("string"),
    		},
    	},
    })
    
    var integrationActionResource = new IntegrationAction("integrationActionResource", IntegrationActionArgs.builder()
        .integrationId("string")
        .acknowledges(IntegrationActionAcknowledgeArgs.builder()
            .name("string")
            .alias("string")
            .filters(IntegrationActionAcknowledgeFilterArgs.builder()
                .type("string")
                .conditions(IntegrationActionAcknowledgeFilterConditionArgs.builder()
                    .field("string")
                    .operation("string")
                    .expectedValue("string")
                    .key("string")
                    .not(false)
                    .order(0)
                    .build())
                .build())
            .note("string")
            .order(0)
            .type("string")
            .user("string")
            .build())
        .addNotes(IntegrationActionAddNoteArgs.builder()
            .name("string")
            .alias("string")
            .filters(IntegrationActionAddNoteFilterArgs.builder()
                .type("string")
                .conditions(IntegrationActionAddNoteFilterConditionArgs.builder()
                    .field("string")
                    .operation("string")
                    .expectedValue("string")
                    .key("string")
                    .not(false)
                    .order(0)
                    .build())
                .build())
            .note("string")
            .order(0)
            .type("string")
            .user("string")
            .build())
        .closes(IntegrationActionCloseArgs.builder()
            .name("string")
            .alias("string")
            .filters(IntegrationActionCloseFilterArgs.builder()
                .type("string")
                .conditions(IntegrationActionCloseFilterConditionArgs.builder()
                    .field("string")
                    .operation("string")
                    .expectedValue("string")
                    .key("string")
                    .not(false)
                    .order(0)
                    .build())
                .build())
            .note("string")
            .order(0)
            .type("string")
            .user("string")
            .build())
        .creates(IntegrationActionCreateArgs.builder()
            .name("string")
            .ignoreRespondersFromPayload(false)
            .customPriority("string")
            .ignoreTeamsFromPayload(false)
            .description("string")
            .entity("string")
            .extraProperties(Map.of("string", "string"))
            .filters(IntegrationActionCreateFilterArgs.builder()
                .type("string")
                .conditions(IntegrationActionCreateFilterConditionArgs.builder()
                    .field("string")
                    .operation("string")
                    .expectedValue("string")
                    .key("string")
                    .not(false)
                    .order(0)
                    .build())
                .build())
            .ignoreAlertActionsFromPayload(false)
            .message("string")
            .alertActions("string")
            .user("string")
            .appendAttachments(false)
            .ignoreExtraPropertiesFromPayload(false)
            .alias("string")
            .note("string")
            .order(0)
            .priority("string")
            .responders(IntegrationActionCreateResponderArgs.builder()
                .id("string")
                .type("string")
                .build())
            .source("string")
            .tags("string")
            .type("string")
            .ignoreTagsFromPayload(false)
            .build())
        .ignores(IntegrationActionIgnoreArgs.builder()
            .name("string")
            .filters(IntegrationActionIgnoreFilterArgs.builder()
                .type("string")
                .conditions(IntegrationActionIgnoreFilterConditionArgs.builder()
                    .field("string")
                    .operation("string")
                    .expectedValue("string")
                    .key("string")
                    .not(false)
                    .order(0)
                    .build())
                .build())
            .order(0)
            .type("string")
            .build())
        .build());
    
    integration_action_resource = opsgenie.IntegrationAction("integrationActionResource",
        integration_id="string",
        acknowledges=[{
            "name": "string",
            "alias": "string",
            "filters": [{
                "type": "string",
                "conditions": [{
                    "field": "string",
                    "operation": "string",
                    "expected_value": "string",
                    "key": "string",
                    "not_": False,
                    "order": 0,
                }],
            }],
            "note": "string",
            "order": 0,
            "type": "string",
            "user": "string",
        }],
        add_notes=[{
            "name": "string",
            "alias": "string",
            "filters": [{
                "type": "string",
                "conditions": [{
                    "field": "string",
                    "operation": "string",
                    "expected_value": "string",
                    "key": "string",
                    "not_": False,
                    "order": 0,
                }],
            }],
            "note": "string",
            "order": 0,
            "type": "string",
            "user": "string",
        }],
        closes=[{
            "name": "string",
            "alias": "string",
            "filters": [{
                "type": "string",
                "conditions": [{
                    "field": "string",
                    "operation": "string",
                    "expected_value": "string",
                    "key": "string",
                    "not_": False,
                    "order": 0,
                }],
            }],
            "note": "string",
            "order": 0,
            "type": "string",
            "user": "string",
        }],
        creates=[{
            "name": "string",
            "ignore_responders_from_payload": False,
            "custom_priority": "string",
            "ignore_teams_from_payload": False,
            "description": "string",
            "entity": "string",
            "extra_properties": {
                "string": "string",
            },
            "filters": [{
                "type": "string",
                "conditions": [{
                    "field": "string",
                    "operation": "string",
                    "expected_value": "string",
                    "key": "string",
                    "not_": False,
                    "order": 0,
                }],
            }],
            "ignore_alert_actions_from_payload": False,
            "message": "string",
            "alert_actions": ["string"],
            "user": "string",
            "append_attachments": False,
            "ignore_extra_properties_from_payload": False,
            "alias": "string",
            "note": "string",
            "order": 0,
            "priority": "string",
            "responders": [{
                "id": "string",
                "type": "string",
            }],
            "source": "string",
            "tags": ["string"],
            "type": "string",
            "ignore_tags_from_payload": False,
        }],
        ignores=[{
            "name": "string",
            "filters": [{
                "type": "string",
                "conditions": [{
                    "field": "string",
                    "operation": "string",
                    "expected_value": "string",
                    "key": "string",
                    "not_": False,
                    "order": 0,
                }],
            }],
            "order": 0,
            "type": "string",
        }])
    
    const integrationActionResource = new opsgenie.IntegrationAction("integrationActionResource", {
        integrationId: "string",
        acknowledges: [{
            name: "string",
            alias: "string",
            filters: [{
                type: "string",
                conditions: [{
                    field: "string",
                    operation: "string",
                    expectedValue: "string",
                    key: "string",
                    not: false,
                    order: 0,
                }],
            }],
            note: "string",
            order: 0,
            type: "string",
            user: "string",
        }],
        addNotes: [{
            name: "string",
            alias: "string",
            filters: [{
                type: "string",
                conditions: [{
                    field: "string",
                    operation: "string",
                    expectedValue: "string",
                    key: "string",
                    not: false,
                    order: 0,
                }],
            }],
            note: "string",
            order: 0,
            type: "string",
            user: "string",
        }],
        closes: [{
            name: "string",
            alias: "string",
            filters: [{
                type: "string",
                conditions: [{
                    field: "string",
                    operation: "string",
                    expectedValue: "string",
                    key: "string",
                    not: false,
                    order: 0,
                }],
            }],
            note: "string",
            order: 0,
            type: "string",
            user: "string",
        }],
        creates: [{
            name: "string",
            ignoreRespondersFromPayload: false,
            customPriority: "string",
            ignoreTeamsFromPayload: false,
            description: "string",
            entity: "string",
            extraProperties: {
                string: "string",
            },
            filters: [{
                type: "string",
                conditions: [{
                    field: "string",
                    operation: "string",
                    expectedValue: "string",
                    key: "string",
                    not: false,
                    order: 0,
                }],
            }],
            ignoreAlertActionsFromPayload: false,
            message: "string",
            alertActions: ["string"],
            user: "string",
            appendAttachments: false,
            ignoreExtraPropertiesFromPayload: false,
            alias: "string",
            note: "string",
            order: 0,
            priority: "string",
            responders: [{
                id: "string",
                type: "string",
            }],
            source: "string",
            tags: ["string"],
            type: "string",
            ignoreTagsFromPayload: false,
        }],
        ignores: [{
            name: "string",
            filters: [{
                type: "string",
                conditions: [{
                    field: "string",
                    operation: "string",
                    expectedValue: "string",
                    key: "string",
                    not: false,
                    order: 0,
                }],
            }],
            order: 0,
            type: "string",
        }],
    });
    
    type: opsgenie:IntegrationAction
    properties:
        acknowledges:
            - alias: string
              filters:
                - conditions:
                    - expectedValue: string
                      field: string
                      key: string
                      not: false
                      operation: string
                      order: 0
                  type: string
              name: string
              note: string
              order: 0
              type: string
              user: string
        addNotes:
            - alias: string
              filters:
                - conditions:
                    - expectedValue: string
                      field: string
                      key: string
                      not: false
                      operation: string
                      order: 0
                  type: string
              name: string
              note: string
              order: 0
              type: string
              user: string
        closes:
            - alias: string
              filters:
                - conditions:
                    - expectedValue: string
                      field: string
                      key: string
                      not: false
                      operation: string
                      order: 0
                  type: string
              name: string
              note: string
              order: 0
              type: string
              user: string
        creates:
            - alertActions:
                - string
              alias: string
              appendAttachments: false
              customPriority: string
              description: string
              entity: string
              extraProperties:
                string: string
              filters:
                - conditions:
                    - expectedValue: string
                      field: string
                      key: string
                      not: false
                      operation: string
                      order: 0
                  type: string
              ignoreAlertActionsFromPayload: false
              ignoreExtraPropertiesFromPayload: false
              ignoreRespondersFromPayload: false
              ignoreTagsFromPayload: false
              ignoreTeamsFromPayload: false
              message: string
              name: string
              note: string
              order: 0
              priority: string
              responders:
                - id: string
                  type: string
              source: string
              tags:
                - string
              type: string
              user: string
        ignores:
            - filters:
                - conditions:
                    - expectedValue: string
                      field: string
                      key: string
                      not: false
                      operation: string
                      order: 0
                  type: string
              name: string
              order: 0
              type: string
        integrationId: string
    

    IntegrationAction Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The IntegrationAction resource accepts the following input properties:

    Outputs

    All input properties are implicitly available as output properties. Additionally, the IntegrationAction resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing IntegrationAction Resource

    Get an existing IntegrationAction resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: IntegrationActionState, opts?: CustomResourceOptions): IntegrationAction
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            acknowledges: Optional[Sequence[IntegrationActionAcknowledgeArgs]] = None,
            add_notes: Optional[Sequence[IntegrationActionAddNoteArgs]] = None,
            closes: Optional[Sequence[IntegrationActionCloseArgs]] = None,
            creates: Optional[Sequence[IntegrationActionCreateArgs]] = None,
            ignores: Optional[Sequence[IntegrationActionIgnoreArgs]] = None,
            integration_id: Optional[str] = None) -> IntegrationAction
    func GetIntegrationAction(ctx *Context, name string, id IDInput, state *IntegrationActionState, opts ...ResourceOption) (*IntegrationAction, error)
    public static IntegrationAction Get(string name, Input<string> id, IntegrationActionState? state, CustomResourceOptions? opts = null)
    public static IntegrationAction get(String name, Output<String> id, IntegrationActionState state, CustomResourceOptions options)
    Resource lookup is not supported in YAML
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:

    Supporting Types

    IntegrationActionAcknowledge, IntegrationActionAcknowledgeArgs

    Name string
    Name of the integration action.
    Alias string
    An identifier that is used for alert deduplication. Default: {{alias}}.
    Filters List<IntegrationActionAcknowledgeFilter>
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    Note string
    Additional alert action note.
    Order int
    Integer value that defines in which order the action will be performed. Default: 1.
    Type string
    The responder type - can be escalation, team or user.
    User string
    Owner of the execution for integration action.
    Name string
    Name of the integration action.
    Alias string
    An identifier that is used for alert deduplication. Default: {{alias}}.
    Filters []IntegrationActionAcknowledgeFilter
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    Note string
    Additional alert action note.
    Order int
    Integer value that defines in which order the action will be performed. Default: 1.
    Type string
    The responder type - can be escalation, team or user.
    User string
    Owner of the execution for integration action.
    name String
    Name of the integration action.
    alias String
    An identifier that is used for alert deduplication. Default: {{alias}}.
    filters List<IntegrationActionAcknowledgeFilter>
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    note String
    Additional alert action note.
    order Integer
    Integer value that defines in which order the action will be performed. Default: 1.
    type String
    The responder type - can be escalation, team or user.
    user String
    Owner of the execution for integration action.
    name string
    Name of the integration action.
    alias string
    An identifier that is used for alert deduplication. Default: {{alias}}.
    filters IntegrationActionAcknowledgeFilter[]
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    note string
    Additional alert action note.
    order number
    Integer value that defines in which order the action will be performed. Default: 1.
    type string
    The responder type - can be escalation, team or user.
    user string
    Owner of the execution for integration action.
    name str
    Name of the integration action.
    alias str
    An identifier that is used for alert deduplication. Default: {{alias}}.
    filters Sequence[IntegrationActionAcknowledgeFilter]
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    note str
    Additional alert action note.
    order int
    Integer value that defines in which order the action will be performed. Default: 1.
    type str
    The responder type - can be escalation, team or user.
    user str
    Owner of the execution for integration action.
    name String
    Name of the integration action.
    alias String
    An identifier that is used for alert deduplication. Default: {{alias}}.
    filters List<Property Map>
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    note String
    Additional alert action note.
    order Number
    Integer value that defines in which order the action will be performed. Default: 1.
    type String
    The responder type - can be escalation, team or user.
    user String
    Owner of the execution for integration action.

    IntegrationActionAcknowledgeFilter, IntegrationActionAcknowledgeFilterArgs

    Type string
    The responder type - can be escalation, team or user.
    Conditions List<IntegrationActionAcknowledgeFilterCondition>
    Type string
    The responder type - can be escalation, team or user.
    Conditions []IntegrationActionAcknowledgeFilterCondition
    type String
    The responder type - can be escalation, team or user.
    conditions List<IntegrationActionAcknowledgeFilterCondition>
    type string
    The responder type - can be escalation, team or user.
    conditions IntegrationActionAcknowledgeFilterCondition[]
    type str
    The responder type - can be escalation, team or user.
    conditions Sequence[IntegrationActionAcknowledgeFilterCondition]
    type String
    The responder type - can be escalation, team or user.
    conditions List<Property Map>

    IntegrationActionAcknowledgeFilterCondition, IntegrationActionAcknowledgeFilterConditionArgs

    Field string
    Operation string
    ExpectedValue string
    Key string
    Not bool
    Order int
    Integer value that defines in which order the action will be performed. Default: 1.
    Field string
    Operation string
    ExpectedValue string
    Key string
    Not bool
    Order int
    Integer value that defines in which order the action will be performed. Default: 1.
    field String
    operation String
    expectedValue String
    key String
    not Boolean
    order Integer
    Integer value that defines in which order the action will be performed. Default: 1.
    field string
    operation string
    expectedValue string
    key string
    not boolean
    order number
    Integer value that defines in which order the action will be performed. Default: 1.
    field str
    operation str
    expected_value str
    key str
    not_ bool
    order int
    Integer value that defines in which order the action will be performed. Default: 1.
    field String
    operation String
    expectedValue String
    key String
    not Boolean
    order Number
    Integer value that defines in which order the action will be performed. Default: 1.

    IntegrationActionAddNote, IntegrationActionAddNoteArgs

    Name string
    Name of the integration action.
    Alias string
    An identifier that is used for alert deduplication. Default: {{alias}}.
    Filters List<IntegrationActionAddNoteFilter>
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    Note string
    Additional alert action note.
    Order int
    Integer value that defines in which order the action will be performed. Default: 1.
    Type string
    The responder type - can be escalation, team or user.
    User string
    Owner of the execution for integration action.
    Name string
    Name of the integration action.
    Alias string
    An identifier that is used for alert deduplication. Default: {{alias}}.
    Filters []IntegrationActionAddNoteFilter
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    Note string
    Additional alert action note.
    Order int
    Integer value that defines in which order the action will be performed. Default: 1.
    Type string
    The responder type - can be escalation, team or user.
    User string
    Owner of the execution for integration action.
    name String
    Name of the integration action.
    alias String
    An identifier that is used for alert deduplication. Default: {{alias}}.
    filters List<IntegrationActionAddNoteFilter>
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    note String
    Additional alert action note.
    order Integer
    Integer value that defines in which order the action will be performed. Default: 1.
    type String
    The responder type - can be escalation, team or user.
    user String
    Owner of the execution for integration action.
    name string
    Name of the integration action.
    alias string
    An identifier that is used for alert deduplication. Default: {{alias}}.
    filters IntegrationActionAddNoteFilter[]
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    note string
    Additional alert action note.
    order number
    Integer value that defines in which order the action will be performed. Default: 1.
    type string
    The responder type - can be escalation, team or user.
    user string
    Owner of the execution for integration action.
    name str
    Name of the integration action.
    alias str
    An identifier that is used for alert deduplication. Default: {{alias}}.
    filters Sequence[IntegrationActionAddNoteFilter]
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    note str
    Additional alert action note.
    order int
    Integer value that defines in which order the action will be performed. Default: 1.
    type str
    The responder type - can be escalation, team or user.
    user str
    Owner of the execution for integration action.
    name String
    Name of the integration action.
    alias String
    An identifier that is used for alert deduplication. Default: {{alias}}.
    filters List<Property Map>
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    note String
    Additional alert action note.
    order Number
    Integer value that defines in which order the action will be performed. Default: 1.
    type String
    The responder type - can be escalation, team or user.
    user String
    Owner of the execution for integration action.

    IntegrationActionAddNoteFilter, IntegrationActionAddNoteFilterArgs

    Type string
    The responder type - can be escalation, team or user.
    Conditions List<IntegrationActionAddNoteFilterCondition>
    Type string
    The responder type - can be escalation, team or user.
    Conditions []IntegrationActionAddNoteFilterCondition
    type String
    The responder type - can be escalation, team or user.
    conditions List<IntegrationActionAddNoteFilterCondition>
    type string
    The responder type - can be escalation, team or user.
    conditions IntegrationActionAddNoteFilterCondition[]
    type str
    The responder type - can be escalation, team or user.
    conditions Sequence[IntegrationActionAddNoteFilterCondition]
    type String
    The responder type - can be escalation, team or user.
    conditions List<Property Map>

    IntegrationActionAddNoteFilterCondition, IntegrationActionAddNoteFilterConditionArgs

    Field string
    Operation string
    ExpectedValue string
    Key string
    Not bool
    Order int
    Integer value that defines in which order the action will be performed. Default: 1.
    Field string
    Operation string
    ExpectedValue string
    Key string
    Not bool
    Order int
    Integer value that defines in which order the action will be performed. Default: 1.
    field String
    operation String
    expectedValue String
    key String
    not Boolean
    order Integer
    Integer value that defines in which order the action will be performed. Default: 1.
    field string
    operation string
    expectedValue string
    key string
    not boolean
    order number
    Integer value that defines in which order the action will be performed. Default: 1.
    field str
    operation str
    expected_value str
    key str
    not_ bool
    order int
    Integer value that defines in which order the action will be performed. Default: 1.
    field String
    operation String
    expectedValue String
    key String
    not Boolean
    order Number
    Integer value that defines in which order the action will be performed. Default: 1.

    IntegrationActionClose, IntegrationActionCloseArgs

    Name string
    Name of the integration action.
    Alias string
    An identifier that is used for alert deduplication. Default: {{alias}}.
    Filters List<IntegrationActionCloseFilter>
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    Note string
    Additional alert action note.
    Order int
    Integer value that defines in which order the action will be performed. Default: 1.
    Type string
    The responder type - can be escalation, team or user.
    User string
    Owner of the execution for integration action.
    Name string
    Name of the integration action.
    Alias string
    An identifier that is used for alert deduplication. Default: {{alias}}.
    Filters []IntegrationActionCloseFilter
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    Note string
    Additional alert action note.
    Order int
    Integer value that defines in which order the action will be performed. Default: 1.
    Type string
    The responder type - can be escalation, team or user.
    User string
    Owner of the execution for integration action.
    name String
    Name of the integration action.
    alias String
    An identifier that is used for alert deduplication. Default: {{alias}}.
    filters List<IntegrationActionCloseFilter>
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    note String
    Additional alert action note.
    order Integer
    Integer value that defines in which order the action will be performed. Default: 1.
    type String
    The responder type - can be escalation, team or user.
    user String
    Owner of the execution for integration action.
    name string
    Name of the integration action.
    alias string
    An identifier that is used for alert deduplication. Default: {{alias}}.
    filters IntegrationActionCloseFilter[]
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    note string
    Additional alert action note.
    order number
    Integer value that defines in which order the action will be performed. Default: 1.
    type string
    The responder type - can be escalation, team or user.
    user string
    Owner of the execution for integration action.
    name str
    Name of the integration action.
    alias str
    An identifier that is used for alert deduplication. Default: {{alias}}.
    filters Sequence[IntegrationActionCloseFilter]
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    note str
    Additional alert action note.
    order int
    Integer value that defines in which order the action will be performed. Default: 1.
    type str
    The responder type - can be escalation, team or user.
    user str
    Owner of the execution for integration action.
    name String
    Name of the integration action.
    alias String
    An identifier that is used for alert deduplication. Default: {{alias}}.
    filters List<Property Map>
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    note String
    Additional alert action note.
    order Number
    Integer value that defines in which order the action will be performed. Default: 1.
    type String
    The responder type - can be escalation, team or user.
    user String
    Owner of the execution for integration action.

    IntegrationActionCloseFilter, IntegrationActionCloseFilterArgs

    Type string
    The responder type - can be escalation, team or user.
    Conditions List<IntegrationActionCloseFilterCondition>
    Type string
    The responder type - can be escalation, team or user.
    Conditions []IntegrationActionCloseFilterCondition
    type String
    The responder type - can be escalation, team or user.
    conditions List<IntegrationActionCloseFilterCondition>
    type string
    The responder type - can be escalation, team or user.
    conditions IntegrationActionCloseFilterCondition[]
    type str
    The responder type - can be escalation, team or user.
    conditions Sequence[IntegrationActionCloseFilterCondition]
    type String
    The responder type - can be escalation, team or user.
    conditions List<Property Map>

    IntegrationActionCloseFilterCondition, IntegrationActionCloseFilterConditionArgs

    Field string
    Operation string
    ExpectedValue string
    Key string
    Not bool
    Order int
    Integer value that defines in which order the action will be performed. Default: 1.
    Field string
    Operation string
    ExpectedValue string
    Key string
    Not bool
    Order int
    Integer value that defines in which order the action will be performed. Default: 1.
    field String
    operation String
    expectedValue String
    key String
    not Boolean
    order Integer
    Integer value that defines in which order the action will be performed. Default: 1.
    field string
    operation string
    expectedValue string
    key string
    not boolean
    order number
    Integer value that defines in which order the action will be performed. Default: 1.
    field str
    operation str
    expected_value str
    key str
    not_ bool
    order int
    Integer value that defines in which order the action will be performed. Default: 1.
    field String
    operation String
    expectedValue String
    key String
    not Boolean
    order Number
    Integer value that defines in which order the action will be performed. Default: 1.

    IntegrationActionCreate, IntegrationActionCreateArgs

    Name string
    Name of the integration action.
    AlertActions List<string>
    Alias string
    An identifier that is used for alert deduplication. Default: {{alias}}.
    AppendAttachments bool
    CustomPriority string
    Custom alert priority. e.g. {{message.substring(0,2)}}
    Description string
    Detailed description of the alert, anything that may not have fit in the message field.
    Entity string
    The entity the alert is related to.
    ExtraProperties Dictionary<string, string>
    Set of user defined properties specified as a map.
    Filters List<IntegrationActionCreateFilter>
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    IgnoreAlertActionsFromPayload bool
    IgnoreExtraPropertiesFromPayload bool
    IgnoreRespondersFromPayload bool
    If enabled, the integration will ignore responders sent in request payloads.
    IgnoreTagsFromPayload bool
    IgnoreTeamsFromPayload bool
    If enabled, the integration will ignore teams sent in request payloads.
    Message string
    Alert text limited to 130 characters.
    Note string
    Additional alert action note.
    Order int
    Integer value that defines in which order the action will be performed. Default: 1.
    Priority string
    Alert priority.
    Responders List<IntegrationActionCreateResponder>
    User, schedule, teams or escalation names to calculate which users will receive notifications of the alert.
    Source string
    User defined field to specify source of action.
    Tags List<string>
    Comma separated list of labels to be attached to the alert.
    Type string
    The responder type - can be escalation, team or user.
    User string
    Owner of the execution for integration action.
    Name string
    Name of the integration action.
    AlertActions []string
    Alias string
    An identifier that is used for alert deduplication. Default: {{alias}}.
    AppendAttachments bool
    CustomPriority string
    Custom alert priority. e.g. {{message.substring(0,2)}}
    Description string
    Detailed description of the alert, anything that may not have fit in the message field.
    Entity string
    The entity the alert is related to.
    ExtraProperties map[string]string
    Set of user defined properties specified as a map.
    Filters []IntegrationActionCreateFilter
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    IgnoreAlertActionsFromPayload bool
    IgnoreExtraPropertiesFromPayload bool
    IgnoreRespondersFromPayload bool
    If enabled, the integration will ignore responders sent in request payloads.
    IgnoreTagsFromPayload bool
    IgnoreTeamsFromPayload bool
    If enabled, the integration will ignore teams sent in request payloads.
    Message string
    Alert text limited to 130 characters.
    Note string
    Additional alert action note.
    Order int
    Integer value that defines in which order the action will be performed. Default: 1.
    Priority string
    Alert priority.
    Responders []IntegrationActionCreateResponder
    User, schedule, teams or escalation names to calculate which users will receive notifications of the alert.
    Source string
    User defined field to specify source of action.
    Tags []string
    Comma separated list of labels to be attached to the alert.
    Type string
    The responder type - can be escalation, team or user.
    User string
    Owner of the execution for integration action.
    name String
    Name of the integration action.
    alertActions List<String>
    alias String
    An identifier that is used for alert deduplication. Default: {{alias}}.
    appendAttachments Boolean
    customPriority String
    Custom alert priority. e.g. {{message.substring(0,2)}}
    description String
    Detailed description of the alert, anything that may not have fit in the message field.
    entity String
    The entity the alert is related to.
    extraProperties Map<String,String>
    Set of user defined properties specified as a map.
    filters List<IntegrationActionCreateFilter>
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    ignoreAlertActionsFromPayload Boolean
    ignoreExtraPropertiesFromPayload Boolean
    ignoreRespondersFromPayload Boolean
    If enabled, the integration will ignore responders sent in request payloads.
    ignoreTagsFromPayload Boolean
    ignoreTeamsFromPayload Boolean
    If enabled, the integration will ignore teams sent in request payloads.
    message String
    Alert text limited to 130 characters.
    note String
    Additional alert action note.
    order Integer
    Integer value that defines in which order the action will be performed. Default: 1.
    priority String
    Alert priority.
    responders List<IntegrationActionCreateResponder>
    User, schedule, teams or escalation names to calculate which users will receive notifications of the alert.
    source String
    User defined field to specify source of action.
    tags List<String>
    Comma separated list of labels to be attached to the alert.
    type String
    The responder type - can be escalation, team or user.
    user String
    Owner of the execution for integration action.
    name string
    Name of the integration action.
    alertActions string[]
    alias string
    An identifier that is used for alert deduplication. Default: {{alias}}.
    appendAttachments boolean
    customPriority string
    Custom alert priority. e.g. {{message.substring(0,2)}}
    description string
    Detailed description of the alert, anything that may not have fit in the message field.
    entity string
    The entity the alert is related to.
    extraProperties {[key: string]: string}
    Set of user defined properties specified as a map.
    filters IntegrationActionCreateFilter[]
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    ignoreAlertActionsFromPayload boolean
    ignoreExtraPropertiesFromPayload boolean
    ignoreRespondersFromPayload boolean
    If enabled, the integration will ignore responders sent in request payloads.
    ignoreTagsFromPayload boolean
    ignoreTeamsFromPayload boolean
    If enabled, the integration will ignore teams sent in request payloads.
    message string
    Alert text limited to 130 characters.
    note string
    Additional alert action note.
    order number
    Integer value that defines in which order the action will be performed. Default: 1.
    priority string
    Alert priority.
    responders IntegrationActionCreateResponder[]
    User, schedule, teams or escalation names to calculate which users will receive notifications of the alert.
    source string
    User defined field to specify source of action.
    tags string[]
    Comma separated list of labels to be attached to the alert.
    type string
    The responder type - can be escalation, team or user.
    user string
    Owner of the execution for integration action.
    name str
    Name of the integration action.
    alert_actions Sequence[str]
    alias str
    An identifier that is used for alert deduplication. Default: {{alias}}.
    append_attachments bool
    custom_priority str
    Custom alert priority. e.g. {{message.substring(0,2)}}
    description str
    Detailed description of the alert, anything that may not have fit in the message field.
    entity str
    The entity the alert is related to.
    extra_properties Mapping[str, str]
    Set of user defined properties specified as a map.
    filters Sequence[IntegrationActionCreateFilter]
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    ignore_alert_actions_from_payload bool
    ignore_extra_properties_from_payload bool
    ignore_responders_from_payload bool
    If enabled, the integration will ignore responders sent in request payloads.
    ignore_tags_from_payload bool
    ignore_teams_from_payload bool
    If enabled, the integration will ignore teams sent in request payloads.
    message str
    Alert text limited to 130 characters.
    note str
    Additional alert action note.
    order int
    Integer value that defines in which order the action will be performed. Default: 1.
    priority str
    Alert priority.
    responders Sequence[IntegrationActionCreateResponder]
    User, schedule, teams or escalation names to calculate which users will receive notifications of the alert.
    source str
    User defined field to specify source of action.
    tags Sequence[str]
    Comma separated list of labels to be attached to the alert.
    type str
    The responder type - can be escalation, team or user.
    user str
    Owner of the execution for integration action.
    name String
    Name of the integration action.
    alertActions List<String>
    alias String
    An identifier that is used for alert deduplication. Default: {{alias}}.
    appendAttachments Boolean
    customPriority String
    Custom alert priority. e.g. {{message.substring(0,2)}}
    description String
    Detailed description of the alert, anything that may not have fit in the message field.
    entity String
    The entity the alert is related to.
    extraProperties Map<String>
    Set of user defined properties specified as a map.
    filters List<Property Map>
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    ignoreAlertActionsFromPayload Boolean
    ignoreExtraPropertiesFromPayload Boolean
    ignoreRespondersFromPayload Boolean
    If enabled, the integration will ignore responders sent in request payloads.
    ignoreTagsFromPayload Boolean
    ignoreTeamsFromPayload Boolean
    If enabled, the integration will ignore teams sent in request payloads.
    message String
    Alert text limited to 130 characters.
    note String
    Additional alert action note.
    order Number
    Integer value that defines in which order the action will be performed. Default: 1.
    priority String
    Alert priority.
    responders List<Property Map>
    User, schedule, teams or escalation names to calculate which users will receive notifications of the alert.
    source String
    User defined field to specify source of action.
    tags List<String>
    Comma separated list of labels to be attached to the alert.
    type String
    The responder type - can be escalation, team or user.
    user String
    Owner of the execution for integration action.

    IntegrationActionCreateFilter, IntegrationActionCreateFilterArgs

    Type string
    The responder type - can be escalation, team or user.
    Conditions List<IntegrationActionCreateFilterCondition>
    Type string
    The responder type - can be escalation, team or user.
    Conditions []IntegrationActionCreateFilterCondition
    type String
    The responder type - can be escalation, team or user.
    conditions List<IntegrationActionCreateFilterCondition>
    type string
    The responder type - can be escalation, team or user.
    conditions IntegrationActionCreateFilterCondition[]
    type str
    The responder type - can be escalation, team or user.
    conditions Sequence[IntegrationActionCreateFilterCondition]
    type String
    The responder type - can be escalation, team or user.
    conditions List<Property Map>

    IntegrationActionCreateFilterCondition, IntegrationActionCreateFilterConditionArgs

    Field string
    Operation string
    ExpectedValue string
    Key string
    Not bool
    Order int
    Integer value that defines in which order the action will be performed. Default: 1.
    Field string
    Operation string
    ExpectedValue string
    Key string
    Not bool
    Order int
    Integer value that defines in which order the action will be performed. Default: 1.
    field String
    operation String
    expectedValue String
    key String
    not Boolean
    order Integer
    Integer value that defines in which order the action will be performed. Default: 1.
    field string
    operation string
    expectedValue string
    key string
    not boolean
    order number
    Integer value that defines in which order the action will be performed. Default: 1.
    field str
    operation str
    expected_value str
    key str
    not_ bool
    order int
    Integer value that defines in which order the action will be performed. Default: 1.
    field String
    operation String
    expectedValue String
    key String
    not Boolean
    order Number
    Integer value that defines in which order the action will be performed. Default: 1.

    IntegrationActionCreateResponder, IntegrationActionCreateResponderArgs

    Id string
    The id of the responder.
    Type string
    The responder type - can be escalation, team or user.
    Id string
    The id of the responder.
    Type string
    The responder type - can be escalation, team or user.
    id String
    The id of the responder.
    type String
    The responder type - can be escalation, team or user.
    id string
    The id of the responder.
    type string
    The responder type - can be escalation, team or user.
    id str
    The id of the responder.
    type str
    The responder type - can be escalation, team or user.
    id String
    The id of the responder.
    type String
    The responder type - can be escalation, team or user.

    IntegrationActionIgnore, IntegrationActionIgnoreArgs

    Name string
    Name of the integration action.
    Filters List<IntegrationActionIgnoreFilter>
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    Order int
    Integer value that defines in which order the action will be performed. Default: 1.
    Type string
    The responder type - can be escalation, team or user.
    Name string
    Name of the integration action.
    Filters []IntegrationActionIgnoreFilter
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    Order int
    Integer value that defines in which order the action will be performed. Default: 1.
    Type string
    The responder type - can be escalation, team or user.
    name String
    Name of the integration action.
    filters List<IntegrationActionIgnoreFilter>
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    order Integer
    Integer value that defines in which order the action will be performed. Default: 1.
    type String
    The responder type - can be escalation, team or user.
    name string
    Name of the integration action.
    filters IntegrationActionIgnoreFilter[]
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    order number
    Integer value that defines in which order the action will be performed. Default: 1.
    type string
    The responder type - can be escalation, team or user.
    name str
    Name of the integration action.
    filters Sequence[IntegrationActionIgnoreFilter]
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    order int
    Integer value that defines in which order the action will be performed. Default: 1.
    type str
    The responder type - can be escalation, team or user.
    name String
    Name of the integration action.
    filters List<Property Map>
    Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:

    • For SNS integration: actions, alias, entity, Message, recipients, responders, Subject, tags, teams, eventType, Timestamp, TopicArn.
    • For API integration: message, alias, description, source, entity, tags, actions, details, extra-properties, recipients, teams, priority, eventType.
    • For Email integration: from_address, from_name, conversationSubject, subject
    order Number
    Integer value that defines in which order the action will be performed. Default: 1.
    type String
    The responder type - can be escalation, team or user.

    IntegrationActionIgnoreFilter, IntegrationActionIgnoreFilterArgs

    Type string
    The responder type - can be escalation, team or user.
    Conditions List<IntegrationActionIgnoreFilterCondition>
    Type string
    The responder type - can be escalation, team or user.
    Conditions []IntegrationActionIgnoreFilterCondition
    type String
    The responder type - can be escalation, team or user.
    conditions List<IntegrationActionIgnoreFilterCondition>
    type string
    The responder type - can be escalation, team or user.
    conditions IntegrationActionIgnoreFilterCondition[]
    type str
    The responder type - can be escalation, team or user.
    conditions Sequence[IntegrationActionIgnoreFilterCondition]
    type String
    The responder type - can be escalation, team or user.
    conditions List<Property Map>

    IntegrationActionIgnoreFilterCondition, IntegrationActionIgnoreFilterConditionArgs

    Field string
    Operation string
    ExpectedValue string
    Key string
    Not bool
    Order int
    Integer value that defines in which order the action will be performed. Default: 1.
    Field string
    Operation string
    ExpectedValue string
    Key string
    Not bool
    Order int
    Integer value that defines in which order the action will be performed. Default: 1.
    field String
    operation String
    expectedValue String
    key String
    not Boolean
    order Integer
    Integer value that defines in which order the action will be performed. Default: 1.
    field string
    operation string
    expectedValue string
    key string
    not boolean
    order number
    Integer value that defines in which order the action will be performed. Default: 1.
    field str
    operation str
    expected_value str
    key str
    not_ bool
    order int
    Integer value that defines in which order the action will be performed. Default: 1.
    field String
    operation String
    expectedValue String
    key String
    not Boolean
    order Number
    Integer value that defines in which order the action will be performed. Default: 1.

    Package Details

    Repository
    Opsgenie pulumi/pulumi-opsgenie
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the opsgenie Terraform Provider.
    opsgenie logo
    Opsgenie v1.3.12 published on Wednesday, Oct 16, 2024 by Pulumi