ruleGroup.go

// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT.
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***

package grafana

import (
	"context"
	"reflect"

	"errors"
	"github.com/lbrlabs/pulumi-grafana/sdk/go/grafana/internal"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumix"
)

// Manages Grafana Alerting rule groups.
//
// * [Official documentation](https://grafana.com/docs/grafana/latest/alerting/alerting-rules/)
// * [HTTP API](https://grafana.com/docs/grafana/latest/developers/http_api/alerting_provisioning/#alert-rules)
//
// This resource requires Grafana 9.1.0 or later.
//
// ## Example Usage
//
// ```go
// package main
//
// import (
//
//	"encoding/json"
//
//	"github.com/lbrlabs/pulumi-grafana/sdk/go/grafana"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			ruleFolder, err := grafana.NewFolder(ctx, "ruleFolder", &grafana.FolderArgs{
//				Title: pulumi.String("My Alert Rule Folder"),
//			})
//			if err != nil {
//				return err
//			}
//			tmpJSON0, err := json.Marshal(map[string]interface{}{
//				"hide":          false,
//				"intervalMs":    1000,
//				"maxDataPoints": 43200,
//				"refId":         "A",
//			})
//			if err != nil {
//				return err
//			}
//			json0 := string(tmpJSON0)
//			_, err = grafana.NewRuleGroup(ctx, "myAlertRule", &grafana.RuleGroupArgs{
//				FolderUid:       ruleFolder.Uid,
//				IntervalSeconds: pulumi.Int(240),
//				OrgId:           pulumi.String("1"),
//				Rules: grafana.RuleGroupRuleArray{
//					&grafana.RuleGroupRuleArgs{
//						Name:         pulumi.String("My Alert Rule 1"),
//						For:          pulumi.String("2m"),
//						Condition:    pulumi.String("B"),
//						NoDataState:  pulumi.String("NoData"),
//						ExecErrState: pulumi.String("Alerting"),
//						Annotations: pulumi.StringMap{
//							"a": pulumi.String("b"),
//							"c": pulumi.String("d"),
//						},
//						Labels: pulumi.StringMap{
//							"e": pulumi.String("f"),
//							"g": pulumi.String("h"),
//						},
//						IsPaused: pulumi.Bool(false),
//						Datas: grafana.RuleGroupRuleDataArray{
//							&grafana.RuleGroupRuleDataArgs{
//								RefId:     pulumi.String("A"),
//								QueryType: pulumi.String(""),
//								RelativeTimeRange: &grafana.RuleGroupRuleDataRelativeTimeRangeArgs{
//									From: pulumi.Int(600),
//									To:   pulumi.Int(0),
//								},
//								DatasourceUid: pulumi.String("PD8C576611E62080A"),
//								Model:         pulumi.String(json0),
//							},
//							&grafana.RuleGroupRuleDataArgs{
//								RefId:     pulumi.String("B"),
//								QueryType: pulumi.String(""),
//								RelativeTimeRange: &grafana.RuleGroupRuleDataRelativeTimeRangeArgs{
//									From: pulumi.Int(0),
//									To:   pulumi.Int(0),
//								},
//								DatasourceUid: pulumi.String("-100"),
//								Model: pulumi.String(`{
//	    "conditions": [
//	        {
//	        "evaluator": {
//	            "params": [
//	            3
//	            ],
//	            "type": "gt"
//	        },
//	        "operator": {
//	            "type": "and"
//	        },
//	        "query": {
//	            "params": [
//	            "A"
//	            ]
//	        },
//	        "reducer": {
//	            "params": [],
//	            "type": "last"
//	        },
//	        "type": "query"
//	        }
//	    ],
//	    "datasource": {
//	        "type": "__expr__",
//	        "uid": "-100"
//	    },
//	    "hide": false,
//	    "intervalMs": 1000,
//	    "maxDataPoints": 43200,
//	    "refId": "B",
//	    "type": "classic_conditions"
//	}
//
// `),
//
//							},
//						},
//					},
//				},
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
//
// ## Import
//
// ```sh
//
//	$ pulumi import grafana:index/ruleGroup:RuleGroup rule_group_name {{folder_uid}};{{rule_group_name}}
//
// ```
type RuleGroup struct {
	pulumi.CustomResourceState

	// The UID of the folder that the group belongs to.
	FolderUid pulumi.StringOutput `pulumi:"folderUid"`
	// The interval, in seconds, at which all rules in the group are evaluated. If a group contains many rules, the rules are evaluated sequentially.
	IntervalSeconds pulumi.IntOutput `pulumi:"intervalSeconds"`
	// The name of the alert rule.
	Name pulumi.StringOutput `pulumi:"name"`
	// The ID of the org to which the group belongs.
	OrgId pulumi.StringOutput `pulumi:"orgId"`
	// The rules within the group.
	Rules RuleGroupRuleArrayOutput `pulumi:"rules"`
}

// NewRuleGroup registers a new resource with the given unique name, arguments, and options.
func NewRuleGroup(ctx *pulumi.Context,
	name string, args *RuleGroupArgs, opts ...pulumi.ResourceOption) (*RuleGroup, error) {
	if args == nil {
		return nil, errors.New("missing one or more required arguments")
	}

	if args.FolderUid == nil {
		return nil, errors.New("invalid value for required argument 'FolderUid'")
	}
	if args.IntervalSeconds == nil {
		return nil, errors.New("invalid value for required argument 'IntervalSeconds'")
	}
	if args.OrgId == nil {
		return nil, errors.New("invalid value for required argument 'OrgId'")
	}
	if args.Rules == nil {
		return nil, errors.New("invalid value for required argument 'Rules'")
	}
	opts = internal.PkgResourceDefaultOpts(opts)
	var resource RuleGroup
	err := ctx.RegisterResource("grafana:index/ruleGroup:RuleGroup", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// GetRuleGroup gets an existing RuleGroup resource's state with the given name, ID, and optional
// state properties that are used to uniquely qualify the lookup (nil if not required).
func GetRuleGroup(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RuleGroupState, opts ...pulumi.ResourceOption) (*RuleGroup, error) {
	var resource RuleGroup
	err := ctx.ReadResource("grafana:index/ruleGroup:RuleGroup", name, id, state, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// Input properties used for looking up and filtering RuleGroup resources.
type ruleGroupState struct {
	// The UID of the folder that the group belongs to.
	FolderUid *string `pulumi:"folderUid"`
	// The interval, in seconds, at which all rules in the group are evaluated. If a group contains many rules, the rules are evaluated sequentially.
	IntervalSeconds *int `pulumi:"intervalSeconds"`
	// The name of the alert rule.
	Name *string `pulumi:"name"`
	// The ID of the org to which the group belongs.
	OrgId *string `pulumi:"orgId"`
	// The rules within the group.
	Rules []RuleGroupRule `pulumi:"rules"`
}

type RuleGroupState struct {
	// The UID of the folder that the group belongs to.
	FolderUid pulumi.StringPtrInput
	// The interval, in seconds, at which all rules in the group are evaluated. If a group contains many rules, the rules are evaluated sequentially.
	IntervalSeconds pulumi.IntPtrInput
	// The name of the alert rule.
	Name pulumi.StringPtrInput
	// The ID of the org to which the group belongs.
	OrgId pulumi.StringPtrInput
	// The rules within the group.
	Rules RuleGroupRuleArrayInput
}

func (RuleGroupState) ElementType() reflect.Type {
	return reflect.TypeOf((*ruleGroupState)(nil)).Elem()
}

type ruleGroupArgs struct {
	// The UID of the folder that the group belongs to.
	FolderUid string `pulumi:"folderUid"`
	// The interval, in seconds, at which all rules in the group are evaluated. If a group contains many rules, the rules are evaluated sequentially.
	IntervalSeconds int `pulumi:"intervalSeconds"`
	// The name of the alert rule.
	Name *string `pulumi:"name"`
	// The ID of the org to which the group belongs.
	OrgId string `pulumi:"orgId"`
	// The rules within the group.
	Rules []RuleGroupRule `pulumi:"rules"`
}

// The set of arguments for constructing a RuleGroup resource.
type RuleGroupArgs struct {
	// The UID of the folder that the group belongs to.
	FolderUid pulumi.StringInput
	// The interval, in seconds, at which all rules in the group are evaluated. If a group contains many rules, the rules are evaluated sequentially.
	IntervalSeconds pulumi.IntInput
	// The name of the alert rule.
	Name pulumi.StringPtrInput
	// The ID of the org to which the group belongs.
	OrgId pulumi.StringInput
	// The rules within the group.
	Rules RuleGroupRuleArrayInput
}

func (RuleGroupArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ruleGroupArgs)(nil)).Elem()
}

type RuleGroupInput interface {
	pulumi.Input

	ToRuleGroupOutput() RuleGroupOutput
	ToRuleGroupOutputWithContext(ctx context.Context) RuleGroupOutput
}

func (*RuleGroup) ElementType() reflect.Type {
	return reflect.TypeOf((**RuleGroup)(nil)).Elem()
}

func (i *RuleGroup) ToRuleGroupOutput() RuleGroupOutput {
	return i.ToRuleGroupOutputWithContext(context.Background())
}

func (i *RuleGroup) ToRuleGroupOutputWithContext(ctx context.Context) RuleGroupOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RuleGroupOutput)
}

func (i *RuleGroup) ToOutput(ctx context.Context) pulumix.Output[*RuleGroup] {
	return pulumix.Output[*RuleGroup]{
		OutputState: i.ToRuleGroupOutputWithContext(ctx).OutputState,
	}
}

// RuleGroupArrayInput is an input type that accepts RuleGroupArray and RuleGroupArrayOutput values.
// You can construct a concrete instance of `RuleGroupArrayInput` via:
//
//	RuleGroupArray{ RuleGroupArgs{...} }
type RuleGroupArrayInput interface {
	pulumi.Input

	ToRuleGroupArrayOutput() RuleGroupArrayOutput
	ToRuleGroupArrayOutputWithContext(context.Context) RuleGroupArrayOutput
}

type RuleGroupArray []RuleGroupInput

func (RuleGroupArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]*RuleGroup)(nil)).Elem()
}

func (i RuleGroupArray) ToRuleGroupArrayOutput() RuleGroupArrayOutput {
	return i.ToRuleGroupArrayOutputWithContext(context.Background())
}

func (i RuleGroupArray) ToRuleGroupArrayOutputWithContext(ctx context.Context) RuleGroupArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RuleGroupArrayOutput)
}

func (i RuleGroupArray) ToOutput(ctx context.Context) pulumix.Output[[]*RuleGroup] {
	return pulumix.Output[[]*RuleGroup]{
		OutputState: i.ToRuleGroupArrayOutputWithContext(ctx).OutputState,
	}
}

// RuleGroupMapInput is an input type that accepts RuleGroupMap and RuleGroupMapOutput values.
// You can construct a concrete instance of `RuleGroupMapInput` via:
//
//	RuleGroupMap{ "key": RuleGroupArgs{...} }
type RuleGroupMapInput interface {
	pulumi.Input

	ToRuleGroupMapOutput() RuleGroupMapOutput
	ToRuleGroupMapOutputWithContext(context.Context) RuleGroupMapOutput
}

type RuleGroupMap map[string]RuleGroupInput

func (RuleGroupMap) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]*RuleGroup)(nil)).Elem()
}

func (i RuleGroupMap) ToRuleGroupMapOutput() RuleGroupMapOutput {
	return i.ToRuleGroupMapOutputWithContext(context.Background())
}

func (i RuleGroupMap) ToRuleGroupMapOutputWithContext(ctx context.Context) RuleGroupMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RuleGroupMapOutput)
}

func (i RuleGroupMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*RuleGroup] {
	return pulumix.Output[map[string]*RuleGroup]{
		OutputState: i.ToRuleGroupMapOutputWithContext(ctx).OutputState,
	}
}

type RuleGroupOutput struct{ *pulumi.OutputState }

func (RuleGroupOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**RuleGroup)(nil)).Elem()
}

func (o RuleGroupOutput) ToRuleGroupOutput() RuleGroupOutput {
	return o
}

func (o RuleGroupOutput) ToRuleGroupOutputWithContext(ctx context.Context) RuleGroupOutput {
	return o
}

func (o RuleGroupOutput) ToOutput(ctx context.Context) pulumix.Output[*RuleGroup] {
	return pulumix.Output[*RuleGroup]{
		OutputState: o.OutputState,
	}
}

// The UID of the folder that the group belongs to.
func (o RuleGroupOutput) FolderUid() pulumi.StringOutput {
	return o.ApplyT(func(v *RuleGroup) pulumi.StringOutput { return v.FolderUid }).(pulumi.StringOutput)
}

// The interval, in seconds, at which all rules in the group are evaluated. If a group contains many rules, the rules are evaluated sequentially.
func (o RuleGroupOutput) IntervalSeconds() pulumi.IntOutput {
	return o.ApplyT(func(v *RuleGroup) pulumi.IntOutput { return v.IntervalSeconds }).(pulumi.IntOutput)
}

// The name of the alert rule.
func (o RuleGroupOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v *RuleGroup) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput)
}

// The ID of the org to which the group belongs.
func (o RuleGroupOutput) OrgId() pulumi.StringOutput {
	return o.ApplyT(func(v *RuleGroup) pulumi.StringOutput { return v.OrgId }).(pulumi.StringOutput)
}

// The rules within the group.
func (o RuleGroupOutput) Rules() RuleGroupRuleArrayOutput {
	return o.ApplyT(func(v *RuleGroup) RuleGroupRuleArrayOutput { return v.Rules }).(RuleGroupRuleArrayOutput)
}

type RuleGroupArrayOutput struct{ *pulumi.OutputState }

func (RuleGroupArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]*RuleGroup)(nil)).Elem()
}

func (o RuleGroupArrayOutput) ToRuleGroupArrayOutput() RuleGroupArrayOutput {
	return o
}

func (o RuleGroupArrayOutput) ToRuleGroupArrayOutputWithContext(ctx context.Context) RuleGroupArrayOutput {
	return o
}

func (o RuleGroupArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*RuleGroup] {
	return pulumix.Output[[]*RuleGroup]{
		OutputState: o.OutputState,
	}
}

func (o RuleGroupArrayOutput) Index(i pulumi.IntInput) RuleGroupOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RuleGroup {
		return vs[0].([]*RuleGroup)[vs[1].(int)]
	}).(RuleGroupOutput)
}

type RuleGroupMapOutput struct{ *pulumi.OutputState }

func (RuleGroupMapOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]*RuleGroup)(nil)).Elem()
}

func (o RuleGroupMapOutput) ToRuleGroupMapOutput() RuleGroupMapOutput {
	return o
}

func (o RuleGroupMapOutput) ToRuleGroupMapOutputWithContext(ctx context.Context) RuleGroupMapOutput {
	return o
}

func (o RuleGroupMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*RuleGroup] {
	return pulumix.Output[map[string]*RuleGroup]{
		OutputState: o.OutputState,
	}
}

func (o RuleGroupMapOutput) MapIndex(k pulumi.StringInput) RuleGroupOutput {
	return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RuleGroup {
		return vs[0].(map[string]*RuleGroup)[vs[1].(string)]
	}).(RuleGroupOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*RuleGroupInput)(nil)).Elem(), &RuleGroup{})
	pulumi.RegisterInputType(reflect.TypeOf((*RuleGroupArrayInput)(nil)).Elem(), RuleGroupArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*RuleGroupMapInput)(nil)).Elem(), RuleGroupMap{})
	pulumi.RegisterOutputType(RuleGroupOutput{})
	pulumi.RegisterOutputType(RuleGroupArrayOutput{})
	pulumi.RegisterOutputType(RuleGroupMapOutput{})
}