grafana.alerting.AlertRuleV0Alpha1

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

const alertruleFolder = new grafana.oss.Folder("alertrule_folder", {title: "Alert Rule Folder"});
const example = new grafana.alerting.AlertRuleV0Alpha1("example", {
    metadata: {
        uid: "example-alert-rule",
        folderUid: alertruleFolder.uid,
    },
    spec: {
        title: "Example Alert Rule",
        trigger: {
            interval: "1m",
        },
        paused: true,
        expressions: {
            A: {
                model: {
                    datasource: {
                        type: "prometheus",
                        uid: "ds_uid",
                    },
                    editorMode: "code",
                    expr: "count(up{})",
                    instant: true,
                    intervalMs: 1000,
                    legendFormat: "__auto",
                    maxDataPoints: 43200,
                    range: false,
                    refId: "A",
                },
                datasourceUid: "ds_uid",
                relativeTimeRange: {
                    from: "600s",
                    to: "0s",
                },
                queryType: "",
                source: true,
            },
            B: {
                model: {
                    conditions: [{
                        evaluator: {
                            params: [1],
                            type: "gt",
                        },
                        operator: {
                            type: "and",
                        },
                        query: {
                            params: ["C"],
                        },
                        reducer: {
                            params: [],
                            type: "last",
                        },
                        type: "query",
                    }],
                    datasource: {
                        type: "__expr__",
                        uid: "__expr__",
                    },
                    expression: "A",
                    intervalMs: 1000,
                    maxDataPoints: 43200,
                    refId: "C",
                    type: "threshold",
                },
                datasourceUid: "__expr__",
                queryType: "",
                source: false,
            },
        },
        "for": "5m",
        labels: {
            severity: "critical",
        },
        annotations: {
            runbook_url: "https://example.com",
        },
        noDataState: "KeepLast",
        execErrState: "KeepLast",
        missingSeriesEvalsToResolve: 5,
        notificationSettings: {
            contactPoint: "grafana-default-email",
        },
    },
});

import pulumi
import pulumiverse_grafana as grafana

alertrule_folder = grafana.oss.Folder("alertrule_folder", title="Alert Rule Folder")
example = grafana.alerting.AlertRuleV0Alpha1("example",
    metadata={
        "uid": "example-alert-rule",
        "folder_uid": alertrule_folder.uid,
    },
    spec={
        "title": "Example Alert Rule",
        "trigger": {
            "interval": "1m",
        },
        "paused": True,
        "expressions": {
            "A": {
                "model": {
                    "datasource": {
                        "type": "prometheus",
                        "uid": "ds_uid",
                    },
                    "editorMode": "code",
                    "expr": "count(up{})",
                    "instant": True,
                    "intervalMs": 1000,
                    "legendFormat": "__auto",
                    "maxDataPoints": 43200,
                    "range": False,
                    "refId": "A",
                },
                "datasourceUid": "ds_uid",
                "relativeTimeRange": {
                    "from": "600s",
                    "to": "0s",
                },
                "queryType": "",
                "source": True,
            },
            "B": {
                "model": {
                    "conditions": [{
                        "evaluator": {
                            "params": [1],
                            "type": "gt",
                        },
                        "operator": {
                            "type": "and",
                        },
                        "query": {
                            "params": ["C"],
                        },
                        "reducer": {
                            "params": [],
                            "type": "last",
                        },
                        "type": "query",
                    }],
                    "datasource": {
                        "type": "__expr__",
                        "uid": "__expr__",
                    },
                    "expression": "A",
                    "intervalMs": 1000,
                    "maxDataPoints": 43200,
                    "refId": "C",
                    "type": "threshold",
                },
                "datasourceUid": "__expr__",
                "queryType": "",
                "source": False,
            },
        },
        "for_": "5m",
        "labels": {
            "severity": "critical",
        },
        "annotations": {
            "runbook_url": "https://example.com",
        },
        "no_data_state": "KeepLast",
        "exec_err_state": "KeepLast",
        "missing_series_evals_to_resolve": 5,
        "notification_settings": {
            "contact_point": "grafana-default-email",
        },
    })

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		alertruleFolder, err := oss.NewFolder(ctx, "alertrule_folder", &oss.FolderArgs{
			Title: pulumi.String("Alert Rule Folder"),
		})
		if err != nil {
			return err
		}
		_, err = alerting.NewAlertRuleV0Alpha1(ctx, "example", &alerting.AlertRuleV0Alpha1Args{
			Metadata: &alerting.AlertRuleV0Alpha1MetadataArgs{
				Uid:       pulumi.String("example-alert-rule"),
				FolderUid: alertruleFolder.Uid,
			},
			Spec: &alerting.AlertRuleV0Alpha1SpecArgs{
				Title: pulumi.String("Example Alert Rule"),
				Trigger: &alerting.AlertRuleV0Alpha1SpecTriggerArgs{
					Interval: pulumi.String("1m"),
				},
				Paused: pulumi.Bool(true),
				Expressions: pulumi.Any(map[string]interface{}{
					"A": map[string]interface{}{
						"model": map[string]interface{}{
							"datasource": map[string]interface{}{
								"type": "prometheus",
								"uid":  "ds_uid",
							},
							"editorMode":    "code",
							"expr":          "count(up{})",
							"instant":       true,
							"intervalMs":    1000,
							"legendFormat":  "__auto",
							"maxDataPoints": 43200,
							"range":         false,
							"refId":         "A",
						},
						"datasourceUid": "ds_uid",
						"relativeTimeRange": map[string]interface{}{
							"from": "600s",
							"to":   "0s",
						},
						"queryType": "",
						"source":    true,
					},
					"B": map[string]interface{}{
						"model": map[string]interface{}{
							"conditions": []map[string]interface{}{
								map[string]interface{}{
									"evaluator": map[string]interface{}{
										"params": []float64{
											1,
										},
										"type": "gt",
									},
									"operator": map[string]interface{}{
										"type": "and",
									},
									"query": map[string]interface{}{
										"params": []string{
											"C",
										},
									},
									"reducer": map[string]interface{}{
										"params": []interface{}{},
										"type":   "last",
									},
									"type": "query",
								},
							},
							"datasource": map[string]interface{}{
								"type": "__expr__",
								"uid":  "__expr__",
							},
							"expression":    "A",
							"intervalMs":    1000,
							"maxDataPoints": 43200,
							"refId":         "C",
							"type":          "threshold",
						},
						"datasourceUid": "__expr__",
						"queryType":     "",
						"source":        false,
					},
				}),
				For: pulumi.String("5m"),
				Labels: pulumi.StringMap{
					"severity": pulumi.String("critical"),
				},
				Annotations: pulumi.StringMap{
					"runbook_url": pulumi.String("https://example.com"),
				},
				NoDataState:                 pulumi.String("KeepLast"),
				ExecErrState:                pulumi.String("KeepLast"),
				MissingSeriesEvalsToResolve: pulumi.Int(5),
				NotificationSettings: &alerting.AlertRuleV0Alpha1SpecNotificationSettingsArgs{
					ContactPoint: pulumi.String("grafana-default-email"),
				},
			},
		})
		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 alertruleFolder = new Grafana.Oss.Folder("alertrule_folder", new()
    {
        Title = "Alert Rule Folder",
    });

    var example = new Grafana.Alerting.AlertRuleV0Alpha1("example", new()
    {
        Metadata = new Grafana.Alerting.Inputs.AlertRuleV0Alpha1MetadataArgs
        {
            Uid = "example-alert-rule",
            FolderUid = alertruleFolder.Uid,
        },
        Spec = new Grafana.Alerting.Inputs.AlertRuleV0Alpha1SpecArgs
        {
            Title = "Example Alert Rule",
            Trigger = new Grafana.Alerting.Inputs.AlertRuleV0Alpha1SpecTriggerArgs
            {
                Interval = "1m",
            },
            Paused = true,
            Expressions = new Dictionary<string, object?>
            {
                ["A"] = new Dictionary<string, object?>
                {
                    ["model"] = new Dictionary<string, object?>
                    {
                        ["datasource"] = new Dictionary<string, object?>
                        {
                            ["type"] = "prometheus",
                            ["uid"] = "ds_uid",
                        },
                        ["editorMode"] = "code",
                        ["expr"] = "count(up{})",
                        ["instant"] = true,
                        ["intervalMs"] = 1000,
                        ["legendFormat"] = "__auto",
                        ["maxDataPoints"] = 43200,
                        ["range"] = false,
                        ["refId"] = "A",
                    },
                    ["datasourceUid"] = "ds_uid",
                    ["relativeTimeRange"] = new Dictionary<string, object?>
                    {
                        ["from"] = "600s",
                        ["to"] = "0s",
                    },
                    ["queryType"] = "",
                    ["source"] = true,
                },
                ["B"] = new Dictionary<string, object?>
                {
                    ["model"] = new Dictionary<string, object?>
                    {
                        ["conditions"] = new[]
                        {
                            new Dictionary<string, object?>
                            {
                                ["evaluator"] = new Dictionary<string, object?>
                                {
                                    ["params"] = new[]
                                    {
                                        1,
                                    },
                                    ["type"] = "gt",
                                },
                                ["operator"] = new Dictionary<string, object?>
                                {
                                    ["type"] = "and",
                                },
                                ["query"] = new Dictionary<string, object?>
                                {
                                    ["params"] = new[]
                                    {
                                        "C",
                                    },
                                },
                                ["reducer"] = new Dictionary<string, object?>
                                {
                                    ["params"] = new[]
                                    {
                                    },
                                    ["type"] = "last",
                                },
                                ["type"] = "query",
                            },
                        },
                        ["datasource"] = new Dictionary<string, object?>
                        {
                            ["type"] = "__expr__",
                            ["uid"] = "__expr__",
                        },
                        ["expression"] = "A",
                        ["intervalMs"] = 1000,
                        ["maxDataPoints"] = 43200,
                        ["refId"] = "C",
                        ["type"] = "threshold",
                    },
                    ["datasourceUid"] = "__expr__",
                    ["queryType"] = "",
                    ["source"] = false,
                },
            },
            For = "5m",
            Labels = 
            {
                { "severity", "critical" },
            },
            Annotations = 
            {
                { "runbook_url", "https://example.com" },
            },
            NoDataState = "KeepLast",
            ExecErrState = "KeepLast",
            MissingSeriesEvalsToResolve = 5,
            NotificationSettings = new Grafana.Alerting.Inputs.AlertRuleV0Alpha1SpecNotificationSettingsArgs
            {
                ContactPoint = "grafana-default-email",
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.grafana.oss.Folder;
import com.pulumi.grafana.oss.FolderArgs;
import com.pulumi.grafana.alerting.AlertRuleV0Alpha1;
import com.pulumi.grafana.alerting.AlertRuleV0Alpha1Args;
import com.pulumi.grafana.alerting.inputs.AlertRuleV0Alpha1MetadataArgs;
import com.pulumi.grafana.alerting.inputs.AlertRuleV0Alpha1SpecArgs;
import com.pulumi.grafana.alerting.inputs.AlertRuleV0Alpha1SpecTriggerArgs;
import com.pulumi.grafana.alerting.inputs.AlertRuleV0Alpha1SpecNotificationSettingsArgs;
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 alertruleFolder = new Folder("alertruleFolder", FolderArgs.builder()
            .title("Alert Rule Folder")
            .build());

        var example = new AlertRuleV0Alpha1("example", AlertRuleV0Alpha1Args.builder()
            .metadata(AlertRuleV0Alpha1MetadataArgs.builder()
                .uid("example-alert-rule")
                .folderUid(alertruleFolder.uid())
                .build())
            .spec(AlertRuleV0Alpha1SpecArgs.builder()
                .title("Example Alert Rule")
                .trigger(AlertRuleV0Alpha1SpecTriggerArgs.builder()
                    .interval("1m")
                    .build())
                .paused(true)
                .expressions(Map.ofEntries(
                    Map.entry("A", Map.ofEntries(
                        Map.entry("model", Map.ofEntries(
                            Map.entry("datasource", Map.ofEntries(
                                Map.entry("type", "prometheus"),
                                Map.entry("uid", "ds_uid")
                            )),
                            Map.entry("editorMode", "code"),
                            Map.entry("expr", "count(up{})"),
                            Map.entry("instant", true),
                            Map.entry("intervalMs", 1000),
                            Map.entry("legendFormat", "__auto"),
                            Map.entry("maxDataPoints", 43200),
                            Map.entry("range", false),
                            Map.entry("refId", "A")
                        )),
                        Map.entry("datasourceUid", "ds_uid"),
                        Map.entry("relativeTimeRange", Map.ofEntries(
                            Map.entry("from", "600s"),
                            Map.entry("to", "0s")
                        )),
                        Map.entry("queryType", ""),
                        Map.entry("source", true)
                    )),
                    Map.entry("B", Map.ofEntries(
                        Map.entry("model", Map.ofEntries(
                            Map.entry("conditions", Map.ofEntries(
                                Map.entry("evaluator", Map.ofEntries(
                                    Map.entry("params", 1),
                                    Map.entry("type", "gt")
                                )),
                                Map.entry("operator", Map.of("type", "and")),
                                Map.entry("query", Map.of("params", "C")),
                                Map.entry("reducer", Map.ofEntries(
                                    Map.entry("params", ),
                                    Map.entry("type", "last")
                                )),
                                Map.entry("type", "query")
                            )),
                            Map.entry("datasource", Map.ofEntries(
                                Map.entry("type", "__expr__"),
                                Map.entry("uid", "__expr__")
                            )),
                            Map.entry("expression", "A"),
                            Map.entry("intervalMs", 1000),
                            Map.entry("maxDataPoints", 43200),
                            Map.entry("refId", "C"),
                            Map.entry("type", "threshold")
                        )),
                        Map.entry("datasourceUid", "__expr__"),
                        Map.entry("queryType", ""),
                        Map.entry("source", false)
                    ))
                ))
                .for_("5m")
                .labels(Map.of("severity", "critical"))
                .annotations(Map.of("runbook_url", "https://example.com"))
                .noDataState("KeepLast")
                .execErrState("KeepLast")
                .missingSeriesEvalsToResolve(5)
                .notificationSettings(AlertRuleV0Alpha1SpecNotificationSettingsArgs.builder()
                    .contactPoint("grafana-default-email")
                    .build())
                .build())
            .build());

    }
}

resources:
  alertruleFolder:
    type: grafana:oss:Folder
    name: alertrule_folder
    properties:
      title: Alert Rule Folder
  example:
    type: grafana:alerting:AlertRuleV0Alpha1
    properties:
      metadata:
        uid: example-alert-rule
        folderUid: ${alertruleFolder.uid}
      spec:
        title: Example Alert Rule
        trigger:
          interval: 1m
        paused: true
        expressions:
          A:
            model:
              datasource:
                type: prometheus
                uid: ds_uid
              editorMode: code
              expr: count(up{})
              instant: true
              intervalMs: 1000
              legendFormat: __auto
              maxDataPoints: 43200
              range: false
              refId: A
            datasourceUid: ds_uid
            relativeTimeRange:
              from: 600s
              to: 0s
            queryType: ""
            source: true
          B:
            model:
              conditions:
                - evaluator:
                    params:
                      - 1
                    type: gt
                  operator:
                    type: and
                  query:
                    params:
                      - C
                  reducer:
                    params: []
                    type: last
                  type: query
              datasource:
                type: __expr__
                uid: __expr__
              expression: A
              intervalMs: 1000
              maxDataPoints: 43200
              refId: C
              type: threshold
            datasourceUid: __expr__
            queryType: ""
            source: false
        for: 5m
        labels:
          severity: critical
        annotations:
          runbook_url: https://example.com
        noDataState: KeepLast
        execErrState: KeepLast
        missingSeriesEvalsToResolve: 5
        notificationSettings:
          contactPoint: grafana-default-email

var alertRuleV0Alpha1Resource = new Grafana.Alerting.AlertRuleV0Alpha1("alertRuleV0Alpha1Resource", new()
{
    Metadata = new Grafana.Alerting.Inputs.AlertRuleV0Alpha1MetadataArgs
    {
        Uid = "string",
        Annotations = 
        {
            { "string", "string" },
        },
        FolderUid = "string",
        Url = "string",
        Uuid = "string",
        Version = "string",
    },
    Options = new Grafana.Alerting.Inputs.AlertRuleV0Alpha1OptionsArgs
    {
        Overwrite = false,
    },
    Spec = new Grafana.Alerting.Inputs.AlertRuleV0Alpha1SpecArgs
    {
        NoDataState = "string",
        ExecErrState = "string",
        Expressions = "any",
        Title = "string",
        MissingSeriesEvalsToResolve = 0,
        Labels = 
        {
            { "string", "string" },
        },
        Annotations = 
        {
            { "string", "string" },
        },
        KeepFiringFor = "string",
        NotificationSettings = new Grafana.Alerting.Inputs.AlertRuleV0Alpha1SpecNotificationSettingsArgs
        {
            ContactPoint = "string",
            ActiveTimings = new[]
            {
                "string",
            },
            GroupBies = new[]
            {
                "string",
            },
            GroupInterval = "string",
            GroupWait = "string",
            MuteTimings = new[]
            {
                "string",
            },
            RepeatInterval = "string",
        },
        PanelRef = "any",
        Paused = false,
        For = "string",
        Trigger = new Grafana.Alerting.Inputs.AlertRuleV0Alpha1SpecTriggerArgs
        {
            Interval = "string",
        },
    },
});

example, err := alerting.NewAlertRuleV0Alpha1(ctx, "alertRuleV0Alpha1Resource", &alerting.AlertRuleV0Alpha1Args{
	Metadata: &alerting.AlertRuleV0Alpha1MetadataArgs{
		Uid: pulumi.String("string"),
		Annotations: pulumi.StringMap{
			"string": pulumi.String("string"),
		},
		FolderUid: pulumi.String("string"),
		Url:       pulumi.String("string"),
		Uuid:      pulumi.String("string"),
		Version:   pulumi.String("string"),
	},
	Options: &alerting.AlertRuleV0Alpha1OptionsArgs{
		Overwrite: pulumi.Bool(false),
	},
	Spec: &alerting.AlertRuleV0Alpha1SpecArgs{
		NoDataState:                 pulumi.String("string"),
		ExecErrState:                pulumi.String("string"),
		Expressions:                 pulumi.Any("any"),
		Title:                       pulumi.String("string"),
		MissingSeriesEvalsToResolve: pulumi.Int(0),
		Labels: pulumi.StringMap{
			"string": pulumi.String("string"),
		},
		Annotations: pulumi.StringMap{
			"string": pulumi.String("string"),
		},
		KeepFiringFor: pulumi.String("string"),
		NotificationSettings: &alerting.AlertRuleV0Alpha1SpecNotificationSettingsArgs{
			ContactPoint: pulumi.String("string"),
			ActiveTimings: pulumi.StringArray{
				pulumi.String("string"),
			},
			GroupBies: pulumi.StringArray{
				pulumi.String("string"),
			},
			GroupInterval: pulumi.String("string"),
			GroupWait:     pulumi.String("string"),
			MuteTimings: pulumi.StringArray{
				pulumi.String("string"),
			},
			RepeatInterval: pulumi.String("string"),
		},
		PanelRef: pulumi.Any("any"),
		Paused:   pulumi.Bool(false),
		For:      pulumi.String("string"),
		Trigger: &alerting.AlertRuleV0Alpha1SpecTriggerArgs{
			Interval: pulumi.String("string"),
		},
	},
})

var alertRuleV0Alpha1Resource = new AlertRuleV0Alpha1("alertRuleV0Alpha1Resource", AlertRuleV0Alpha1Args.builder()
    .metadata(AlertRuleV0Alpha1MetadataArgs.builder()
        .uid("string")
        .annotations(Map.of("string", "string"))
        .folderUid("string")
        .url("string")
        .uuid("string")
        .version("string")
        .build())
    .options(AlertRuleV0Alpha1OptionsArgs.builder()
        .overwrite(false)
        .build())
    .spec(AlertRuleV0Alpha1SpecArgs.builder()
        .noDataState("string")
        .execErrState("string")
        .expressions("any")
        .title("string")
        .missingSeriesEvalsToResolve(0)
        .labels(Map.of("string", "string"))
        .annotations(Map.of("string", "string"))
        .keepFiringFor("string")
        .notificationSettings(AlertRuleV0Alpha1SpecNotificationSettingsArgs.builder()
            .contactPoint("string")
            .activeTimings("string")
            .groupBies("string")
            .groupInterval("string")
            .groupWait("string")
            .muteTimings("string")
            .repeatInterval("string")
            .build())
        .panelRef("any")
        .paused(false)
        .for_("string")
        .trigger(AlertRuleV0Alpha1SpecTriggerArgs.builder()
            .interval("string")
            .build())
        .build())
    .build());

alert_rule_v0_alpha1_resource = grafana.alerting.AlertRuleV0Alpha1("alertRuleV0Alpha1Resource",
    metadata={
        "uid": "string",
        "annotations": {
            "string": "string",
        },
        "folder_uid": "string",
        "url": "string",
        "uuid": "string",
        "version": "string",
    },
    options={
        "overwrite": False,
    },
    spec={
        "no_data_state": "string",
        "exec_err_state": "string",
        "expressions": "any",
        "title": "string",
        "missing_series_evals_to_resolve": 0,
        "labels": {
            "string": "string",
        },
        "annotations": {
            "string": "string",
        },
        "keep_firing_for": "string",
        "notification_settings": {
            "contact_point": "string",
            "active_timings": ["string"],
            "group_bies": ["string"],
            "group_interval": "string",
            "group_wait": "string",
            "mute_timings": ["string"],
            "repeat_interval": "string",
        },
        "panel_ref": "any",
        "paused": False,
        "for_": "string",
        "trigger": {
            "interval": "string",
        },
    })

const alertRuleV0Alpha1Resource = new grafana.alerting.AlertRuleV0Alpha1("alertRuleV0Alpha1Resource", {
    metadata: {
        uid: "string",
        annotations: {
            string: "string",
        },
        folderUid: "string",
        url: "string",
        uuid: "string",
        version: "string",
    },
    options: {
        overwrite: false,
    },
    spec: {
        noDataState: "string",
        execErrState: "string",
        expressions: "any",
        title: "string",
        missingSeriesEvalsToResolve: 0,
        labels: {
            string: "string",
        },
        annotations: {
            string: "string",
        },
        keepFiringFor: "string",
        notificationSettings: {
            contactPoint: "string",
            activeTimings: ["string"],
            groupBies: ["string"],
            groupInterval: "string",
            groupWait: "string",
            muteTimings: ["string"],
            repeatInterval: "string",
        },
        panelRef: "any",
        paused: false,
        "for": "string",
        trigger: {
            interval: "string",
        },
    },
});

type: grafana:alerting:AlertRuleV0Alpha1
properties:
    metadata:
        annotations:
            string: string
        folderUid: string
        uid: string
        url: string
        uuid: string
        version: string
    options:
        overwrite: false
    spec:
        annotations:
            string: string
        execErrState: string
        expressions: any
        for: string
        keepFiringFor: string
        labels:
            string: string
        missingSeriesEvalsToResolve: 0
        noDataState: string
        notificationSettings:
            activeTimings:
                - string
            contactPoint: string
            groupBies:
                - string
            groupInterval: string
            groupWait: string
            muteTimings:
                - string
            repeatInterval: string
        panelRef: any
        paused: false
        title: string
        trigger:
            interval: string