1. Packages
  2. Grafana Cloud
  3. API Docs
  4. NotificationPolicy
Grafana v0.5.1 published on Wednesday, Jun 12, 2024 by pulumiverse

grafana.NotificationPolicy

Explore with Pulumi AI

grafana logo
Grafana v0.5.1 published on Wednesday, Jun 12, 2024 by pulumiverse

    Sets the global notification policy for Grafana.

    !> This resource manages the entire notification policy tree, and will overwrite any existing policies.

    This resource requires Grafana 9.1.0 or later.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
    import * as grafana from "@pulumiverse/grafana";
    
    const aContactPoint = new grafana.ContactPoint("aContactPoint", {emails: [{
        addresses: [
            "one@company.org",
            "two@company.org",
        ],
        message: "{{ len .Alerts.Firing }} firing.",
    }]});
    const aMuteTiming = new grafana.MuteTiming("aMuteTiming", {intervals: [{
        weekdays: ["monday"],
    }]});
    const myNotificationPolicy = new grafana.NotificationPolicy("myNotificationPolicy", {
        groupBies: ["..."],
        contactPoint: aContactPoint.name,
        groupWait: "45s",
        groupInterval: "6m",
        repeatInterval: "3h",
        policies: [
            {
                matchers: [
                    {
                        label: "mylabel",
                        match: "=",
                        value: "myvalue",
                    },
                    {
                        label: "alertname",
                        match: "=",
                        value: "CPU Usage",
                    },
                    {
                        label: "Name",
                        match: "=~",
                        value: "host.*|host-b.*",
                    },
                ],
                contactPoint: aContactPoint.name,
                "continue": true,
                muteTimings: [aMuteTiming.name],
                groupWait: "45s",
                groupInterval: "6m",
                repeatInterval: "3h",
                policies: [{
                    matchers: [{
                        label: "sublabel",
                        match: "=",
                        value: "subvalue",
                    }],
                    contactPoint: aContactPoint.name,
                    groupBies: ["..."],
                }],
            },
            {
                matchers: [{
                    label: "anotherlabel",
                    match: "=~",
                    value: "another value.*",
                }],
                contactPoint: aContactPoint.name,
                groupBies: ["..."],
            },
        ],
    });
    
    import pulumi
    import pulumiverse_grafana as grafana
    
    a_contact_point = grafana.ContactPoint("aContactPoint", emails=[grafana.ContactPointEmailArgs(
        addresses=[
            "one@company.org",
            "two@company.org",
        ],
        message="{{ len .Alerts.Firing }} firing.",
    )])
    a_mute_timing = grafana.MuteTiming("aMuteTiming", intervals=[grafana.MuteTimingIntervalArgs(
        weekdays=["monday"],
    )])
    my_notification_policy = grafana.NotificationPolicy("myNotificationPolicy",
        group_bies=["..."],
        contact_point=a_contact_point.name,
        group_wait="45s",
        group_interval="6m",
        repeat_interval="3h",
        policies=[
            grafana.NotificationPolicyPolicyArgs(
                matchers=[
                    grafana.NotificationPolicyPolicyMatcherArgs(
                        label="mylabel",
                        match="=",
                        value="myvalue",
                    ),
                    grafana.NotificationPolicyPolicyMatcherArgs(
                        label="alertname",
                        match="=",
                        value="CPU Usage",
                    ),
                    grafana.NotificationPolicyPolicyMatcherArgs(
                        label="Name",
                        match="=~",
                        value="host.*|host-b.*",
                    ),
                ],
                contact_point=a_contact_point.name,
                continue_=True,
                mute_timings=[a_mute_timing.name],
                group_wait="45s",
                group_interval="6m",
                repeat_interval="3h",
                policies=[grafana.NotificationPolicyPolicyPolicyArgs(
                    matchers=[grafana.NotificationPolicyPolicyPolicyMatcherArgs(
                        label="sublabel",
                        match="=",
                        value="subvalue",
                    )],
                    contact_point=a_contact_point.name,
                    group_bies=["..."],
                )],
            ),
            grafana.NotificationPolicyPolicyArgs(
                matchers=[grafana.NotificationPolicyPolicyMatcherArgs(
                    label="anotherlabel",
                    match="=~",
                    value="another value.*",
                )],
                contact_point=a_contact_point.name,
                group_bies=["..."],
            ),
        ])
    
    package main
    
    import (
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    	"github.com/pulumiverse/pulumi-grafana/sdk/go/grafana"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		aContactPoint, err := grafana.NewContactPoint(ctx, "aContactPoint", &grafana.ContactPointArgs{
    			Emails: grafana.ContactPointEmailArray{
    				&grafana.ContactPointEmailArgs{
    					Addresses: pulumi.StringArray{
    						pulumi.String("one@company.org"),
    						pulumi.String("two@company.org"),
    					},
    					Message: pulumi.String("{{ len .Alerts.Firing }} firing."),
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		aMuteTiming, err := grafana.NewMuteTiming(ctx, "aMuteTiming", &grafana.MuteTimingArgs{
    			Intervals: grafana.MuteTimingIntervalArray{
    				&grafana.MuteTimingIntervalArgs{
    					Weekdays: pulumi.StringArray{
    						pulumi.String("monday"),
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		_, err = grafana.NewNotificationPolicy(ctx, "myNotificationPolicy", &grafana.NotificationPolicyArgs{
    			GroupBies: pulumi.StringArray{
    				pulumi.String("..."),
    			},
    			ContactPoint:   aContactPoint.Name,
    			GroupWait:      pulumi.String("45s"),
    			GroupInterval:  pulumi.String("6m"),
    			RepeatInterval: pulumi.String("3h"),
    			Policies: grafana.NotificationPolicyPolicyArray{
    				&grafana.NotificationPolicyPolicyArgs{
    					Matchers: grafana.NotificationPolicyPolicyMatcherArray{
    						&grafana.NotificationPolicyPolicyMatcherArgs{
    							Label: pulumi.String("mylabel"),
    							Match: pulumi.String("="),
    							Value: pulumi.String("myvalue"),
    						},
    						&grafana.NotificationPolicyPolicyMatcherArgs{
    							Label: pulumi.String("alertname"),
    							Match: pulumi.String("="),
    							Value: pulumi.String("CPU Usage"),
    						},
    						&grafana.NotificationPolicyPolicyMatcherArgs{
    							Label: pulumi.String("Name"),
    							Match: pulumi.String("=~"),
    							Value: pulumi.String("host.*|host-b.*"),
    						},
    					},
    					ContactPoint: aContactPoint.Name,
    					Continue:     pulumi.Bool(true),
    					MuteTimings: pulumi.StringArray{
    						aMuteTiming.Name,
    					},
    					GroupWait:      pulumi.String("45s"),
    					GroupInterval:  pulumi.String("6m"),
    					RepeatInterval: pulumi.String("3h"),
    					Policies: grafana.NotificationPolicyPolicyPolicyArray{
    						&grafana.NotificationPolicyPolicyPolicyArgs{
    							Matchers: grafana.NotificationPolicyPolicyPolicyMatcherArray{
    								&grafana.NotificationPolicyPolicyPolicyMatcherArgs{
    									Label: pulumi.String("sublabel"),
    									Match: pulumi.String("="),
    									Value: pulumi.String("subvalue"),
    								},
    							},
    							ContactPoint: aContactPoint.Name,
    							GroupBies: pulumi.StringArray{
    								pulumi.String("..."),
    							},
    						},
    					},
    				},
    				&grafana.NotificationPolicyPolicyArgs{
    					Matchers: grafana.NotificationPolicyPolicyMatcherArray{
    						&grafana.NotificationPolicyPolicyMatcherArgs{
    							Label: pulumi.String("anotherlabel"),
    							Match: pulumi.String("=~"),
    							Value: pulumi.String("another value.*"),
    						},
    					},
    					ContactPoint: aContactPoint.Name,
    					GroupBies: pulumi.StringArray{
    						pulumi.String("..."),
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Grafana = Pulumiverse.Grafana;
    
    return await Deployment.RunAsync(() => 
    {
        var aContactPoint = new Grafana.ContactPoint("aContactPoint", new()
        {
            Emails = new[]
            {
                new Grafana.Inputs.ContactPointEmailArgs
                {
                    Addresses = new[]
                    {
                        "one@company.org",
                        "two@company.org",
                    },
                    Message = "{{ len .Alerts.Firing }} firing.",
                },
            },
        });
    
        var aMuteTiming = new Grafana.MuteTiming("aMuteTiming", new()
        {
            Intervals = new[]
            {
                new Grafana.Inputs.MuteTimingIntervalArgs
                {
                    Weekdays = new[]
                    {
                        "monday",
                    },
                },
            },
        });
    
        var myNotificationPolicy = new Grafana.NotificationPolicy("myNotificationPolicy", new()
        {
            GroupBies = new[]
            {
                "...",
            },
            ContactPoint = aContactPoint.Name,
            GroupWait = "45s",
            GroupInterval = "6m",
            RepeatInterval = "3h",
            Policies = new[]
            {
                new Grafana.Inputs.NotificationPolicyPolicyArgs
                {
                    Matchers = new[]
                    {
                        new Grafana.Inputs.NotificationPolicyPolicyMatcherArgs
                        {
                            Label = "mylabel",
                            Match = "=",
                            Value = "myvalue",
                        },
                        new Grafana.Inputs.NotificationPolicyPolicyMatcherArgs
                        {
                            Label = "alertname",
                            Match = "=",
                            Value = "CPU Usage",
                        },
                        new Grafana.Inputs.NotificationPolicyPolicyMatcherArgs
                        {
                            Label = "Name",
                            Match = "=~",
                            Value = "host.*|host-b.*",
                        },
                    },
                    ContactPoint = aContactPoint.Name,
                    Continue = true,
                    MuteTimings = new[]
                    {
                        aMuteTiming.Name,
                    },
                    GroupWait = "45s",
                    GroupInterval = "6m",
                    RepeatInterval = "3h",
                    Policies = new[]
                    {
                        new Grafana.Inputs.NotificationPolicyPolicyPolicyArgs
                        {
                            Matchers = new[]
                            {
                                new Grafana.Inputs.NotificationPolicyPolicyPolicyMatcherArgs
                                {
                                    Label = "sublabel",
                                    Match = "=",
                                    Value = "subvalue",
                                },
                            },
                            ContactPoint = aContactPoint.Name,
                            GroupBies = new[]
                            {
                                "...",
                            },
                        },
                    },
                },
                new Grafana.Inputs.NotificationPolicyPolicyArgs
                {
                    Matchers = new[]
                    {
                        new Grafana.Inputs.NotificationPolicyPolicyMatcherArgs
                        {
                            Label = "anotherlabel",
                            Match = "=~",
                            Value = "another value.*",
                        },
                    },
                    ContactPoint = aContactPoint.Name,
                    GroupBies = new[]
                    {
                        "...",
                    },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.grafana.ContactPoint;
    import com.pulumi.grafana.ContactPointArgs;
    import com.pulumi.grafana.inputs.ContactPointEmailArgs;
    import com.pulumi.grafana.MuteTiming;
    import com.pulumi.grafana.MuteTimingArgs;
    import com.pulumi.grafana.inputs.MuteTimingIntervalArgs;
    import com.pulumi.grafana.NotificationPolicy;
    import com.pulumi.grafana.NotificationPolicyArgs;
    import com.pulumi.grafana.inputs.NotificationPolicyPolicyArgs;
    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 aContactPoint = new ContactPoint("aContactPoint", ContactPointArgs.builder()        
                .emails(ContactPointEmailArgs.builder()
                    .addresses(                
                        "one@company.org",
                        "two@company.org")
                    .message("{{ len .Alerts.Firing }} firing.")
                    .build())
                .build());
    
            var aMuteTiming = new MuteTiming("aMuteTiming", MuteTimingArgs.builder()        
                .intervals(MuteTimingIntervalArgs.builder()
                    .weekdays("monday")
                    .build())
                .build());
    
            var myNotificationPolicy = new NotificationPolicy("myNotificationPolicy", NotificationPolicyArgs.builder()        
                .groupBies("...")
                .contactPoint(aContactPoint.name())
                .groupWait("45s")
                .groupInterval("6m")
                .repeatInterval("3h")
                .policies(            
                    NotificationPolicyPolicyArgs.builder()
                        .matchers(                    
                            NotificationPolicyPolicyMatcherArgs.builder()
                                .label("mylabel")
                                .match("=")
                                .value("myvalue")
                                .build(),
                            NotificationPolicyPolicyMatcherArgs.builder()
                                .label("alertname")
                                .match("=")
                                .value("CPU Usage")
                                .build(),
                            NotificationPolicyPolicyMatcherArgs.builder()
                                .label("Name")
                                .match("=~")
                                .value("host.*|host-b.*")
                                .build())
                        .contactPoint(aContactPoint.name())
                        .continue_(true)
                        .muteTimings(aMuteTiming.name())
                        .groupWait("45s")
                        .groupInterval("6m")
                        .repeatInterval("3h")
                        .policies(NotificationPolicyPolicyPolicyArgs.builder()
                            .matchers(NotificationPolicyPolicyPolicyMatcherArgs.builder()
                                .label("sublabel")
                                .match("=")
                                .value("subvalue")
                                .build())
                            .contactPoint(aContactPoint.name())
                            .groupBies("...")
                            .build())
                        .build(),
                    NotificationPolicyPolicyArgs.builder()
                        .matchers(NotificationPolicyPolicyMatcherArgs.builder()
                            .label("anotherlabel")
                            .match("=~")
                            .value("another value.*")
                            .build())
                        .contactPoint(aContactPoint.name())
                        .groupBies("...")
                        .build())
                .build());
    
        }
    }
    
    resources:
      aContactPoint:
        type: grafana:ContactPoint
        properties:
          emails:
            - addresses:
                - one@company.org
                - two@company.org
              message: '{{ len .Alerts.Firing }} firing.'
      aMuteTiming:
        type: grafana:MuteTiming
        properties:
          intervals:
            - weekdays:
                - monday
      myNotificationPolicy:
        type: grafana:NotificationPolicy
        properties:
          groupBies:
            - '...'
          contactPoint: ${aContactPoint.name}
          groupWait: 45s
          groupInterval: 6m
          repeatInterval: 3h
          policies:
            - matchers:
                - label: mylabel
                  match: =
                  value: myvalue
                - label: alertname
                  match: =
                  value: CPU Usage
                - label: Name
                  match: =~
                  value: host.*|host-b.*
              contactPoint: ${aContactPoint.name}
              continue: true
              muteTimings:
                - ${aMuteTiming.name}
              groupWait: 45s
              groupInterval: 6m
              repeatInterval: 3h
              policies:
                - matchers:
                    - label: sublabel
                      match: =
                      value: subvalue
                  contactPoint: ${aContactPoint.name}
                  groupBies:
                    - '...'
            - matchers:
                - label: anotherlabel
                  match: =~
                  value: another value.*
              contactPoint: ${aContactPoint.name}
              groupBies:
                - '...'
    

    Create NotificationPolicy Resource

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

    Constructor syntax

    new NotificationPolicy(name: string, args: NotificationPolicyArgs, opts?: CustomResourceOptions);
    @overload
    def NotificationPolicy(resource_name: str,
                           args: NotificationPolicyArgs,
                           opts: Optional[ResourceOptions] = None)
    
    @overload
    def NotificationPolicy(resource_name: str,
                           opts: Optional[ResourceOptions] = None,
                           contact_point: Optional[str] = None,
                           group_bies: Optional[Sequence[str]] = None,
                           disable_provenance: Optional[bool] = None,
                           group_interval: Optional[str] = None,
                           group_wait: Optional[str] = None,
                           org_id: Optional[str] = None,
                           policies: Optional[Sequence[NotificationPolicyPolicyArgs]] = None,
                           repeat_interval: Optional[str] = None)
    func NewNotificationPolicy(ctx *Context, name string, args NotificationPolicyArgs, opts ...ResourceOption) (*NotificationPolicy, error)
    public NotificationPolicy(string name, NotificationPolicyArgs args, CustomResourceOptions? opts = null)
    public NotificationPolicy(String name, NotificationPolicyArgs args)
    public NotificationPolicy(String name, NotificationPolicyArgs args, CustomResourceOptions options)
    
    type: grafana:NotificationPolicy
    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 NotificationPolicyArgs
    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 NotificationPolicyArgs
    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 NotificationPolicyArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args NotificationPolicyArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args NotificationPolicyArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Example

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

    var notificationPolicyResource = new Grafana.NotificationPolicy("notificationPolicyResource", new()
    {
        ContactPoint = "string",
        GroupBies = new[]
        {
            "string",
        },
        DisableProvenance = false,
        GroupInterval = "string",
        GroupWait = "string",
        OrgId = "string",
        Policies = new[]
        {
            new Grafana.Inputs.NotificationPolicyPolicyArgs
            {
                ContactPoint = "string",
                Continue = false,
                GroupBies = new[]
                {
                    "string",
                },
                GroupInterval = "string",
                GroupWait = "string",
                Matchers = new[]
                {
                    new Grafana.Inputs.NotificationPolicyPolicyMatcherArgs
                    {
                        Label = "string",
                        Match = "string",
                        Value = "string",
                    },
                },
                MuteTimings = new[]
                {
                    "string",
                },
                Policies = new[]
                {
                    new Grafana.Inputs.NotificationPolicyPolicyPolicyArgs
                    {
                        ContactPoint = "string",
                        Continue = false,
                        GroupBies = new[]
                        {
                            "string",
                        },
                        GroupInterval = "string",
                        GroupWait = "string",
                        Matchers = new[]
                        {
                            new Grafana.Inputs.NotificationPolicyPolicyPolicyMatcherArgs
                            {
                                Label = "string",
                                Match = "string",
                                Value = "string",
                            },
                        },
                        MuteTimings = new[]
                        {
                            "string",
                        },
                        Policies = new[]
                        {
                            new Grafana.Inputs.NotificationPolicyPolicyPolicyPolicyArgs
                            {
                                ContactPoint = "string",
                                Continue = false,
                                GroupBies = new[]
                                {
                                    "string",
                                },
                                GroupInterval = "string",
                                GroupWait = "string",
                                Matchers = new[]
                                {
                                    new Grafana.Inputs.NotificationPolicyPolicyPolicyPolicyMatcherArgs
                                    {
                                        Label = "string",
                                        Match = "string",
                                        Value = "string",
                                    },
                                },
                                MuteTimings = new[]
                                {
                                    "string",
                                },
                                Policies = new[]
                                {
                                    new Grafana.Inputs.NotificationPolicyPolicyPolicyPolicyPolicyArgs
                                    {
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        ContactPoint = "string",
                                        Continue = false,
                                        GroupInterval = "string",
                                        GroupWait = "string",
                                        Matchers = new[]
                                        {
                                            new Grafana.Inputs.NotificationPolicyPolicyPolicyPolicyPolicyMatcherArgs
                                            {
                                                Label = "string",
                                                Match = "string",
                                                Value = "string",
                                            },
                                        },
                                        MuteTimings = new[]
                                        {
                                            "string",
                                        },
                                        RepeatInterval = "string",
                                    },
                                },
                                RepeatInterval = "string",
                            },
                        },
                        RepeatInterval = "string",
                    },
                },
                RepeatInterval = "string",
            },
        },
        RepeatInterval = "string",
    });
    
    example, err := grafana.NewNotificationPolicy(ctx, "notificationPolicyResource", &grafana.NotificationPolicyArgs{
    	ContactPoint: pulumi.String("string"),
    	GroupBies: pulumi.StringArray{
    		pulumi.String("string"),
    	},
    	DisableProvenance: pulumi.Bool(false),
    	GroupInterval:     pulumi.String("string"),
    	GroupWait:         pulumi.String("string"),
    	OrgId:             pulumi.String("string"),
    	Policies: grafana.NotificationPolicyPolicyArray{
    		&grafana.NotificationPolicyPolicyArgs{
    			ContactPoint: pulumi.String("string"),
    			Continue:     pulumi.Bool(false),
    			GroupBies: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			GroupInterval: pulumi.String("string"),
    			GroupWait:     pulumi.String("string"),
    			Matchers: grafana.NotificationPolicyPolicyMatcherArray{
    				&grafana.NotificationPolicyPolicyMatcherArgs{
    					Label: pulumi.String("string"),
    					Match: pulumi.String("string"),
    					Value: pulumi.String("string"),
    				},
    			},
    			MuteTimings: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			Policies: grafana.NotificationPolicyPolicyPolicyArray{
    				&grafana.NotificationPolicyPolicyPolicyArgs{
    					ContactPoint: pulumi.String("string"),
    					Continue:     pulumi.Bool(false),
    					GroupBies: pulumi.StringArray{
    						pulumi.String("string"),
    					},
    					GroupInterval: pulumi.String("string"),
    					GroupWait:     pulumi.String("string"),
    					Matchers: grafana.NotificationPolicyPolicyPolicyMatcherArray{
    						&grafana.NotificationPolicyPolicyPolicyMatcherArgs{
    							Label: pulumi.String("string"),
    							Match: pulumi.String("string"),
    							Value: pulumi.String("string"),
    						},
    					},
    					MuteTimings: pulumi.StringArray{
    						pulumi.String("string"),
    					},
    					Policies: grafana.NotificationPolicyPolicyPolicyPolicyArray{
    						&grafana.NotificationPolicyPolicyPolicyPolicyArgs{
    							ContactPoint: pulumi.String("string"),
    							Continue:     pulumi.Bool(false),
    							GroupBies: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							GroupInterval: pulumi.String("string"),
    							GroupWait:     pulumi.String("string"),
    							Matchers: grafana.NotificationPolicyPolicyPolicyPolicyMatcherArray{
    								&grafana.NotificationPolicyPolicyPolicyPolicyMatcherArgs{
    									Label: pulumi.String("string"),
    									Match: pulumi.String("string"),
    									Value: pulumi.String("string"),
    								},
    							},
    							MuteTimings: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							Policies: grafana.NotificationPolicyPolicyPolicyPolicyPolicyArray{
    								&grafana.NotificationPolicyPolicyPolicyPolicyPolicyArgs{
    									GroupBies: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									ContactPoint:  pulumi.String("string"),
    									Continue:      pulumi.Bool(false),
    									GroupInterval: pulumi.String("string"),
    									GroupWait:     pulumi.String("string"),
    									Matchers: grafana.NotificationPolicyPolicyPolicyPolicyPolicyMatcherArray{
    										&grafana.NotificationPolicyPolicyPolicyPolicyPolicyMatcherArgs{
    											Label: pulumi.String("string"),
    											Match: pulumi.String("string"),
    											Value: pulumi.String("string"),
    										},
    									},
    									MuteTimings: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									RepeatInterval: pulumi.String("string"),
    								},
    							},
    							RepeatInterval: pulumi.String("string"),
    						},
    					},
    					RepeatInterval: pulumi.String("string"),
    				},
    			},
    			RepeatInterval: pulumi.String("string"),
    		},
    	},
    	RepeatInterval: pulumi.String("string"),
    })
    
    var notificationPolicyResource = new NotificationPolicy("notificationPolicyResource", NotificationPolicyArgs.builder()
        .contactPoint("string")
        .groupBies("string")
        .disableProvenance(false)
        .groupInterval("string")
        .groupWait("string")
        .orgId("string")
        .policies(NotificationPolicyPolicyArgs.builder()
            .contactPoint("string")
            .continue_(false)
            .groupBies("string")
            .groupInterval("string")
            .groupWait("string")
            .matchers(NotificationPolicyPolicyMatcherArgs.builder()
                .label("string")
                .match("string")
                .value("string")
                .build())
            .muteTimings("string")
            .policies(NotificationPolicyPolicyPolicyArgs.builder()
                .contactPoint("string")
                .continue_(false)
                .groupBies("string")
                .groupInterval("string")
                .groupWait("string")
                .matchers(NotificationPolicyPolicyPolicyMatcherArgs.builder()
                    .label("string")
                    .match("string")
                    .value("string")
                    .build())
                .muteTimings("string")
                .policies(NotificationPolicyPolicyPolicyPolicyArgs.builder()
                    .contactPoint("string")
                    .continue_(false)
                    .groupBies("string")
                    .groupInterval("string")
                    .groupWait("string")
                    .matchers(NotificationPolicyPolicyPolicyPolicyMatcherArgs.builder()
                        .label("string")
                        .match("string")
                        .value("string")
                        .build())
                    .muteTimings("string")
                    .policies(NotificationPolicyPolicyPolicyPolicyPolicyArgs.builder()
                        .groupBies("string")
                        .contactPoint("string")
                        .continue_(false)
                        .groupInterval("string")
                        .groupWait("string")
                        .matchers(NotificationPolicyPolicyPolicyPolicyPolicyMatcherArgs.builder()
                            .label("string")
                            .match("string")
                            .value("string")
                            .build())
                        .muteTimings("string")
                        .repeatInterval("string")
                        .build())
                    .repeatInterval("string")
                    .build())
                .repeatInterval("string")
                .build())
            .repeatInterval("string")
            .build())
        .repeatInterval("string")
        .build());
    
    notification_policy_resource = grafana.NotificationPolicy("notificationPolicyResource",
        contact_point="string",
        group_bies=["string"],
        disable_provenance=False,
        group_interval="string",
        group_wait="string",
        org_id="string",
        policies=[grafana.NotificationPolicyPolicyArgs(
            contact_point="string",
            continue_=False,
            group_bies=["string"],
            group_interval="string",
            group_wait="string",
            matchers=[grafana.NotificationPolicyPolicyMatcherArgs(
                label="string",
                match="string",
                value="string",
            )],
            mute_timings=["string"],
            policies=[grafana.NotificationPolicyPolicyPolicyArgs(
                contact_point="string",
                continue_=False,
                group_bies=["string"],
                group_interval="string",
                group_wait="string",
                matchers=[grafana.NotificationPolicyPolicyPolicyMatcherArgs(
                    label="string",
                    match="string",
                    value="string",
                )],
                mute_timings=["string"],
                policies=[grafana.NotificationPolicyPolicyPolicyPolicyArgs(
                    contact_point="string",
                    continue_=False,
                    group_bies=["string"],
                    group_interval="string",
                    group_wait="string",
                    matchers=[grafana.NotificationPolicyPolicyPolicyPolicyMatcherArgs(
                        label="string",
                        match="string",
                        value="string",
                    )],
                    mute_timings=["string"],
                    policies=[grafana.NotificationPolicyPolicyPolicyPolicyPolicyArgs(
                        group_bies=["string"],
                        contact_point="string",
                        continue_=False,
                        group_interval="string",
                        group_wait="string",
                        matchers=[grafana.NotificationPolicyPolicyPolicyPolicyPolicyMatcherArgs(
                            label="string",
                            match="string",
                            value="string",
                        )],
                        mute_timings=["string"],
                        repeat_interval="string",
                    )],
                    repeat_interval="string",
                )],
                repeat_interval="string",
            )],
            repeat_interval="string",
        )],
        repeat_interval="string")
    
    const notificationPolicyResource = new grafana.NotificationPolicy("notificationPolicyResource", {
        contactPoint: "string",
        groupBies: ["string"],
        disableProvenance: false,
        groupInterval: "string",
        groupWait: "string",
        orgId: "string",
        policies: [{
            contactPoint: "string",
            "continue": false,
            groupBies: ["string"],
            groupInterval: "string",
            groupWait: "string",
            matchers: [{
                label: "string",
                match: "string",
                value: "string",
            }],
            muteTimings: ["string"],
            policies: [{
                contactPoint: "string",
                "continue": false,
                groupBies: ["string"],
                groupInterval: "string",
                groupWait: "string",
                matchers: [{
                    label: "string",
                    match: "string",
                    value: "string",
                }],
                muteTimings: ["string"],
                policies: [{
                    contactPoint: "string",
                    "continue": false,
                    groupBies: ["string"],
                    groupInterval: "string",
                    groupWait: "string",
                    matchers: [{
                        label: "string",
                        match: "string",
                        value: "string",
                    }],
                    muteTimings: ["string"],
                    policies: [{
                        groupBies: ["string"],
                        contactPoint: "string",
                        "continue": false,
                        groupInterval: "string",
                        groupWait: "string",
                        matchers: [{
                            label: "string",
                            match: "string",
                            value: "string",
                        }],
                        muteTimings: ["string"],
                        repeatInterval: "string",
                    }],
                    repeatInterval: "string",
                }],
                repeatInterval: "string",
            }],
            repeatInterval: "string",
        }],
        repeatInterval: "string",
    });
    
    type: grafana:NotificationPolicy
    properties:
        contactPoint: string
        disableProvenance: false
        groupBies:
            - string
        groupInterval: string
        groupWait: string
        orgId: string
        policies:
            - contactPoint: string
              continue: false
              groupBies:
                - string
              groupInterval: string
              groupWait: string
              matchers:
                - label: string
                  match: string
                  value: string
              muteTimings:
                - string
              policies:
                - contactPoint: string
                  continue: false
                  groupBies:
                    - string
                  groupInterval: string
                  groupWait: string
                  matchers:
                    - label: string
                      match: string
                      value: string
                  muteTimings:
                    - string
                  policies:
                    - contactPoint: string
                      continue: false
                      groupBies:
                        - string
                      groupInterval: string
                      groupWait: string
                      matchers:
                        - label: string
                          match: string
                          value: string
                      muteTimings:
                        - string
                      policies:
                        - contactPoint: string
                          continue: false
                          groupBies:
                            - string
                          groupInterval: string
                          groupWait: string
                          matchers:
                            - label: string
                              match: string
                              value: string
                          muteTimings:
                            - string
                          repeatInterval: string
                      repeatInterval: string
                  repeatInterval: string
              repeatInterval: string
        repeatInterval: string
    

    NotificationPolicy Resource Properties

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

    Inputs

    The NotificationPolicy resource accepts the following input properties:

    ContactPoint string
    The contact point to route notifications that match this rule to.
    GroupBies List<string>
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    DisableProvenance bool
    Allow modifying the notification policy from other sources than Terraform or the Grafana API.
    GroupInterval string
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    GroupWait string
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    OrgId string
    The Organization ID. If not set, the Org ID defined in the provider block will be used.
    Policies List<Pulumiverse.Grafana.Inputs.NotificationPolicyPolicy>
    Routing rules for specific label sets.
    RepeatInterval string
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    ContactPoint string
    The contact point to route notifications that match this rule to.
    GroupBies []string
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    DisableProvenance bool
    Allow modifying the notification policy from other sources than Terraform or the Grafana API.
    GroupInterval string
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    GroupWait string
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    OrgId string
    The Organization ID. If not set, the Org ID defined in the provider block will be used.
    Policies []NotificationPolicyPolicyArgs
    Routing rules for specific label sets.
    RepeatInterval string
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contactPoint String
    The contact point to route notifications that match this rule to.
    groupBies List<String>
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    disableProvenance Boolean
    Allow modifying the notification policy from other sources than Terraform or the Grafana API.
    groupInterval String
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    groupWait String
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    orgId String
    The Organization ID. If not set, the Org ID defined in the provider block will be used.
    policies List<NotificationPolicyPolicy>
    Routing rules for specific label sets.
    repeatInterval String
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contactPoint string
    The contact point to route notifications that match this rule to.
    groupBies string[]
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    disableProvenance boolean
    Allow modifying the notification policy from other sources than Terraform or the Grafana API.
    groupInterval string
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    groupWait string
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    orgId string
    The Organization ID. If not set, the Org ID defined in the provider block will be used.
    policies NotificationPolicyPolicy[]
    Routing rules for specific label sets.
    repeatInterval string
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contact_point str
    The contact point to route notifications that match this rule to.
    group_bies Sequence[str]
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    disable_provenance bool
    Allow modifying the notification policy from other sources than Terraform or the Grafana API.
    group_interval str
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    group_wait str
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    org_id str
    The Organization ID. If not set, the Org ID defined in the provider block will be used.
    policies Sequence[NotificationPolicyPolicyArgs]
    Routing rules for specific label sets.
    repeat_interval str
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contactPoint String
    The contact point to route notifications that match this rule to.
    groupBies List<String>
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    disableProvenance Boolean
    Allow modifying the notification policy from other sources than Terraform or the Grafana API.
    groupInterval String
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    groupWait String
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    orgId String
    The Organization ID. If not set, the Org ID defined in the provider block will be used.
    policies List<Property Map>
    Routing rules for specific label sets.
    repeatInterval String
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the NotificationPolicy 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 NotificationPolicy Resource

    Get an existing NotificationPolicy 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?: NotificationPolicyState, opts?: CustomResourceOptions): NotificationPolicy
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            contact_point: Optional[str] = None,
            disable_provenance: Optional[bool] = None,
            group_bies: Optional[Sequence[str]] = None,
            group_interval: Optional[str] = None,
            group_wait: Optional[str] = None,
            org_id: Optional[str] = None,
            policies: Optional[Sequence[NotificationPolicyPolicyArgs]] = None,
            repeat_interval: Optional[str] = None) -> NotificationPolicy
    func GetNotificationPolicy(ctx *Context, name string, id IDInput, state *NotificationPolicyState, opts ...ResourceOption) (*NotificationPolicy, error)
    public static NotificationPolicy Get(string name, Input<string> id, NotificationPolicyState? state, CustomResourceOptions? opts = null)
    public static NotificationPolicy get(String name, Output<String> id, NotificationPolicyState 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:
    ContactPoint string
    The contact point to route notifications that match this rule to.
    DisableProvenance bool
    Allow modifying the notification policy from other sources than Terraform or the Grafana API.
    GroupBies List<string>
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    GroupInterval string
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    GroupWait string
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    OrgId string
    The Organization ID. If not set, the Org ID defined in the provider block will be used.
    Policies List<Pulumiverse.Grafana.Inputs.NotificationPolicyPolicy>
    Routing rules for specific label sets.
    RepeatInterval string
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    ContactPoint string
    The contact point to route notifications that match this rule to.
    DisableProvenance bool
    Allow modifying the notification policy from other sources than Terraform or the Grafana API.
    GroupBies []string
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    GroupInterval string
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    GroupWait string
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    OrgId string
    The Organization ID. If not set, the Org ID defined in the provider block will be used.
    Policies []NotificationPolicyPolicyArgs
    Routing rules for specific label sets.
    RepeatInterval string
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contactPoint String
    The contact point to route notifications that match this rule to.
    disableProvenance Boolean
    Allow modifying the notification policy from other sources than Terraform or the Grafana API.
    groupBies List<String>
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    groupInterval String
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    groupWait String
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    orgId String
    The Organization ID. If not set, the Org ID defined in the provider block will be used.
    policies List<NotificationPolicyPolicy>
    Routing rules for specific label sets.
    repeatInterval String
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contactPoint string
    The contact point to route notifications that match this rule to.
    disableProvenance boolean
    Allow modifying the notification policy from other sources than Terraform or the Grafana API.
    groupBies string[]
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    groupInterval string
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    groupWait string
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    orgId string
    The Organization ID. If not set, the Org ID defined in the provider block will be used.
    policies NotificationPolicyPolicy[]
    Routing rules for specific label sets.
    repeatInterval string
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contact_point str
    The contact point to route notifications that match this rule to.
    disable_provenance bool
    Allow modifying the notification policy from other sources than Terraform or the Grafana API.
    group_bies Sequence[str]
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    group_interval str
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    group_wait str
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    org_id str
    The Organization ID. If not set, the Org ID defined in the provider block will be used.
    policies Sequence[NotificationPolicyPolicyArgs]
    Routing rules for specific label sets.
    repeat_interval str
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contactPoint String
    The contact point to route notifications that match this rule to.
    disableProvenance Boolean
    Allow modifying the notification policy from other sources than Terraform or the Grafana API.
    groupBies List<String>
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    groupInterval String
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    groupWait String
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    orgId String
    The Organization ID. If not set, the Org ID defined in the provider block will be used.
    policies List<Property Map>
    Routing rules for specific label sets.
    repeatInterval String
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

    Supporting Types

    NotificationPolicyPolicy, NotificationPolicyPolicyArgs

    ContactPoint string
    The contact point to route notifications that match this rule to.
    Continue bool
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    GroupBies List<string>
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    GroupInterval string
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    GroupWait string
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    Matchers List<Pulumiverse.Grafana.Inputs.NotificationPolicyPolicyMatcher>
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    MuteTimings List<string>
    A list of mute timing names to apply to alerts that match this policy.
    Policies List<Pulumiverse.Grafana.Inputs.NotificationPolicyPolicyPolicy>
    Routing rules for specific label sets.
    RepeatInterval string
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    ContactPoint string
    The contact point to route notifications that match this rule to.
    Continue bool
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    GroupBies []string
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    GroupInterval string
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    GroupWait string
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    Matchers []NotificationPolicyPolicyMatcher
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    MuteTimings []string
    A list of mute timing names to apply to alerts that match this policy.
    Policies []NotificationPolicyPolicyPolicy
    Routing rules for specific label sets.
    RepeatInterval string
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contactPoint String
    The contact point to route notifications that match this rule to.
    continue_ Boolean
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    groupBies List<String>
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    groupInterval String
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    groupWait String
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    matchers List<NotificationPolicyPolicyMatcher>
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    muteTimings List<String>
    A list of mute timing names to apply to alerts that match this policy.
    policies List<NotificationPolicyPolicyPolicy>
    Routing rules for specific label sets.
    repeatInterval String
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contactPoint string
    The contact point to route notifications that match this rule to.
    continue boolean
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    groupBies string[]
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    groupInterval string
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    groupWait string
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    matchers NotificationPolicyPolicyMatcher[]
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    muteTimings string[]
    A list of mute timing names to apply to alerts that match this policy.
    policies NotificationPolicyPolicyPolicy[]
    Routing rules for specific label sets.
    repeatInterval string
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contact_point str
    The contact point to route notifications that match this rule to.
    continue_ bool
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    group_bies Sequence[str]
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    group_interval str
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    group_wait str
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    matchers Sequence[NotificationPolicyPolicyMatcher]
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    mute_timings Sequence[str]
    A list of mute timing names to apply to alerts that match this policy.
    policies Sequence[NotificationPolicyPolicyPolicy]
    Routing rules for specific label sets.
    repeat_interval str
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contactPoint String
    The contact point to route notifications that match this rule to.
    continue Boolean
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    groupBies List<String>
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    groupInterval String
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    groupWait String
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    matchers List<Property Map>
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    muteTimings List<String>
    A list of mute timing names to apply to alerts that match this policy.
    policies List<Property Map>
    Routing rules for specific label sets.
    repeatInterval String
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

    NotificationPolicyPolicyMatcher, NotificationPolicyPolicyMatcherArgs

    Label string
    The name of the label to match against.
    Match string
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    Value string
    The label value to match against.
    Label string
    The name of the label to match against.
    Match string
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    Value string
    The label value to match against.
    label String
    The name of the label to match against.
    match String
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    value String
    The label value to match against.
    label string
    The name of the label to match against.
    match string
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    value string
    The label value to match against.
    label str
    The name of the label to match against.
    match str
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    value str
    The label value to match against.
    label String
    The name of the label to match against.
    match String
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    value String
    The label value to match against.

    NotificationPolicyPolicyPolicy, NotificationPolicyPolicyPolicyArgs

    ContactPoint string
    The contact point to route notifications that match this rule to.
    Continue bool
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    GroupBies List<string>
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    GroupInterval string
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    GroupWait string
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    Matchers List<Pulumiverse.Grafana.Inputs.NotificationPolicyPolicyPolicyMatcher>
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    MuteTimings List<string>
    A list of mute timing names to apply to alerts that match this policy.
    Policies List<Pulumiverse.Grafana.Inputs.NotificationPolicyPolicyPolicyPolicy>
    Routing rules for specific label sets.
    RepeatInterval string
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    ContactPoint string
    The contact point to route notifications that match this rule to.
    Continue bool
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    GroupBies []string
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    GroupInterval string
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    GroupWait string
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    Matchers []NotificationPolicyPolicyPolicyMatcher
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    MuteTimings []string
    A list of mute timing names to apply to alerts that match this policy.
    Policies []NotificationPolicyPolicyPolicyPolicy
    Routing rules for specific label sets.
    RepeatInterval string
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contactPoint String
    The contact point to route notifications that match this rule to.
    continue_ Boolean
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    groupBies List<String>
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    groupInterval String
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    groupWait String
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    matchers List<NotificationPolicyPolicyPolicyMatcher>
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    muteTimings List<String>
    A list of mute timing names to apply to alerts that match this policy.
    policies List<NotificationPolicyPolicyPolicyPolicy>
    Routing rules for specific label sets.
    repeatInterval String
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contactPoint string
    The contact point to route notifications that match this rule to.
    continue boolean
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    groupBies string[]
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    groupInterval string
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    groupWait string
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    matchers NotificationPolicyPolicyPolicyMatcher[]
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    muteTimings string[]
    A list of mute timing names to apply to alerts that match this policy.
    policies NotificationPolicyPolicyPolicyPolicy[]
    Routing rules for specific label sets.
    repeatInterval string
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contact_point str
    The contact point to route notifications that match this rule to.
    continue_ bool
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    group_bies Sequence[str]
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    group_interval str
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    group_wait str
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    matchers Sequence[NotificationPolicyPolicyPolicyMatcher]
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    mute_timings Sequence[str]
    A list of mute timing names to apply to alerts that match this policy.
    policies Sequence[NotificationPolicyPolicyPolicyPolicy]
    Routing rules for specific label sets.
    repeat_interval str
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contactPoint String
    The contact point to route notifications that match this rule to.
    continue Boolean
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    groupBies List<String>
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    groupInterval String
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    groupWait String
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    matchers List<Property Map>
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    muteTimings List<String>
    A list of mute timing names to apply to alerts that match this policy.
    policies List<Property Map>
    Routing rules for specific label sets.
    repeatInterval String
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

    NotificationPolicyPolicyPolicyMatcher, NotificationPolicyPolicyPolicyMatcherArgs

    Label string
    The name of the label to match against.
    Match string
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    Value string
    The label value to match against.
    Label string
    The name of the label to match against.
    Match string
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    Value string
    The label value to match against.
    label String
    The name of the label to match against.
    match String
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    value String
    The label value to match against.
    label string
    The name of the label to match against.
    match string
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    value string
    The label value to match against.
    label str
    The name of the label to match against.
    match str
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    value str
    The label value to match against.
    label String
    The name of the label to match against.
    match String
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    value String
    The label value to match against.

    NotificationPolicyPolicyPolicyPolicy, NotificationPolicyPolicyPolicyPolicyArgs

    ContactPoint string
    The contact point to route notifications that match this rule to.
    Continue bool
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    GroupBies List<string>
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    GroupInterval string
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    GroupWait string
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    Matchers List<Pulumiverse.Grafana.Inputs.NotificationPolicyPolicyPolicyPolicyMatcher>
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    MuteTimings List<string>
    A list of mute timing names to apply to alerts that match this policy.
    Policies List<Pulumiverse.Grafana.Inputs.NotificationPolicyPolicyPolicyPolicyPolicy>
    Routing rules for specific label sets.
    RepeatInterval string
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    ContactPoint string
    The contact point to route notifications that match this rule to.
    Continue bool
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    GroupBies []string
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    GroupInterval string
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    GroupWait string
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    Matchers []NotificationPolicyPolicyPolicyPolicyMatcher
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    MuteTimings []string
    A list of mute timing names to apply to alerts that match this policy.
    Policies []NotificationPolicyPolicyPolicyPolicyPolicy
    Routing rules for specific label sets.
    RepeatInterval string
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contactPoint String
    The contact point to route notifications that match this rule to.
    continue_ Boolean
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    groupBies List<String>
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    groupInterval String
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    groupWait String
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    matchers List<NotificationPolicyPolicyPolicyPolicyMatcher>
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    muteTimings List<String>
    A list of mute timing names to apply to alerts that match this policy.
    policies List<NotificationPolicyPolicyPolicyPolicyPolicy>
    Routing rules for specific label sets.
    repeatInterval String
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contactPoint string
    The contact point to route notifications that match this rule to.
    continue boolean
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    groupBies string[]
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    groupInterval string
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    groupWait string
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    matchers NotificationPolicyPolicyPolicyPolicyMatcher[]
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    muteTimings string[]
    A list of mute timing names to apply to alerts that match this policy.
    policies NotificationPolicyPolicyPolicyPolicyPolicy[]
    Routing rules for specific label sets.
    repeatInterval string
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contact_point str
    The contact point to route notifications that match this rule to.
    continue_ bool
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    group_bies Sequence[str]
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    group_interval str
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    group_wait str
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    matchers Sequence[NotificationPolicyPolicyPolicyPolicyMatcher]
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    mute_timings Sequence[str]
    A list of mute timing names to apply to alerts that match this policy.
    policies Sequence[NotificationPolicyPolicyPolicyPolicyPolicy]
    Routing rules for specific label sets.
    repeat_interval str
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contactPoint String
    The contact point to route notifications that match this rule to.
    continue Boolean
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    groupBies List<String>
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    groupInterval String
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    groupWait String
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    matchers List<Property Map>
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    muteTimings List<String>
    A list of mute timing names to apply to alerts that match this policy.
    policies List<Property Map>
    Routing rules for specific label sets.
    repeatInterval String
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

    NotificationPolicyPolicyPolicyPolicyMatcher, NotificationPolicyPolicyPolicyPolicyMatcherArgs

    Label string
    The name of the label to match against.
    Match string
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    Value string
    The label value to match against.
    Label string
    The name of the label to match against.
    Match string
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    Value string
    The label value to match against.
    label String
    The name of the label to match against.
    match String
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    value String
    The label value to match against.
    label string
    The name of the label to match against.
    match string
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    value string
    The label value to match against.
    label str
    The name of the label to match against.
    match str
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    value str
    The label value to match against.
    label String
    The name of the label to match against.
    match String
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    value String
    The label value to match against.

    NotificationPolicyPolicyPolicyPolicyPolicy, NotificationPolicyPolicyPolicyPolicyPolicyArgs

    GroupBies List<string>
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    ContactPoint string
    The contact point to route notifications that match this rule to.
    Continue bool
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    GroupInterval string
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    GroupWait string
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    Matchers List<Pulumiverse.Grafana.Inputs.NotificationPolicyPolicyPolicyPolicyPolicyMatcher>
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    MuteTimings List<string>
    A list of mute timing names to apply to alerts that match this policy.
    RepeatInterval string
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    GroupBies []string
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    ContactPoint string
    The contact point to route notifications that match this rule to.
    Continue bool
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    GroupInterval string
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    GroupWait string
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    Matchers []NotificationPolicyPolicyPolicyPolicyPolicyMatcher
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    MuteTimings []string
    A list of mute timing names to apply to alerts that match this policy.
    RepeatInterval string
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    groupBies List<String>
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    contactPoint String
    The contact point to route notifications that match this rule to.
    continue_ Boolean
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    groupInterval String
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    groupWait String
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    matchers List<NotificationPolicyPolicyPolicyPolicyPolicyMatcher>
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    muteTimings List<String>
    A list of mute timing names to apply to alerts that match this policy.
    repeatInterval String
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    groupBies string[]
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    contactPoint string
    The contact point to route notifications that match this rule to.
    continue boolean
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    groupInterval string
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    groupWait string
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    matchers NotificationPolicyPolicyPolicyPolicyPolicyMatcher[]
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    muteTimings string[]
    A list of mute timing names to apply to alerts that match this policy.
    repeatInterval string
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    group_bies Sequence[str]
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    contact_point str
    The contact point to route notifications that match this rule to.
    continue_ bool
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    group_interval str
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    group_wait str
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    matchers Sequence[NotificationPolicyPolicyPolicyPolicyPolicyMatcher]
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    mute_timings Sequence[str]
    A list of mute timing names to apply to alerts that match this policy.
    repeat_interval str
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    groupBies List<String>
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. Required for root policy only. If empty, the parent grouping is used.
    contactPoint String
    The contact point to route notifications that match this rule to.
    continue Boolean
    Whether to continue matching subsequent rules if an alert matches the current rule. Otherwise, the rule will be 'consumed' by the first policy to match it.
    groupInterval String
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    groupWait String
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    matchers List<Property Map>
    Describes which labels this rule should match. When multiple matchers are supplied, an alert must match ALL matchers to be accepted by this policy. When no matchers are supplied, the rule will match all alert instances.
    muteTimings List<String>
    A list of mute timing names to apply to alerts that match this policy.
    repeatInterval String
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

    NotificationPolicyPolicyPolicyPolicyPolicyMatcher, NotificationPolicyPolicyPolicyPolicyPolicyMatcherArgs

    Label string
    The name of the label to match against.
    Match string
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    Value string
    The label value to match against.
    Label string
    The name of the label to match against.
    Match string
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    Value string
    The label value to match against.
    label String
    The name of the label to match against.
    match String
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    value String
    The label value to match against.
    label string
    The name of the label to match against.
    match string
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    value string
    The label value to match against.
    label str
    The name of the label to match against.
    match str
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    value str
    The label value to match against.
    label String
    The name of the label to match against.
    match String
    The operator to apply when matching values of the given label. Allowed operators are = for equality, != for negated equality, =~ for regex equality, and !~ for negated regex equality.
    value String
    The label value to match against.

    Import

    $ pulumi import grafana:index/notificationPolicy:NotificationPolicy name "{{ anyString }}"
    
    $ pulumi import grafana:index/notificationPolicy:NotificationPolicy name "{{ orgID }}:{{ anyString }}"
    

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    grafana pulumiverse/pulumi-grafana
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the grafana Terraform Provider.
    grafana logo
    Grafana v0.5.1 published on Wednesday, Jun 12, 2024 by pulumiverse