grafana.alerting/v1beta1.NotificationsInhibitionRule

import * as pulumi from "@pulumi/pulumi";
import * as grafana from "@pulumiverse/grafana";

const example = new grafana.index.AppsNotificationsInhibitionruleV0alpha1("example", {
    metadata: [{
        uid: "example-inhibition-rule",
    }],
    spec: [{
        sourceMatchers: [{
            type: "=",
            label: "alertname",
            value: "TargetDown",
        }],
        targetMatchers: [{
            type: "=",
            label: "severity",
            value: "warning",
        }],
        equal: [
            "namespace",
            "pod",
        ],
    }],
});

import pulumi
import pulumi_grafana as grafana

example = grafana.index.AppsNotificationsInhibitionruleV0alpha1("example",
    metadata=[{
        uid: example-inhibition-rule,
    }],
    spec=[{
        sourceMatchers: [{
            type: =,
            label: alertname,
            value: TargetDown,
        }],
        targetMatchers: [{
            type: =,
            label: severity,
            value: warning,
        }],
        equal: [
            namespace,
            pod,
        ],
    }])

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-grafana/sdk/v2/go/grafana"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := grafana.NewAppsNotificationsInhibitionruleV0alpha1(ctx, "example", &grafana.AppsNotificationsInhibitionruleV0alpha1Args{
			Metadata: []map[string]interface{}{
				map[string]interface{}{
					"uid": "example-inhibition-rule",
				},
			},
			Spec: []map[string]interface{}{
				map[string]interface{}{
					"sourceMatchers": []map[string]interface{}{
						map[string]interface{}{
							"type":  "=",
							"label": "alertname",
							"value": "TargetDown",
						},
					},
					"targetMatchers": []map[string]interface{}{
						map[string]interface{}{
							"type":  "=",
							"label": "severity",
							"value": "warning",
						},
					},
					"equal": []string{
						"namespace",
						"pod",
					},
				},
			},
		})
		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 example = new Grafana.Index.AppsNotificationsInhibitionruleV0alpha1("example", new()
    {
        Metadata = new[]
        {
            
            {
                { "uid", "example-inhibition-rule" },
            },
        },
        Spec = new[]
        {
            
            {
                { "sourceMatchers", new[]
                {
                    
                    {
                        { "type", "=" },
                        { "label", "alertname" },
                        { "value", "TargetDown" },
                    },
                } },
                { "targetMatchers", new[]
                {
                    
                    {
                        { "type", "=" },
                        { "label", "severity" },
                        { "value", "warning" },
                    },
                } },
                { "equal", new[]
                {
                    "namespace",
                    "pod",
                } },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.grafana.AppsNotificationsInhibitionruleV0alpha1;
import com.pulumi.grafana.AppsNotificationsInhibitionruleV0alpha1Args;
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 example = new AppsNotificationsInhibitionruleV0alpha1("example", AppsNotificationsInhibitionruleV0alpha1Args.builder()
            .metadata(List.of(Map.of("uid", "example-inhibition-rule")))
            .spec(List.of(Map.ofEntries(
                Map.entry("sourceMatchers", List.of(Map.ofEntries(
                    Map.entry("type", "="),
                    Map.entry("label", "alertname"),
                    Map.entry("value", "TargetDown")
                ))),
                Map.entry("targetMatchers", List.of(Map.ofEntries(
                    Map.entry("type", "="),
                    Map.entry("label", "severity"),
                    Map.entry("value", "warning")
                ))),
                Map.entry("equal", List.of(                
                    "namespace",
                    "pod"))
            )))
            .build());

    }
}

resources:
  example:
    type: grafana:AppsNotificationsInhibitionruleV0alpha1
    properties:
      metadata:
        - uid: example-inhibition-rule
      spec:
        - sourceMatchers:
            - type: =
              label: alertname
              value: TargetDown
          targetMatchers:
            - type: =
              label: severity
              value: warning
          equal:
            - namespace
            - pod