pulumiTypes.go

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

package pagerduty

import (
	"context"
	"reflect"

	"github.com/pulumi/pulumi/sdk/v2/go/pulumi"
)

type EscalationPolicyRule struct {
	// The number of minutes before an unacknowledged incident escalates away from this rule.
	EscalationDelayInMinutes int `pulumi:"escalationDelayInMinutes"`
	// A target ID
	Id      *string                      `pulumi:"id"`
	Targets []EscalationPolicyRuleTarget `pulumi:"targets"`
}

// EscalationPolicyRuleInput is an input type that accepts EscalationPolicyRuleArgs and EscalationPolicyRuleOutput values.
// You can construct a concrete instance of `EscalationPolicyRuleInput` via:
//
// 		 EscalationPolicyRuleArgs{...}
//
type EscalationPolicyRuleInput interface {
	pulumi.Input

	ToEscalationPolicyRuleOutput() EscalationPolicyRuleOutput
	ToEscalationPolicyRuleOutputWithContext(context.Context) EscalationPolicyRuleOutput
}

type EscalationPolicyRuleArgs struct {
	// The number of minutes before an unacknowledged incident escalates away from this rule.
	EscalationDelayInMinutes pulumi.IntInput `pulumi:"escalationDelayInMinutes"`
	// A target ID
	Id      pulumi.StringPtrInput                `pulumi:"id"`
	Targets EscalationPolicyRuleTargetArrayInput `pulumi:"targets"`
}

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

func (i EscalationPolicyRuleArgs) ToEscalationPolicyRuleOutput() EscalationPolicyRuleOutput {
	return i.ToEscalationPolicyRuleOutputWithContext(context.Background())
}

func (i EscalationPolicyRuleArgs) ToEscalationPolicyRuleOutputWithContext(ctx context.Context) EscalationPolicyRuleOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EscalationPolicyRuleOutput)
}

// EscalationPolicyRuleArrayInput is an input type that accepts EscalationPolicyRuleArray and EscalationPolicyRuleArrayOutput values.
// You can construct a concrete instance of `EscalationPolicyRuleArrayInput` via:
//
// 		 EscalationPolicyRuleArray{ EscalationPolicyRuleArgs{...} }
//
type EscalationPolicyRuleArrayInput interface {
	pulumi.Input

	ToEscalationPolicyRuleArrayOutput() EscalationPolicyRuleArrayOutput
	ToEscalationPolicyRuleArrayOutputWithContext(context.Context) EscalationPolicyRuleArrayOutput
}

type EscalationPolicyRuleArray []EscalationPolicyRuleInput

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

func (i EscalationPolicyRuleArray) ToEscalationPolicyRuleArrayOutput() EscalationPolicyRuleArrayOutput {
	return i.ToEscalationPolicyRuleArrayOutputWithContext(context.Background())
}

func (i EscalationPolicyRuleArray) ToEscalationPolicyRuleArrayOutputWithContext(ctx context.Context) EscalationPolicyRuleArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EscalationPolicyRuleArrayOutput)
}

type EscalationPolicyRuleOutput struct{ *pulumi.OutputState }

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

func (o EscalationPolicyRuleOutput) ToEscalationPolicyRuleOutput() EscalationPolicyRuleOutput {
	return o
}

func (o EscalationPolicyRuleOutput) ToEscalationPolicyRuleOutputWithContext(ctx context.Context) EscalationPolicyRuleOutput {
	return o
}

// The number of minutes before an unacknowledged incident escalates away from this rule.
func (o EscalationPolicyRuleOutput) EscalationDelayInMinutes() pulumi.IntOutput {
	return o.ApplyT(func(v EscalationPolicyRule) int { return v.EscalationDelayInMinutes }).(pulumi.IntOutput)
}

// A target ID
func (o EscalationPolicyRuleOutput) Id() pulumi.StringPtrOutput {
	return o.ApplyT(func(v EscalationPolicyRule) *string { return v.Id }).(pulumi.StringPtrOutput)
}

func (o EscalationPolicyRuleOutput) Targets() EscalationPolicyRuleTargetArrayOutput {
	return o.ApplyT(func(v EscalationPolicyRule) []EscalationPolicyRuleTarget { return v.Targets }).(EscalationPolicyRuleTargetArrayOutput)
}

type EscalationPolicyRuleArrayOutput struct{ *pulumi.OutputState }

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

func (o EscalationPolicyRuleArrayOutput) ToEscalationPolicyRuleArrayOutput() EscalationPolicyRuleArrayOutput {
	return o
}

func (o EscalationPolicyRuleArrayOutput) ToEscalationPolicyRuleArrayOutputWithContext(ctx context.Context) EscalationPolicyRuleArrayOutput {
	return o
}

func (o EscalationPolicyRuleArrayOutput) Index(i pulumi.IntInput) EscalationPolicyRuleOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) EscalationPolicyRule {
		return vs[0].([]EscalationPolicyRule)[vs[1].(int)]
	}).(EscalationPolicyRuleOutput)
}

type EscalationPolicyRuleTarget struct {
	// A target ID
	Id string `pulumi:"id"`
	// Can be `user`, `schedule`, `userReference` or `scheduleReference`. Defaults to `userReference`
	Type *string `pulumi:"type"`
}

// EscalationPolicyRuleTargetInput is an input type that accepts EscalationPolicyRuleTargetArgs and EscalationPolicyRuleTargetOutput values.
// You can construct a concrete instance of `EscalationPolicyRuleTargetInput` via:
//
// 		 EscalationPolicyRuleTargetArgs{...}
//
type EscalationPolicyRuleTargetInput interface {
	pulumi.Input

	ToEscalationPolicyRuleTargetOutput() EscalationPolicyRuleTargetOutput
	ToEscalationPolicyRuleTargetOutputWithContext(context.Context) EscalationPolicyRuleTargetOutput
}

type EscalationPolicyRuleTargetArgs struct {
	// A target ID
	Id pulumi.StringInput `pulumi:"id"`
	// Can be `user`, `schedule`, `userReference` or `scheduleReference`. Defaults to `userReference`
	Type pulumi.StringPtrInput `pulumi:"type"`
}

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

func (i EscalationPolicyRuleTargetArgs) ToEscalationPolicyRuleTargetOutput() EscalationPolicyRuleTargetOutput {
	return i.ToEscalationPolicyRuleTargetOutputWithContext(context.Background())
}

func (i EscalationPolicyRuleTargetArgs) ToEscalationPolicyRuleTargetOutputWithContext(ctx context.Context) EscalationPolicyRuleTargetOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EscalationPolicyRuleTargetOutput)
}

// EscalationPolicyRuleTargetArrayInput is an input type that accepts EscalationPolicyRuleTargetArray and EscalationPolicyRuleTargetArrayOutput values.
// You can construct a concrete instance of `EscalationPolicyRuleTargetArrayInput` via:
//
// 		 EscalationPolicyRuleTargetArray{ EscalationPolicyRuleTargetArgs{...} }
//
type EscalationPolicyRuleTargetArrayInput interface {
	pulumi.Input

	ToEscalationPolicyRuleTargetArrayOutput() EscalationPolicyRuleTargetArrayOutput
	ToEscalationPolicyRuleTargetArrayOutputWithContext(context.Context) EscalationPolicyRuleTargetArrayOutput
}

type EscalationPolicyRuleTargetArray []EscalationPolicyRuleTargetInput

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

func (i EscalationPolicyRuleTargetArray) ToEscalationPolicyRuleTargetArrayOutput() EscalationPolicyRuleTargetArrayOutput {
	return i.ToEscalationPolicyRuleTargetArrayOutputWithContext(context.Background())
}

func (i EscalationPolicyRuleTargetArray) ToEscalationPolicyRuleTargetArrayOutputWithContext(ctx context.Context) EscalationPolicyRuleTargetArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EscalationPolicyRuleTargetArrayOutput)
}

type EscalationPolicyRuleTargetOutput struct{ *pulumi.OutputState }

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

func (o EscalationPolicyRuleTargetOutput) ToEscalationPolicyRuleTargetOutput() EscalationPolicyRuleTargetOutput {
	return o
}

func (o EscalationPolicyRuleTargetOutput) ToEscalationPolicyRuleTargetOutputWithContext(ctx context.Context) EscalationPolicyRuleTargetOutput {
	return o
}

// A target ID
func (o EscalationPolicyRuleTargetOutput) Id() pulumi.StringOutput {
	return o.ApplyT(func(v EscalationPolicyRuleTarget) string { return v.Id }).(pulumi.StringOutput)
}

// Can be `user`, `schedule`, `userReference` or `scheduleReference`. Defaults to `userReference`
func (o EscalationPolicyRuleTargetOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v EscalationPolicyRuleTarget) *string { return v.Type }).(pulumi.StringPtrOutput)
}

type EscalationPolicyRuleTargetArrayOutput struct{ *pulumi.OutputState }

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

func (o EscalationPolicyRuleTargetArrayOutput) ToEscalationPolicyRuleTargetArrayOutput() EscalationPolicyRuleTargetArrayOutput {
	return o
}

func (o EscalationPolicyRuleTargetArrayOutput) ToEscalationPolicyRuleTargetArrayOutputWithContext(ctx context.Context) EscalationPolicyRuleTargetArrayOutput {
	return o
}

func (o EscalationPolicyRuleTargetArrayOutput) Index(i pulumi.IntInput) EscalationPolicyRuleTargetOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) EscalationPolicyRuleTarget {
		return vs[0].([]EscalationPolicyRuleTarget)[vs[1].(int)]
	}).(EscalationPolicyRuleTargetOutput)
}

type RulesetRuleActions struct {
	// Note added to the event.
	Annotates    []RulesetRuleActionsAnnotate    `pulumi:"annotates"`
	EventActions []RulesetRuleActionsEventAction `pulumi:"eventActions"`
	// Allows you to copy important data from one event field to another. Extraction rules must use valid [RE2 regular expression syntax](https://github.com/google/re2/wiki/Syntax). Extraction objects consist of the following fields:
	Extractions []RulesetRuleActionsExtraction `pulumi:"extractions"`
	// The ID of the priority applied to the event.
	Priorities []RulesetRuleActionsPriority `pulumi:"priorities"`
	// The ID of the service where the event will be routed.
	Routes []RulesetRuleActionsRoute `pulumi:"routes"`
	// The [severity level](https://support.pagerduty.com/docs/rulesets#section-set-severity-with-event-rules) of the event. Can be either `info`,`error`,`warning`, or `critical`.
	Severities []RulesetRuleActionsSeverity `pulumi:"severities"`
	// Controls whether an alert is [suppressed](https://support.pagerduty.com/docs/rulesets#section-suppress-but-create-triggering-thresholds-with-event-rules) (does not create an incident).
	Suppresses []RulesetRuleActionsSuppress `pulumi:"suppresses"`
}

// RulesetRuleActionsInput is an input type that accepts RulesetRuleActionsArgs and RulesetRuleActionsOutput values.
// You can construct a concrete instance of `RulesetRuleActionsInput` via:
//
// 		 RulesetRuleActionsArgs{...}
//
type RulesetRuleActionsInput interface {
	pulumi.Input

	ToRulesetRuleActionsOutput() RulesetRuleActionsOutput
	ToRulesetRuleActionsOutputWithContext(context.Context) RulesetRuleActionsOutput
}

type RulesetRuleActionsArgs struct {
	// Note added to the event.
	Annotates    RulesetRuleActionsAnnotateArrayInput    `pulumi:"annotates"`
	EventActions RulesetRuleActionsEventActionArrayInput `pulumi:"eventActions"`
	// Allows you to copy important data from one event field to another. Extraction rules must use valid [RE2 regular expression syntax](https://github.com/google/re2/wiki/Syntax). Extraction objects consist of the following fields:
	Extractions RulesetRuleActionsExtractionArrayInput `pulumi:"extractions"`
	// The ID of the priority applied to the event.
	Priorities RulesetRuleActionsPriorityArrayInput `pulumi:"priorities"`
	// The ID of the service where the event will be routed.
	Routes RulesetRuleActionsRouteArrayInput `pulumi:"routes"`
	// The [severity level](https://support.pagerduty.com/docs/rulesets#section-set-severity-with-event-rules) of the event. Can be either `info`,`error`,`warning`, or `critical`.
	Severities RulesetRuleActionsSeverityArrayInput `pulumi:"severities"`
	// Controls whether an alert is [suppressed](https://support.pagerduty.com/docs/rulesets#section-suppress-but-create-triggering-thresholds-with-event-rules) (does not create an incident).
	Suppresses RulesetRuleActionsSuppressArrayInput `pulumi:"suppresses"`
}

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

func (i RulesetRuleActionsArgs) ToRulesetRuleActionsOutput() RulesetRuleActionsOutput {
	return i.ToRulesetRuleActionsOutputWithContext(context.Background())
}

func (i RulesetRuleActionsArgs) ToRulesetRuleActionsOutputWithContext(ctx context.Context) RulesetRuleActionsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleActionsOutput)
}

func (i RulesetRuleActionsArgs) ToRulesetRuleActionsPtrOutput() RulesetRuleActionsPtrOutput {
	return i.ToRulesetRuleActionsPtrOutputWithContext(context.Background())
}

func (i RulesetRuleActionsArgs) ToRulesetRuleActionsPtrOutputWithContext(ctx context.Context) RulesetRuleActionsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleActionsOutput).ToRulesetRuleActionsPtrOutputWithContext(ctx)
}

// RulesetRuleActionsPtrInput is an input type that accepts RulesetRuleActionsArgs, RulesetRuleActionsPtr and RulesetRuleActionsPtrOutput values.
// You can construct a concrete instance of `RulesetRuleActionsPtrInput` via:
//
// 		 RulesetRuleActionsArgs{...}
//
//  or:
//
// 		 nil
//
type RulesetRuleActionsPtrInput interface {
	pulumi.Input

	ToRulesetRuleActionsPtrOutput() RulesetRuleActionsPtrOutput
	ToRulesetRuleActionsPtrOutputWithContext(context.Context) RulesetRuleActionsPtrOutput
}

type rulesetRuleActionsPtrType RulesetRuleActionsArgs

func RulesetRuleActionsPtr(v *RulesetRuleActionsArgs) RulesetRuleActionsPtrInput {
	return (*rulesetRuleActionsPtrType)(v)
}

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

func (i *rulesetRuleActionsPtrType) ToRulesetRuleActionsPtrOutput() RulesetRuleActionsPtrOutput {
	return i.ToRulesetRuleActionsPtrOutputWithContext(context.Background())
}

func (i *rulesetRuleActionsPtrType) ToRulesetRuleActionsPtrOutputWithContext(ctx context.Context) RulesetRuleActionsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleActionsPtrOutput)
}

type RulesetRuleActionsOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleActionsOutput) ToRulesetRuleActionsOutput() RulesetRuleActionsOutput {
	return o
}

func (o RulesetRuleActionsOutput) ToRulesetRuleActionsOutputWithContext(ctx context.Context) RulesetRuleActionsOutput {
	return o
}

func (o RulesetRuleActionsOutput) ToRulesetRuleActionsPtrOutput() RulesetRuleActionsPtrOutput {
	return o.ToRulesetRuleActionsPtrOutputWithContext(context.Background())
}

func (o RulesetRuleActionsOutput) ToRulesetRuleActionsPtrOutputWithContext(ctx context.Context) RulesetRuleActionsPtrOutput {
	return o.ApplyT(func(v RulesetRuleActions) *RulesetRuleActions {
		return &v
	}).(RulesetRuleActionsPtrOutput)
}

// Note added to the event.
func (o RulesetRuleActionsOutput) Annotates() RulesetRuleActionsAnnotateArrayOutput {
	return o.ApplyT(func(v RulesetRuleActions) []RulesetRuleActionsAnnotate { return v.Annotates }).(RulesetRuleActionsAnnotateArrayOutput)
}

func (o RulesetRuleActionsOutput) EventActions() RulesetRuleActionsEventActionArrayOutput {
	return o.ApplyT(func(v RulesetRuleActions) []RulesetRuleActionsEventAction { return v.EventActions }).(RulesetRuleActionsEventActionArrayOutput)
}

// Allows you to copy important data from one event field to another. Extraction rules must use valid [RE2 regular expression syntax](https://github.com/google/re2/wiki/Syntax). Extraction objects consist of the following fields:
func (o RulesetRuleActionsOutput) Extractions() RulesetRuleActionsExtractionArrayOutput {
	return o.ApplyT(func(v RulesetRuleActions) []RulesetRuleActionsExtraction { return v.Extractions }).(RulesetRuleActionsExtractionArrayOutput)
}

// The ID of the priority applied to the event.
func (o RulesetRuleActionsOutput) Priorities() RulesetRuleActionsPriorityArrayOutput {
	return o.ApplyT(func(v RulesetRuleActions) []RulesetRuleActionsPriority { return v.Priorities }).(RulesetRuleActionsPriorityArrayOutput)
}

// The ID of the service where the event will be routed.
func (o RulesetRuleActionsOutput) Routes() RulesetRuleActionsRouteArrayOutput {
	return o.ApplyT(func(v RulesetRuleActions) []RulesetRuleActionsRoute { return v.Routes }).(RulesetRuleActionsRouteArrayOutput)
}

// The [severity level](https://support.pagerduty.com/docs/rulesets#section-set-severity-with-event-rules) of the event. Can be either `info`,`error`,`warning`, or `critical`.
func (o RulesetRuleActionsOutput) Severities() RulesetRuleActionsSeverityArrayOutput {
	return o.ApplyT(func(v RulesetRuleActions) []RulesetRuleActionsSeverity { return v.Severities }).(RulesetRuleActionsSeverityArrayOutput)
}

// Controls whether an alert is [suppressed](https://support.pagerduty.com/docs/rulesets#section-suppress-but-create-triggering-thresholds-with-event-rules) (does not create an incident).
func (o RulesetRuleActionsOutput) Suppresses() RulesetRuleActionsSuppressArrayOutput {
	return o.ApplyT(func(v RulesetRuleActions) []RulesetRuleActionsSuppress { return v.Suppresses }).(RulesetRuleActionsSuppressArrayOutput)
}

type RulesetRuleActionsPtrOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleActionsPtrOutput) ToRulesetRuleActionsPtrOutput() RulesetRuleActionsPtrOutput {
	return o
}

func (o RulesetRuleActionsPtrOutput) ToRulesetRuleActionsPtrOutputWithContext(ctx context.Context) RulesetRuleActionsPtrOutput {
	return o
}

func (o RulesetRuleActionsPtrOutput) Elem() RulesetRuleActionsOutput {
	return o.ApplyT(func(v *RulesetRuleActions) RulesetRuleActions { return *v }).(RulesetRuleActionsOutput)
}

// Note added to the event.
func (o RulesetRuleActionsPtrOutput) Annotates() RulesetRuleActionsAnnotateArrayOutput {
	return o.ApplyT(func(v *RulesetRuleActions) []RulesetRuleActionsAnnotate {
		if v == nil {
			return nil
		}
		return v.Annotates
	}).(RulesetRuleActionsAnnotateArrayOutput)
}

func (o RulesetRuleActionsPtrOutput) EventActions() RulesetRuleActionsEventActionArrayOutput {
	return o.ApplyT(func(v *RulesetRuleActions) []RulesetRuleActionsEventAction {
		if v == nil {
			return nil
		}
		return v.EventActions
	}).(RulesetRuleActionsEventActionArrayOutput)
}

// Allows you to copy important data from one event field to another. Extraction rules must use valid [RE2 regular expression syntax](https://github.com/google/re2/wiki/Syntax). Extraction objects consist of the following fields:
func (o RulesetRuleActionsPtrOutput) Extractions() RulesetRuleActionsExtractionArrayOutput {
	return o.ApplyT(func(v *RulesetRuleActions) []RulesetRuleActionsExtraction {
		if v == nil {
			return nil
		}
		return v.Extractions
	}).(RulesetRuleActionsExtractionArrayOutput)
}

// The ID of the priority applied to the event.
func (o RulesetRuleActionsPtrOutput) Priorities() RulesetRuleActionsPriorityArrayOutput {
	return o.ApplyT(func(v *RulesetRuleActions) []RulesetRuleActionsPriority {
		if v == nil {
			return nil
		}
		return v.Priorities
	}).(RulesetRuleActionsPriorityArrayOutput)
}

// The ID of the service where the event will be routed.
func (o RulesetRuleActionsPtrOutput) Routes() RulesetRuleActionsRouteArrayOutput {
	return o.ApplyT(func(v *RulesetRuleActions) []RulesetRuleActionsRoute {
		if v == nil {
			return nil
		}
		return v.Routes
	}).(RulesetRuleActionsRouteArrayOutput)
}

// The [severity level](https://support.pagerduty.com/docs/rulesets#section-set-severity-with-event-rules) of the event. Can be either `info`,`error`,`warning`, or `critical`.
func (o RulesetRuleActionsPtrOutput) Severities() RulesetRuleActionsSeverityArrayOutput {
	return o.ApplyT(func(v *RulesetRuleActions) []RulesetRuleActionsSeverity {
		if v == nil {
			return nil
		}
		return v.Severities
	}).(RulesetRuleActionsSeverityArrayOutput)
}

// Controls whether an alert is [suppressed](https://support.pagerduty.com/docs/rulesets#section-suppress-but-create-triggering-thresholds-with-event-rules) (does not create an incident).
func (o RulesetRuleActionsPtrOutput) Suppresses() RulesetRuleActionsSuppressArrayOutput {
	return o.ApplyT(func(v *RulesetRuleActions) []RulesetRuleActionsSuppress {
		if v == nil {
			return nil
		}
		return v.Suppresses
	}).(RulesetRuleActionsSuppressArrayOutput)
}

type RulesetRuleActionsAnnotate struct {
	// Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met.
	Value *string `pulumi:"value"`
}

// RulesetRuleActionsAnnotateInput is an input type that accepts RulesetRuleActionsAnnotateArgs and RulesetRuleActionsAnnotateOutput values.
// You can construct a concrete instance of `RulesetRuleActionsAnnotateInput` via:
//
// 		 RulesetRuleActionsAnnotateArgs{...}
//
type RulesetRuleActionsAnnotateInput interface {
	pulumi.Input

	ToRulesetRuleActionsAnnotateOutput() RulesetRuleActionsAnnotateOutput
	ToRulesetRuleActionsAnnotateOutputWithContext(context.Context) RulesetRuleActionsAnnotateOutput
}

type RulesetRuleActionsAnnotateArgs struct {
	// Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met.
	Value pulumi.StringPtrInput `pulumi:"value"`
}

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

func (i RulesetRuleActionsAnnotateArgs) ToRulesetRuleActionsAnnotateOutput() RulesetRuleActionsAnnotateOutput {
	return i.ToRulesetRuleActionsAnnotateOutputWithContext(context.Background())
}

func (i RulesetRuleActionsAnnotateArgs) ToRulesetRuleActionsAnnotateOutputWithContext(ctx context.Context) RulesetRuleActionsAnnotateOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleActionsAnnotateOutput)
}

// RulesetRuleActionsAnnotateArrayInput is an input type that accepts RulesetRuleActionsAnnotateArray and RulesetRuleActionsAnnotateArrayOutput values.
// You can construct a concrete instance of `RulesetRuleActionsAnnotateArrayInput` via:
//
// 		 RulesetRuleActionsAnnotateArray{ RulesetRuleActionsAnnotateArgs{...} }
//
type RulesetRuleActionsAnnotateArrayInput interface {
	pulumi.Input

	ToRulesetRuleActionsAnnotateArrayOutput() RulesetRuleActionsAnnotateArrayOutput
	ToRulesetRuleActionsAnnotateArrayOutputWithContext(context.Context) RulesetRuleActionsAnnotateArrayOutput
}

type RulesetRuleActionsAnnotateArray []RulesetRuleActionsAnnotateInput

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

func (i RulesetRuleActionsAnnotateArray) ToRulesetRuleActionsAnnotateArrayOutput() RulesetRuleActionsAnnotateArrayOutput {
	return i.ToRulesetRuleActionsAnnotateArrayOutputWithContext(context.Background())
}

func (i RulesetRuleActionsAnnotateArray) ToRulesetRuleActionsAnnotateArrayOutputWithContext(ctx context.Context) RulesetRuleActionsAnnotateArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleActionsAnnotateArrayOutput)
}

type RulesetRuleActionsAnnotateOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleActionsAnnotateOutput) ToRulesetRuleActionsAnnotateOutput() RulesetRuleActionsAnnotateOutput {
	return o
}

func (o RulesetRuleActionsAnnotateOutput) ToRulesetRuleActionsAnnotateOutputWithContext(ctx context.Context) RulesetRuleActionsAnnotateOutput {
	return o
}

// Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met.
func (o RulesetRuleActionsAnnotateOutput) Value() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RulesetRuleActionsAnnotate) *string { return v.Value }).(pulumi.StringPtrOutput)
}

type RulesetRuleActionsAnnotateArrayOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleActionsAnnotateArrayOutput) ToRulesetRuleActionsAnnotateArrayOutput() RulesetRuleActionsAnnotateArrayOutput {
	return o
}

func (o RulesetRuleActionsAnnotateArrayOutput) ToRulesetRuleActionsAnnotateArrayOutputWithContext(ctx context.Context) RulesetRuleActionsAnnotateArrayOutput {
	return o
}

func (o RulesetRuleActionsAnnotateArrayOutput) Index(i pulumi.IntInput) RulesetRuleActionsAnnotateOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) RulesetRuleActionsAnnotate {
		return vs[0].([]RulesetRuleActionsAnnotate)[vs[1].(int)]
	}).(RulesetRuleActionsAnnotateOutput)
}

type RulesetRuleActionsEventAction struct {
	// Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met.
	Value *string `pulumi:"value"`
}

// RulesetRuleActionsEventActionInput is an input type that accepts RulesetRuleActionsEventActionArgs and RulesetRuleActionsEventActionOutput values.
// You can construct a concrete instance of `RulesetRuleActionsEventActionInput` via:
//
// 		 RulesetRuleActionsEventActionArgs{...}
//
type RulesetRuleActionsEventActionInput interface {
	pulumi.Input

	ToRulesetRuleActionsEventActionOutput() RulesetRuleActionsEventActionOutput
	ToRulesetRuleActionsEventActionOutputWithContext(context.Context) RulesetRuleActionsEventActionOutput
}

type RulesetRuleActionsEventActionArgs struct {
	// Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met.
	Value pulumi.StringPtrInput `pulumi:"value"`
}

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

func (i RulesetRuleActionsEventActionArgs) ToRulesetRuleActionsEventActionOutput() RulesetRuleActionsEventActionOutput {
	return i.ToRulesetRuleActionsEventActionOutputWithContext(context.Background())
}

func (i RulesetRuleActionsEventActionArgs) ToRulesetRuleActionsEventActionOutputWithContext(ctx context.Context) RulesetRuleActionsEventActionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleActionsEventActionOutput)
}

// RulesetRuleActionsEventActionArrayInput is an input type that accepts RulesetRuleActionsEventActionArray and RulesetRuleActionsEventActionArrayOutput values.
// You can construct a concrete instance of `RulesetRuleActionsEventActionArrayInput` via:
//
// 		 RulesetRuleActionsEventActionArray{ RulesetRuleActionsEventActionArgs{...} }
//
type RulesetRuleActionsEventActionArrayInput interface {
	pulumi.Input

	ToRulesetRuleActionsEventActionArrayOutput() RulesetRuleActionsEventActionArrayOutput
	ToRulesetRuleActionsEventActionArrayOutputWithContext(context.Context) RulesetRuleActionsEventActionArrayOutput
}

type RulesetRuleActionsEventActionArray []RulesetRuleActionsEventActionInput

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

func (i RulesetRuleActionsEventActionArray) ToRulesetRuleActionsEventActionArrayOutput() RulesetRuleActionsEventActionArrayOutput {
	return i.ToRulesetRuleActionsEventActionArrayOutputWithContext(context.Background())
}

func (i RulesetRuleActionsEventActionArray) ToRulesetRuleActionsEventActionArrayOutputWithContext(ctx context.Context) RulesetRuleActionsEventActionArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleActionsEventActionArrayOutput)
}

type RulesetRuleActionsEventActionOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleActionsEventActionOutput) ToRulesetRuleActionsEventActionOutput() RulesetRuleActionsEventActionOutput {
	return o
}

func (o RulesetRuleActionsEventActionOutput) ToRulesetRuleActionsEventActionOutputWithContext(ctx context.Context) RulesetRuleActionsEventActionOutput {
	return o
}

// Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met.
func (o RulesetRuleActionsEventActionOutput) Value() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RulesetRuleActionsEventAction) *string { return v.Value }).(pulumi.StringPtrOutput)
}

type RulesetRuleActionsEventActionArrayOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleActionsEventActionArrayOutput) ToRulesetRuleActionsEventActionArrayOutput() RulesetRuleActionsEventActionArrayOutput {
	return o
}

func (o RulesetRuleActionsEventActionArrayOutput) ToRulesetRuleActionsEventActionArrayOutputWithContext(ctx context.Context) RulesetRuleActionsEventActionArrayOutput {
	return o
}

func (o RulesetRuleActionsEventActionArrayOutput) Index(i pulumi.IntInput) RulesetRuleActionsEventActionOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) RulesetRuleActionsEventAction {
		return vs[0].([]RulesetRuleActionsEventAction)[vs[1].(int)]
	}).(RulesetRuleActionsEventActionOutput)
}

type RulesetRuleActionsExtraction struct {
	// The conditions that need to be met for the extraction to happen.
	// * *NOTE: A rule can have multiple `extraction` objects attributed to it.*
	Regex *string `pulumi:"regex"`
	// Field where the data is being copied from.
	Source *string `pulumi:"source"`
	// Field where the data is being copied to.
	Target *string `pulumi:"target"`
}

// RulesetRuleActionsExtractionInput is an input type that accepts RulesetRuleActionsExtractionArgs and RulesetRuleActionsExtractionOutput values.
// You can construct a concrete instance of `RulesetRuleActionsExtractionInput` via:
//
// 		 RulesetRuleActionsExtractionArgs{...}
//
type RulesetRuleActionsExtractionInput interface {
	pulumi.Input

	ToRulesetRuleActionsExtractionOutput() RulesetRuleActionsExtractionOutput
	ToRulesetRuleActionsExtractionOutputWithContext(context.Context) RulesetRuleActionsExtractionOutput
}

type RulesetRuleActionsExtractionArgs struct {
	// The conditions that need to be met for the extraction to happen.
	// * *NOTE: A rule can have multiple `extraction` objects attributed to it.*
	Regex pulumi.StringPtrInput `pulumi:"regex"`
	// Field where the data is being copied from.
	Source pulumi.StringPtrInput `pulumi:"source"`
	// Field where the data is being copied to.
	Target pulumi.StringPtrInput `pulumi:"target"`
}

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

func (i RulesetRuleActionsExtractionArgs) ToRulesetRuleActionsExtractionOutput() RulesetRuleActionsExtractionOutput {
	return i.ToRulesetRuleActionsExtractionOutputWithContext(context.Background())
}

func (i RulesetRuleActionsExtractionArgs) ToRulesetRuleActionsExtractionOutputWithContext(ctx context.Context) RulesetRuleActionsExtractionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleActionsExtractionOutput)
}

// RulesetRuleActionsExtractionArrayInput is an input type that accepts RulesetRuleActionsExtractionArray and RulesetRuleActionsExtractionArrayOutput values.
// You can construct a concrete instance of `RulesetRuleActionsExtractionArrayInput` via:
//
// 		 RulesetRuleActionsExtractionArray{ RulesetRuleActionsExtractionArgs{...} }
//
type RulesetRuleActionsExtractionArrayInput interface {
	pulumi.Input

	ToRulesetRuleActionsExtractionArrayOutput() RulesetRuleActionsExtractionArrayOutput
	ToRulesetRuleActionsExtractionArrayOutputWithContext(context.Context) RulesetRuleActionsExtractionArrayOutput
}

type RulesetRuleActionsExtractionArray []RulesetRuleActionsExtractionInput

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

func (i RulesetRuleActionsExtractionArray) ToRulesetRuleActionsExtractionArrayOutput() RulesetRuleActionsExtractionArrayOutput {
	return i.ToRulesetRuleActionsExtractionArrayOutputWithContext(context.Background())
}

func (i RulesetRuleActionsExtractionArray) ToRulesetRuleActionsExtractionArrayOutputWithContext(ctx context.Context) RulesetRuleActionsExtractionArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleActionsExtractionArrayOutput)
}

type RulesetRuleActionsExtractionOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleActionsExtractionOutput) ToRulesetRuleActionsExtractionOutput() RulesetRuleActionsExtractionOutput {
	return o
}

func (o RulesetRuleActionsExtractionOutput) ToRulesetRuleActionsExtractionOutputWithContext(ctx context.Context) RulesetRuleActionsExtractionOutput {
	return o
}

// The conditions that need to be met for the extraction to happen.
// * *NOTE: A rule can have multiple `extraction` objects attributed to it.*
func (o RulesetRuleActionsExtractionOutput) Regex() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RulesetRuleActionsExtraction) *string { return v.Regex }).(pulumi.StringPtrOutput)
}

// Field where the data is being copied from.
func (o RulesetRuleActionsExtractionOutput) Source() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RulesetRuleActionsExtraction) *string { return v.Source }).(pulumi.StringPtrOutput)
}

// Field where the data is being copied to.
func (o RulesetRuleActionsExtractionOutput) Target() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RulesetRuleActionsExtraction) *string { return v.Target }).(pulumi.StringPtrOutput)
}

type RulesetRuleActionsExtractionArrayOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleActionsExtractionArrayOutput) ToRulesetRuleActionsExtractionArrayOutput() RulesetRuleActionsExtractionArrayOutput {
	return o
}

func (o RulesetRuleActionsExtractionArrayOutput) ToRulesetRuleActionsExtractionArrayOutputWithContext(ctx context.Context) RulesetRuleActionsExtractionArrayOutput {
	return o
}

func (o RulesetRuleActionsExtractionArrayOutput) Index(i pulumi.IntInput) RulesetRuleActionsExtractionOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) RulesetRuleActionsExtraction {
		return vs[0].([]RulesetRuleActionsExtraction)[vs[1].(int)]
	}).(RulesetRuleActionsExtractionOutput)
}

type RulesetRuleActionsPriority struct {
	// Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met.
	Value *string `pulumi:"value"`
}

// RulesetRuleActionsPriorityInput is an input type that accepts RulesetRuleActionsPriorityArgs and RulesetRuleActionsPriorityOutput values.
// You can construct a concrete instance of `RulesetRuleActionsPriorityInput` via:
//
// 		 RulesetRuleActionsPriorityArgs{...}
//
type RulesetRuleActionsPriorityInput interface {
	pulumi.Input

	ToRulesetRuleActionsPriorityOutput() RulesetRuleActionsPriorityOutput
	ToRulesetRuleActionsPriorityOutputWithContext(context.Context) RulesetRuleActionsPriorityOutput
}

type RulesetRuleActionsPriorityArgs struct {
	// Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met.
	Value pulumi.StringPtrInput `pulumi:"value"`
}

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

func (i RulesetRuleActionsPriorityArgs) ToRulesetRuleActionsPriorityOutput() RulesetRuleActionsPriorityOutput {
	return i.ToRulesetRuleActionsPriorityOutputWithContext(context.Background())
}

func (i RulesetRuleActionsPriorityArgs) ToRulesetRuleActionsPriorityOutputWithContext(ctx context.Context) RulesetRuleActionsPriorityOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleActionsPriorityOutput)
}

// RulesetRuleActionsPriorityArrayInput is an input type that accepts RulesetRuleActionsPriorityArray and RulesetRuleActionsPriorityArrayOutput values.
// You can construct a concrete instance of `RulesetRuleActionsPriorityArrayInput` via:
//
// 		 RulesetRuleActionsPriorityArray{ RulesetRuleActionsPriorityArgs{...} }
//
type RulesetRuleActionsPriorityArrayInput interface {
	pulumi.Input

	ToRulesetRuleActionsPriorityArrayOutput() RulesetRuleActionsPriorityArrayOutput
	ToRulesetRuleActionsPriorityArrayOutputWithContext(context.Context) RulesetRuleActionsPriorityArrayOutput
}

type RulesetRuleActionsPriorityArray []RulesetRuleActionsPriorityInput

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

func (i RulesetRuleActionsPriorityArray) ToRulesetRuleActionsPriorityArrayOutput() RulesetRuleActionsPriorityArrayOutput {
	return i.ToRulesetRuleActionsPriorityArrayOutputWithContext(context.Background())
}

func (i RulesetRuleActionsPriorityArray) ToRulesetRuleActionsPriorityArrayOutputWithContext(ctx context.Context) RulesetRuleActionsPriorityArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleActionsPriorityArrayOutput)
}

type RulesetRuleActionsPriorityOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleActionsPriorityOutput) ToRulesetRuleActionsPriorityOutput() RulesetRuleActionsPriorityOutput {
	return o
}

func (o RulesetRuleActionsPriorityOutput) ToRulesetRuleActionsPriorityOutputWithContext(ctx context.Context) RulesetRuleActionsPriorityOutput {
	return o
}

// Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met.
func (o RulesetRuleActionsPriorityOutput) Value() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RulesetRuleActionsPriority) *string { return v.Value }).(pulumi.StringPtrOutput)
}

type RulesetRuleActionsPriorityArrayOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleActionsPriorityArrayOutput) ToRulesetRuleActionsPriorityArrayOutput() RulesetRuleActionsPriorityArrayOutput {
	return o
}

func (o RulesetRuleActionsPriorityArrayOutput) ToRulesetRuleActionsPriorityArrayOutputWithContext(ctx context.Context) RulesetRuleActionsPriorityArrayOutput {
	return o
}

func (o RulesetRuleActionsPriorityArrayOutput) Index(i pulumi.IntInput) RulesetRuleActionsPriorityOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) RulesetRuleActionsPriority {
		return vs[0].([]RulesetRuleActionsPriority)[vs[1].(int)]
	}).(RulesetRuleActionsPriorityOutput)
}

type RulesetRuleActionsRoute struct {
	// Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met.
	Value *string `pulumi:"value"`
}

// RulesetRuleActionsRouteInput is an input type that accepts RulesetRuleActionsRouteArgs and RulesetRuleActionsRouteOutput values.
// You can construct a concrete instance of `RulesetRuleActionsRouteInput` via:
//
// 		 RulesetRuleActionsRouteArgs{...}
//
type RulesetRuleActionsRouteInput interface {
	pulumi.Input

	ToRulesetRuleActionsRouteOutput() RulesetRuleActionsRouteOutput
	ToRulesetRuleActionsRouteOutputWithContext(context.Context) RulesetRuleActionsRouteOutput
}

type RulesetRuleActionsRouteArgs struct {
	// Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met.
	Value pulumi.StringPtrInput `pulumi:"value"`
}

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

func (i RulesetRuleActionsRouteArgs) ToRulesetRuleActionsRouteOutput() RulesetRuleActionsRouteOutput {
	return i.ToRulesetRuleActionsRouteOutputWithContext(context.Background())
}

func (i RulesetRuleActionsRouteArgs) ToRulesetRuleActionsRouteOutputWithContext(ctx context.Context) RulesetRuleActionsRouteOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleActionsRouteOutput)
}

// RulesetRuleActionsRouteArrayInput is an input type that accepts RulesetRuleActionsRouteArray and RulesetRuleActionsRouteArrayOutput values.
// You can construct a concrete instance of `RulesetRuleActionsRouteArrayInput` via:
//
// 		 RulesetRuleActionsRouteArray{ RulesetRuleActionsRouteArgs{...} }
//
type RulesetRuleActionsRouteArrayInput interface {
	pulumi.Input

	ToRulesetRuleActionsRouteArrayOutput() RulesetRuleActionsRouteArrayOutput
	ToRulesetRuleActionsRouteArrayOutputWithContext(context.Context) RulesetRuleActionsRouteArrayOutput
}

type RulesetRuleActionsRouteArray []RulesetRuleActionsRouteInput

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

func (i RulesetRuleActionsRouteArray) ToRulesetRuleActionsRouteArrayOutput() RulesetRuleActionsRouteArrayOutput {
	return i.ToRulesetRuleActionsRouteArrayOutputWithContext(context.Background())
}

func (i RulesetRuleActionsRouteArray) ToRulesetRuleActionsRouteArrayOutputWithContext(ctx context.Context) RulesetRuleActionsRouteArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleActionsRouteArrayOutput)
}

type RulesetRuleActionsRouteOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleActionsRouteOutput) ToRulesetRuleActionsRouteOutput() RulesetRuleActionsRouteOutput {
	return o
}

func (o RulesetRuleActionsRouteOutput) ToRulesetRuleActionsRouteOutputWithContext(ctx context.Context) RulesetRuleActionsRouteOutput {
	return o
}

// Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met.
func (o RulesetRuleActionsRouteOutput) Value() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RulesetRuleActionsRoute) *string { return v.Value }).(pulumi.StringPtrOutput)
}

type RulesetRuleActionsRouteArrayOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleActionsRouteArrayOutput) ToRulesetRuleActionsRouteArrayOutput() RulesetRuleActionsRouteArrayOutput {
	return o
}

func (o RulesetRuleActionsRouteArrayOutput) ToRulesetRuleActionsRouteArrayOutputWithContext(ctx context.Context) RulesetRuleActionsRouteArrayOutput {
	return o
}

func (o RulesetRuleActionsRouteArrayOutput) Index(i pulumi.IntInput) RulesetRuleActionsRouteOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) RulesetRuleActionsRoute {
		return vs[0].([]RulesetRuleActionsRoute)[vs[1].(int)]
	}).(RulesetRuleActionsRouteOutput)
}

type RulesetRuleActionsSeverity struct {
	// Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met.
	Value *string `pulumi:"value"`
}

// RulesetRuleActionsSeverityInput is an input type that accepts RulesetRuleActionsSeverityArgs and RulesetRuleActionsSeverityOutput values.
// You can construct a concrete instance of `RulesetRuleActionsSeverityInput` via:
//
// 		 RulesetRuleActionsSeverityArgs{...}
//
type RulesetRuleActionsSeverityInput interface {
	pulumi.Input

	ToRulesetRuleActionsSeverityOutput() RulesetRuleActionsSeverityOutput
	ToRulesetRuleActionsSeverityOutputWithContext(context.Context) RulesetRuleActionsSeverityOutput
}

type RulesetRuleActionsSeverityArgs struct {
	// Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met.
	Value pulumi.StringPtrInput `pulumi:"value"`
}

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

func (i RulesetRuleActionsSeverityArgs) ToRulesetRuleActionsSeverityOutput() RulesetRuleActionsSeverityOutput {
	return i.ToRulesetRuleActionsSeverityOutputWithContext(context.Background())
}

func (i RulesetRuleActionsSeverityArgs) ToRulesetRuleActionsSeverityOutputWithContext(ctx context.Context) RulesetRuleActionsSeverityOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleActionsSeverityOutput)
}

// RulesetRuleActionsSeverityArrayInput is an input type that accepts RulesetRuleActionsSeverityArray and RulesetRuleActionsSeverityArrayOutput values.
// You can construct a concrete instance of `RulesetRuleActionsSeverityArrayInput` via:
//
// 		 RulesetRuleActionsSeverityArray{ RulesetRuleActionsSeverityArgs{...} }
//
type RulesetRuleActionsSeverityArrayInput interface {
	pulumi.Input

	ToRulesetRuleActionsSeverityArrayOutput() RulesetRuleActionsSeverityArrayOutput
	ToRulesetRuleActionsSeverityArrayOutputWithContext(context.Context) RulesetRuleActionsSeverityArrayOutput
}

type RulesetRuleActionsSeverityArray []RulesetRuleActionsSeverityInput

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

func (i RulesetRuleActionsSeverityArray) ToRulesetRuleActionsSeverityArrayOutput() RulesetRuleActionsSeverityArrayOutput {
	return i.ToRulesetRuleActionsSeverityArrayOutputWithContext(context.Background())
}

func (i RulesetRuleActionsSeverityArray) ToRulesetRuleActionsSeverityArrayOutputWithContext(ctx context.Context) RulesetRuleActionsSeverityArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleActionsSeverityArrayOutput)
}

type RulesetRuleActionsSeverityOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleActionsSeverityOutput) ToRulesetRuleActionsSeverityOutput() RulesetRuleActionsSeverityOutput {
	return o
}

func (o RulesetRuleActionsSeverityOutput) ToRulesetRuleActionsSeverityOutputWithContext(ctx context.Context) RulesetRuleActionsSeverityOutput {
	return o
}

// Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met.
func (o RulesetRuleActionsSeverityOutput) Value() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RulesetRuleActionsSeverity) *string { return v.Value }).(pulumi.StringPtrOutput)
}

type RulesetRuleActionsSeverityArrayOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleActionsSeverityArrayOutput) ToRulesetRuleActionsSeverityArrayOutput() RulesetRuleActionsSeverityArrayOutput {
	return o
}

func (o RulesetRuleActionsSeverityArrayOutput) ToRulesetRuleActionsSeverityArrayOutputWithContext(ctx context.Context) RulesetRuleActionsSeverityArrayOutput {
	return o
}

func (o RulesetRuleActionsSeverityArrayOutput) Index(i pulumi.IntInput) RulesetRuleActionsSeverityOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) RulesetRuleActionsSeverity {
		return vs[0].([]RulesetRuleActionsSeverity)[vs[1].(int)]
	}).(RulesetRuleActionsSeverityOutput)
}

type RulesetRuleActionsSuppress struct {
	// The number value of the `thresholdTimeUnit` before an incident is created.
	ThresholdTimeAmount *int `pulumi:"thresholdTimeAmount"`
	// The `minutes`,`hours`, or `days` that the `thresholdTimeAmount` should be measured.
	ThresholdTimeUnit *string `pulumi:"thresholdTimeUnit"`
	// The number of alerts that should be suppressed.
	ThresholdValue *int `pulumi:"thresholdValue"`
	// Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met.
	Value *bool `pulumi:"value"`
}

// RulesetRuleActionsSuppressInput is an input type that accepts RulesetRuleActionsSuppressArgs and RulesetRuleActionsSuppressOutput values.
// You can construct a concrete instance of `RulesetRuleActionsSuppressInput` via:
//
// 		 RulesetRuleActionsSuppressArgs{...}
//
type RulesetRuleActionsSuppressInput interface {
	pulumi.Input

	ToRulesetRuleActionsSuppressOutput() RulesetRuleActionsSuppressOutput
	ToRulesetRuleActionsSuppressOutputWithContext(context.Context) RulesetRuleActionsSuppressOutput
}

type RulesetRuleActionsSuppressArgs struct {
	// The number value of the `thresholdTimeUnit` before an incident is created.
	ThresholdTimeAmount pulumi.IntPtrInput `pulumi:"thresholdTimeAmount"`
	// The `minutes`,`hours`, or `days` that the `thresholdTimeAmount` should be measured.
	ThresholdTimeUnit pulumi.StringPtrInput `pulumi:"thresholdTimeUnit"`
	// The number of alerts that should be suppressed.
	ThresholdValue pulumi.IntPtrInput `pulumi:"thresholdValue"`
	// Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met.
	Value pulumi.BoolPtrInput `pulumi:"value"`
}

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

func (i RulesetRuleActionsSuppressArgs) ToRulesetRuleActionsSuppressOutput() RulesetRuleActionsSuppressOutput {
	return i.ToRulesetRuleActionsSuppressOutputWithContext(context.Background())
}

func (i RulesetRuleActionsSuppressArgs) ToRulesetRuleActionsSuppressOutputWithContext(ctx context.Context) RulesetRuleActionsSuppressOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleActionsSuppressOutput)
}

// RulesetRuleActionsSuppressArrayInput is an input type that accepts RulesetRuleActionsSuppressArray and RulesetRuleActionsSuppressArrayOutput values.
// You can construct a concrete instance of `RulesetRuleActionsSuppressArrayInput` via:
//
// 		 RulesetRuleActionsSuppressArray{ RulesetRuleActionsSuppressArgs{...} }
//
type RulesetRuleActionsSuppressArrayInput interface {
	pulumi.Input

	ToRulesetRuleActionsSuppressArrayOutput() RulesetRuleActionsSuppressArrayOutput
	ToRulesetRuleActionsSuppressArrayOutputWithContext(context.Context) RulesetRuleActionsSuppressArrayOutput
}

type RulesetRuleActionsSuppressArray []RulesetRuleActionsSuppressInput

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

func (i RulesetRuleActionsSuppressArray) ToRulesetRuleActionsSuppressArrayOutput() RulesetRuleActionsSuppressArrayOutput {
	return i.ToRulesetRuleActionsSuppressArrayOutputWithContext(context.Background())
}

func (i RulesetRuleActionsSuppressArray) ToRulesetRuleActionsSuppressArrayOutputWithContext(ctx context.Context) RulesetRuleActionsSuppressArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleActionsSuppressArrayOutput)
}

type RulesetRuleActionsSuppressOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleActionsSuppressOutput) ToRulesetRuleActionsSuppressOutput() RulesetRuleActionsSuppressOutput {
	return o
}

func (o RulesetRuleActionsSuppressOutput) ToRulesetRuleActionsSuppressOutputWithContext(ctx context.Context) RulesetRuleActionsSuppressOutput {
	return o
}

// The number value of the `thresholdTimeUnit` before an incident is created.
func (o RulesetRuleActionsSuppressOutput) ThresholdTimeAmount() pulumi.IntPtrOutput {
	return o.ApplyT(func(v RulesetRuleActionsSuppress) *int { return v.ThresholdTimeAmount }).(pulumi.IntPtrOutput)
}

// The `minutes`,`hours`, or `days` that the `thresholdTimeAmount` should be measured.
func (o RulesetRuleActionsSuppressOutput) ThresholdTimeUnit() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RulesetRuleActionsSuppress) *string { return v.ThresholdTimeUnit }).(pulumi.StringPtrOutput)
}

// The number of alerts that should be suppressed.
func (o RulesetRuleActionsSuppressOutput) ThresholdValue() pulumi.IntPtrOutput {
	return o.ApplyT(func(v RulesetRuleActionsSuppress) *int { return v.ThresholdValue }).(pulumi.IntPtrOutput)
}

// Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met.
func (o RulesetRuleActionsSuppressOutput) Value() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v RulesetRuleActionsSuppress) *bool { return v.Value }).(pulumi.BoolPtrOutput)
}

type RulesetRuleActionsSuppressArrayOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleActionsSuppressArrayOutput) ToRulesetRuleActionsSuppressArrayOutput() RulesetRuleActionsSuppressArrayOutput {
	return o
}

func (o RulesetRuleActionsSuppressArrayOutput) ToRulesetRuleActionsSuppressArrayOutputWithContext(ctx context.Context) RulesetRuleActionsSuppressArrayOutput {
	return o
}

func (o RulesetRuleActionsSuppressArrayOutput) Index(i pulumi.IntInput) RulesetRuleActionsSuppressOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) RulesetRuleActionsSuppress {
		return vs[0].([]RulesetRuleActionsSuppress)[vs[1].(int)]
	}).(RulesetRuleActionsSuppressOutput)
}

type RulesetRuleConditions struct {
	// Operator to combine sub-conditions. Can be `and` or `or`.
	Operator *string `pulumi:"operator"`
	// List of sub-conditions that define the the condition.
	Subconditions []RulesetRuleConditionsSubcondition `pulumi:"subconditions"`
}

// RulesetRuleConditionsInput is an input type that accepts RulesetRuleConditionsArgs and RulesetRuleConditionsOutput values.
// You can construct a concrete instance of `RulesetRuleConditionsInput` via:
//
// 		 RulesetRuleConditionsArgs{...}
//
type RulesetRuleConditionsInput interface {
	pulumi.Input

	ToRulesetRuleConditionsOutput() RulesetRuleConditionsOutput
	ToRulesetRuleConditionsOutputWithContext(context.Context) RulesetRuleConditionsOutput
}

type RulesetRuleConditionsArgs struct {
	// Operator to combine sub-conditions. Can be `and` or `or`.
	Operator pulumi.StringPtrInput `pulumi:"operator"`
	// List of sub-conditions that define the the condition.
	Subconditions RulesetRuleConditionsSubconditionArrayInput `pulumi:"subconditions"`
}

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

func (i RulesetRuleConditionsArgs) ToRulesetRuleConditionsOutput() RulesetRuleConditionsOutput {
	return i.ToRulesetRuleConditionsOutputWithContext(context.Background())
}

func (i RulesetRuleConditionsArgs) ToRulesetRuleConditionsOutputWithContext(ctx context.Context) RulesetRuleConditionsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleConditionsOutput)
}

func (i RulesetRuleConditionsArgs) ToRulesetRuleConditionsPtrOutput() RulesetRuleConditionsPtrOutput {
	return i.ToRulesetRuleConditionsPtrOutputWithContext(context.Background())
}

func (i RulesetRuleConditionsArgs) ToRulesetRuleConditionsPtrOutputWithContext(ctx context.Context) RulesetRuleConditionsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleConditionsOutput).ToRulesetRuleConditionsPtrOutputWithContext(ctx)
}

// RulesetRuleConditionsPtrInput is an input type that accepts RulesetRuleConditionsArgs, RulesetRuleConditionsPtr and RulesetRuleConditionsPtrOutput values.
// You can construct a concrete instance of `RulesetRuleConditionsPtrInput` via:
//
// 		 RulesetRuleConditionsArgs{...}
//
//  or:
//
// 		 nil
//
type RulesetRuleConditionsPtrInput interface {
	pulumi.Input

	ToRulesetRuleConditionsPtrOutput() RulesetRuleConditionsPtrOutput
	ToRulesetRuleConditionsPtrOutputWithContext(context.Context) RulesetRuleConditionsPtrOutput
}

type rulesetRuleConditionsPtrType RulesetRuleConditionsArgs

func RulesetRuleConditionsPtr(v *RulesetRuleConditionsArgs) RulesetRuleConditionsPtrInput {
	return (*rulesetRuleConditionsPtrType)(v)
}

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

func (i *rulesetRuleConditionsPtrType) ToRulesetRuleConditionsPtrOutput() RulesetRuleConditionsPtrOutput {
	return i.ToRulesetRuleConditionsPtrOutputWithContext(context.Background())
}

func (i *rulesetRuleConditionsPtrType) ToRulesetRuleConditionsPtrOutputWithContext(ctx context.Context) RulesetRuleConditionsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleConditionsPtrOutput)
}

type RulesetRuleConditionsOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleConditionsOutput) ToRulesetRuleConditionsOutput() RulesetRuleConditionsOutput {
	return o
}

func (o RulesetRuleConditionsOutput) ToRulesetRuleConditionsOutputWithContext(ctx context.Context) RulesetRuleConditionsOutput {
	return o
}

func (o RulesetRuleConditionsOutput) ToRulesetRuleConditionsPtrOutput() RulesetRuleConditionsPtrOutput {
	return o.ToRulesetRuleConditionsPtrOutputWithContext(context.Background())
}

func (o RulesetRuleConditionsOutput) ToRulesetRuleConditionsPtrOutputWithContext(ctx context.Context) RulesetRuleConditionsPtrOutput {
	return o.ApplyT(func(v RulesetRuleConditions) *RulesetRuleConditions {
		return &v
	}).(RulesetRuleConditionsPtrOutput)
}

// Operator to combine sub-conditions. Can be `and` or `or`.
func (o RulesetRuleConditionsOutput) Operator() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RulesetRuleConditions) *string { return v.Operator }).(pulumi.StringPtrOutput)
}

// List of sub-conditions that define the the condition.
func (o RulesetRuleConditionsOutput) Subconditions() RulesetRuleConditionsSubconditionArrayOutput {
	return o.ApplyT(func(v RulesetRuleConditions) []RulesetRuleConditionsSubcondition { return v.Subconditions }).(RulesetRuleConditionsSubconditionArrayOutput)
}

type RulesetRuleConditionsPtrOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleConditionsPtrOutput) ToRulesetRuleConditionsPtrOutput() RulesetRuleConditionsPtrOutput {
	return o
}

func (o RulesetRuleConditionsPtrOutput) ToRulesetRuleConditionsPtrOutputWithContext(ctx context.Context) RulesetRuleConditionsPtrOutput {
	return o
}

func (o RulesetRuleConditionsPtrOutput) Elem() RulesetRuleConditionsOutput {
	return o.ApplyT(func(v *RulesetRuleConditions) RulesetRuleConditions { return *v }).(RulesetRuleConditionsOutput)
}

// Operator to combine sub-conditions. Can be `and` or `or`.
func (o RulesetRuleConditionsPtrOutput) Operator() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *RulesetRuleConditions) *string {
		if v == nil {
			return nil
		}
		return v.Operator
	}).(pulumi.StringPtrOutput)
}

// List of sub-conditions that define the the condition.
func (o RulesetRuleConditionsPtrOutput) Subconditions() RulesetRuleConditionsSubconditionArrayOutput {
	return o.ApplyT(func(v *RulesetRuleConditions) []RulesetRuleConditionsSubcondition {
		if v == nil {
			return nil
		}
		return v.Subconditions
	}).(RulesetRuleConditionsSubconditionArrayOutput)
}

type RulesetRuleConditionsSubcondition struct {
	// Type of operator to apply to the sub-condition. Can be `exists`,`nexists`,`equals`,`nequals`,`contains`,`ncontains`,`matches`, or `nmatches`.
	Operator *string `pulumi:"operator"`
	// Parameter for the sub-condition. It requires both a `path` and `value` to be set.
	Parameters []RulesetRuleConditionsSubconditionParameter `pulumi:"parameters"`
}

// RulesetRuleConditionsSubconditionInput is an input type that accepts RulesetRuleConditionsSubconditionArgs and RulesetRuleConditionsSubconditionOutput values.
// You can construct a concrete instance of `RulesetRuleConditionsSubconditionInput` via:
//
// 		 RulesetRuleConditionsSubconditionArgs{...}
//
type RulesetRuleConditionsSubconditionInput interface {
	pulumi.Input

	ToRulesetRuleConditionsSubconditionOutput() RulesetRuleConditionsSubconditionOutput
	ToRulesetRuleConditionsSubconditionOutputWithContext(context.Context) RulesetRuleConditionsSubconditionOutput
}

type RulesetRuleConditionsSubconditionArgs struct {
	// Type of operator to apply to the sub-condition. Can be `exists`,`nexists`,`equals`,`nequals`,`contains`,`ncontains`,`matches`, or `nmatches`.
	Operator pulumi.StringPtrInput `pulumi:"operator"`
	// Parameter for the sub-condition. It requires both a `path` and `value` to be set.
	Parameters RulesetRuleConditionsSubconditionParameterArrayInput `pulumi:"parameters"`
}

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

func (i RulesetRuleConditionsSubconditionArgs) ToRulesetRuleConditionsSubconditionOutput() RulesetRuleConditionsSubconditionOutput {
	return i.ToRulesetRuleConditionsSubconditionOutputWithContext(context.Background())
}

func (i RulesetRuleConditionsSubconditionArgs) ToRulesetRuleConditionsSubconditionOutputWithContext(ctx context.Context) RulesetRuleConditionsSubconditionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleConditionsSubconditionOutput)
}

// RulesetRuleConditionsSubconditionArrayInput is an input type that accepts RulesetRuleConditionsSubconditionArray and RulesetRuleConditionsSubconditionArrayOutput values.
// You can construct a concrete instance of `RulesetRuleConditionsSubconditionArrayInput` via:
//
// 		 RulesetRuleConditionsSubconditionArray{ RulesetRuleConditionsSubconditionArgs{...} }
//
type RulesetRuleConditionsSubconditionArrayInput interface {
	pulumi.Input

	ToRulesetRuleConditionsSubconditionArrayOutput() RulesetRuleConditionsSubconditionArrayOutput
	ToRulesetRuleConditionsSubconditionArrayOutputWithContext(context.Context) RulesetRuleConditionsSubconditionArrayOutput
}

type RulesetRuleConditionsSubconditionArray []RulesetRuleConditionsSubconditionInput

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

func (i RulesetRuleConditionsSubconditionArray) ToRulesetRuleConditionsSubconditionArrayOutput() RulesetRuleConditionsSubconditionArrayOutput {
	return i.ToRulesetRuleConditionsSubconditionArrayOutputWithContext(context.Background())
}

func (i RulesetRuleConditionsSubconditionArray) ToRulesetRuleConditionsSubconditionArrayOutputWithContext(ctx context.Context) RulesetRuleConditionsSubconditionArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleConditionsSubconditionArrayOutput)
}

type RulesetRuleConditionsSubconditionOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleConditionsSubconditionOutput) ToRulesetRuleConditionsSubconditionOutput() RulesetRuleConditionsSubconditionOutput {
	return o
}

func (o RulesetRuleConditionsSubconditionOutput) ToRulesetRuleConditionsSubconditionOutputWithContext(ctx context.Context) RulesetRuleConditionsSubconditionOutput {
	return o
}

// Type of operator to apply to the sub-condition. Can be `exists`,`nexists`,`equals`,`nequals`,`contains`,`ncontains`,`matches`, or `nmatches`.
func (o RulesetRuleConditionsSubconditionOutput) Operator() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RulesetRuleConditionsSubcondition) *string { return v.Operator }).(pulumi.StringPtrOutput)
}

// Parameter for the sub-condition. It requires both a `path` and `value` to be set.
func (o RulesetRuleConditionsSubconditionOutput) Parameters() RulesetRuleConditionsSubconditionParameterArrayOutput {
	return o.ApplyT(func(v RulesetRuleConditionsSubcondition) []RulesetRuleConditionsSubconditionParameter {
		return v.Parameters
	}).(RulesetRuleConditionsSubconditionParameterArrayOutput)
}

type RulesetRuleConditionsSubconditionArrayOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleConditionsSubconditionArrayOutput) ToRulesetRuleConditionsSubconditionArrayOutput() RulesetRuleConditionsSubconditionArrayOutput {
	return o
}

func (o RulesetRuleConditionsSubconditionArrayOutput) ToRulesetRuleConditionsSubconditionArrayOutputWithContext(ctx context.Context) RulesetRuleConditionsSubconditionArrayOutput {
	return o
}

func (o RulesetRuleConditionsSubconditionArrayOutput) Index(i pulumi.IntInput) RulesetRuleConditionsSubconditionOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) RulesetRuleConditionsSubcondition {
		return vs[0].([]RulesetRuleConditionsSubcondition)[vs[1].(int)]
	}).(RulesetRuleConditionsSubconditionOutput)
}

type RulesetRuleConditionsSubconditionParameter struct {
	Path *string `pulumi:"path"`
	// Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met.
	Value *string `pulumi:"value"`
}

// RulesetRuleConditionsSubconditionParameterInput is an input type that accepts RulesetRuleConditionsSubconditionParameterArgs and RulesetRuleConditionsSubconditionParameterOutput values.
// You can construct a concrete instance of `RulesetRuleConditionsSubconditionParameterInput` via:
//
// 		 RulesetRuleConditionsSubconditionParameterArgs{...}
//
type RulesetRuleConditionsSubconditionParameterInput interface {
	pulumi.Input

	ToRulesetRuleConditionsSubconditionParameterOutput() RulesetRuleConditionsSubconditionParameterOutput
	ToRulesetRuleConditionsSubconditionParameterOutputWithContext(context.Context) RulesetRuleConditionsSubconditionParameterOutput
}

type RulesetRuleConditionsSubconditionParameterArgs struct {
	Path pulumi.StringPtrInput `pulumi:"path"`
	// Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met.
	Value pulumi.StringPtrInput `pulumi:"value"`
}

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

func (i RulesetRuleConditionsSubconditionParameterArgs) ToRulesetRuleConditionsSubconditionParameterOutput() RulesetRuleConditionsSubconditionParameterOutput {
	return i.ToRulesetRuleConditionsSubconditionParameterOutputWithContext(context.Background())
}

func (i RulesetRuleConditionsSubconditionParameterArgs) ToRulesetRuleConditionsSubconditionParameterOutputWithContext(ctx context.Context) RulesetRuleConditionsSubconditionParameterOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleConditionsSubconditionParameterOutput)
}

// RulesetRuleConditionsSubconditionParameterArrayInput is an input type that accepts RulesetRuleConditionsSubconditionParameterArray and RulesetRuleConditionsSubconditionParameterArrayOutput values.
// You can construct a concrete instance of `RulesetRuleConditionsSubconditionParameterArrayInput` via:
//
// 		 RulesetRuleConditionsSubconditionParameterArray{ RulesetRuleConditionsSubconditionParameterArgs{...} }
//
type RulesetRuleConditionsSubconditionParameterArrayInput interface {
	pulumi.Input

	ToRulesetRuleConditionsSubconditionParameterArrayOutput() RulesetRuleConditionsSubconditionParameterArrayOutput
	ToRulesetRuleConditionsSubconditionParameterArrayOutputWithContext(context.Context) RulesetRuleConditionsSubconditionParameterArrayOutput
}

type RulesetRuleConditionsSubconditionParameterArray []RulesetRuleConditionsSubconditionParameterInput

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

func (i RulesetRuleConditionsSubconditionParameterArray) ToRulesetRuleConditionsSubconditionParameterArrayOutput() RulesetRuleConditionsSubconditionParameterArrayOutput {
	return i.ToRulesetRuleConditionsSubconditionParameterArrayOutputWithContext(context.Background())
}

func (i RulesetRuleConditionsSubconditionParameterArray) ToRulesetRuleConditionsSubconditionParameterArrayOutputWithContext(ctx context.Context) RulesetRuleConditionsSubconditionParameterArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleConditionsSubconditionParameterArrayOutput)
}

type RulesetRuleConditionsSubconditionParameterOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleConditionsSubconditionParameterOutput) ToRulesetRuleConditionsSubconditionParameterOutput() RulesetRuleConditionsSubconditionParameterOutput {
	return o
}

func (o RulesetRuleConditionsSubconditionParameterOutput) ToRulesetRuleConditionsSubconditionParameterOutputWithContext(ctx context.Context) RulesetRuleConditionsSubconditionParameterOutput {
	return o
}

func (o RulesetRuleConditionsSubconditionParameterOutput) Path() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RulesetRuleConditionsSubconditionParameter) *string { return v.Path }).(pulumi.StringPtrOutput)
}

// Boolean value that indicates if the alert should be suppressed before the indicated threshold values are met.
func (o RulesetRuleConditionsSubconditionParameterOutput) Value() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RulesetRuleConditionsSubconditionParameter) *string { return v.Value }).(pulumi.StringPtrOutput)
}

type RulesetRuleConditionsSubconditionParameterArrayOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleConditionsSubconditionParameterArrayOutput) ToRulesetRuleConditionsSubconditionParameterArrayOutput() RulesetRuleConditionsSubconditionParameterArrayOutput {
	return o
}

func (o RulesetRuleConditionsSubconditionParameterArrayOutput) ToRulesetRuleConditionsSubconditionParameterArrayOutputWithContext(ctx context.Context) RulesetRuleConditionsSubconditionParameterArrayOutput {
	return o
}

func (o RulesetRuleConditionsSubconditionParameterArrayOutput) Index(i pulumi.IntInput) RulesetRuleConditionsSubconditionParameterOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) RulesetRuleConditionsSubconditionParameter {
		return vs[0].([]RulesetRuleConditionsSubconditionParameter)[vs[1].(int)]
	}).(RulesetRuleConditionsSubconditionParameterOutput)
}

type RulesetRuleTimeFrame struct {
	// Values for executing the rule during a specific time period.
	ActiveBetweens []RulesetRuleTimeFrameActiveBetween `pulumi:"activeBetweens"`
	// Values for executing the rule on a recurring schedule.
	ScheduledWeeklies []RulesetRuleTimeFrameScheduledWeekly `pulumi:"scheduledWeeklies"`
}

// RulesetRuleTimeFrameInput is an input type that accepts RulesetRuleTimeFrameArgs and RulesetRuleTimeFrameOutput values.
// You can construct a concrete instance of `RulesetRuleTimeFrameInput` via:
//
// 		 RulesetRuleTimeFrameArgs{...}
//
type RulesetRuleTimeFrameInput interface {
	pulumi.Input

	ToRulesetRuleTimeFrameOutput() RulesetRuleTimeFrameOutput
	ToRulesetRuleTimeFrameOutputWithContext(context.Context) RulesetRuleTimeFrameOutput
}

type RulesetRuleTimeFrameArgs struct {
	// Values for executing the rule during a specific time period.
	ActiveBetweens RulesetRuleTimeFrameActiveBetweenArrayInput `pulumi:"activeBetweens"`
	// Values for executing the rule on a recurring schedule.
	ScheduledWeeklies RulesetRuleTimeFrameScheduledWeeklyArrayInput `pulumi:"scheduledWeeklies"`
}

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

func (i RulesetRuleTimeFrameArgs) ToRulesetRuleTimeFrameOutput() RulesetRuleTimeFrameOutput {
	return i.ToRulesetRuleTimeFrameOutputWithContext(context.Background())
}

func (i RulesetRuleTimeFrameArgs) ToRulesetRuleTimeFrameOutputWithContext(ctx context.Context) RulesetRuleTimeFrameOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleTimeFrameOutput)
}

func (i RulesetRuleTimeFrameArgs) ToRulesetRuleTimeFramePtrOutput() RulesetRuleTimeFramePtrOutput {
	return i.ToRulesetRuleTimeFramePtrOutputWithContext(context.Background())
}

func (i RulesetRuleTimeFrameArgs) ToRulesetRuleTimeFramePtrOutputWithContext(ctx context.Context) RulesetRuleTimeFramePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleTimeFrameOutput).ToRulesetRuleTimeFramePtrOutputWithContext(ctx)
}

// RulesetRuleTimeFramePtrInput is an input type that accepts RulesetRuleTimeFrameArgs, RulesetRuleTimeFramePtr and RulesetRuleTimeFramePtrOutput values.
// You can construct a concrete instance of `RulesetRuleTimeFramePtrInput` via:
//
// 		 RulesetRuleTimeFrameArgs{...}
//
//  or:
//
// 		 nil
//
type RulesetRuleTimeFramePtrInput interface {
	pulumi.Input

	ToRulesetRuleTimeFramePtrOutput() RulesetRuleTimeFramePtrOutput
	ToRulesetRuleTimeFramePtrOutputWithContext(context.Context) RulesetRuleTimeFramePtrOutput
}

type rulesetRuleTimeFramePtrType RulesetRuleTimeFrameArgs

func RulesetRuleTimeFramePtr(v *RulesetRuleTimeFrameArgs) RulesetRuleTimeFramePtrInput {
	return (*rulesetRuleTimeFramePtrType)(v)
}

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

func (i *rulesetRuleTimeFramePtrType) ToRulesetRuleTimeFramePtrOutput() RulesetRuleTimeFramePtrOutput {
	return i.ToRulesetRuleTimeFramePtrOutputWithContext(context.Background())
}

func (i *rulesetRuleTimeFramePtrType) ToRulesetRuleTimeFramePtrOutputWithContext(ctx context.Context) RulesetRuleTimeFramePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleTimeFramePtrOutput)
}

type RulesetRuleTimeFrameOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleTimeFrameOutput) ToRulesetRuleTimeFrameOutput() RulesetRuleTimeFrameOutput {
	return o
}

func (o RulesetRuleTimeFrameOutput) ToRulesetRuleTimeFrameOutputWithContext(ctx context.Context) RulesetRuleTimeFrameOutput {
	return o
}

func (o RulesetRuleTimeFrameOutput) ToRulesetRuleTimeFramePtrOutput() RulesetRuleTimeFramePtrOutput {
	return o.ToRulesetRuleTimeFramePtrOutputWithContext(context.Background())
}

func (o RulesetRuleTimeFrameOutput) ToRulesetRuleTimeFramePtrOutputWithContext(ctx context.Context) RulesetRuleTimeFramePtrOutput {
	return o.ApplyT(func(v RulesetRuleTimeFrame) *RulesetRuleTimeFrame {
		return &v
	}).(RulesetRuleTimeFramePtrOutput)
}

// Values for executing the rule during a specific time period.
func (o RulesetRuleTimeFrameOutput) ActiveBetweens() RulesetRuleTimeFrameActiveBetweenArrayOutput {
	return o.ApplyT(func(v RulesetRuleTimeFrame) []RulesetRuleTimeFrameActiveBetween { return v.ActiveBetweens }).(RulesetRuleTimeFrameActiveBetweenArrayOutput)
}

// Values for executing the rule on a recurring schedule.
func (o RulesetRuleTimeFrameOutput) ScheduledWeeklies() RulesetRuleTimeFrameScheduledWeeklyArrayOutput {
	return o.ApplyT(func(v RulesetRuleTimeFrame) []RulesetRuleTimeFrameScheduledWeekly { return v.ScheduledWeeklies }).(RulesetRuleTimeFrameScheduledWeeklyArrayOutput)
}

type RulesetRuleTimeFramePtrOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleTimeFramePtrOutput) ToRulesetRuleTimeFramePtrOutput() RulesetRuleTimeFramePtrOutput {
	return o
}

func (o RulesetRuleTimeFramePtrOutput) ToRulesetRuleTimeFramePtrOutputWithContext(ctx context.Context) RulesetRuleTimeFramePtrOutput {
	return o
}

func (o RulesetRuleTimeFramePtrOutput) Elem() RulesetRuleTimeFrameOutput {
	return o.ApplyT(func(v *RulesetRuleTimeFrame) RulesetRuleTimeFrame { return *v }).(RulesetRuleTimeFrameOutput)
}

// Values for executing the rule during a specific time period.
func (o RulesetRuleTimeFramePtrOutput) ActiveBetweens() RulesetRuleTimeFrameActiveBetweenArrayOutput {
	return o.ApplyT(func(v *RulesetRuleTimeFrame) []RulesetRuleTimeFrameActiveBetween {
		if v == nil {
			return nil
		}
		return v.ActiveBetweens
	}).(RulesetRuleTimeFrameActiveBetweenArrayOutput)
}

// Values for executing the rule on a recurring schedule.
func (o RulesetRuleTimeFramePtrOutput) ScheduledWeeklies() RulesetRuleTimeFrameScheduledWeeklyArrayOutput {
	return o.ApplyT(func(v *RulesetRuleTimeFrame) []RulesetRuleTimeFrameScheduledWeekly {
		if v == nil {
			return nil
		}
		return v.ScheduledWeeklies
	}).(RulesetRuleTimeFrameScheduledWeeklyArrayOutput)
}

type RulesetRuleTimeFrameActiveBetween struct {
	// Ending of the scheduled time when the rule should execute.  Unix timestamp in milliseconds.
	EndTime *int `pulumi:"endTime"`
	// Time when the schedule will start. Unix timestamp in milliseconds. For example, if you have a rule with a `startTime` of `0` and a `duration` of `60,000` then that rule would be active from `00:00` to `00:01`. If the `startTime` was `3,600,000` the it would be active starting at `01:00`.
	StartTime *int `pulumi:"startTime"`
}

// RulesetRuleTimeFrameActiveBetweenInput is an input type that accepts RulesetRuleTimeFrameActiveBetweenArgs and RulesetRuleTimeFrameActiveBetweenOutput values.
// You can construct a concrete instance of `RulesetRuleTimeFrameActiveBetweenInput` via:
//
// 		 RulesetRuleTimeFrameActiveBetweenArgs{...}
//
type RulesetRuleTimeFrameActiveBetweenInput interface {
	pulumi.Input

	ToRulesetRuleTimeFrameActiveBetweenOutput() RulesetRuleTimeFrameActiveBetweenOutput
	ToRulesetRuleTimeFrameActiveBetweenOutputWithContext(context.Context) RulesetRuleTimeFrameActiveBetweenOutput
}

type RulesetRuleTimeFrameActiveBetweenArgs struct {
	// Ending of the scheduled time when the rule should execute.  Unix timestamp in milliseconds.
	EndTime pulumi.IntPtrInput `pulumi:"endTime"`
	// Time when the schedule will start. Unix timestamp in milliseconds. For example, if you have a rule with a `startTime` of `0` and a `duration` of `60,000` then that rule would be active from `00:00` to `00:01`. If the `startTime` was `3,600,000` the it would be active starting at `01:00`.
	StartTime pulumi.IntPtrInput `pulumi:"startTime"`
}

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

func (i RulesetRuleTimeFrameActiveBetweenArgs) ToRulesetRuleTimeFrameActiveBetweenOutput() RulesetRuleTimeFrameActiveBetweenOutput {
	return i.ToRulesetRuleTimeFrameActiveBetweenOutputWithContext(context.Background())
}

func (i RulesetRuleTimeFrameActiveBetweenArgs) ToRulesetRuleTimeFrameActiveBetweenOutputWithContext(ctx context.Context) RulesetRuleTimeFrameActiveBetweenOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleTimeFrameActiveBetweenOutput)
}

// RulesetRuleTimeFrameActiveBetweenArrayInput is an input type that accepts RulesetRuleTimeFrameActiveBetweenArray and RulesetRuleTimeFrameActiveBetweenArrayOutput values.
// You can construct a concrete instance of `RulesetRuleTimeFrameActiveBetweenArrayInput` via:
//
// 		 RulesetRuleTimeFrameActiveBetweenArray{ RulesetRuleTimeFrameActiveBetweenArgs{...} }
//
type RulesetRuleTimeFrameActiveBetweenArrayInput interface {
	pulumi.Input

	ToRulesetRuleTimeFrameActiveBetweenArrayOutput() RulesetRuleTimeFrameActiveBetweenArrayOutput
	ToRulesetRuleTimeFrameActiveBetweenArrayOutputWithContext(context.Context) RulesetRuleTimeFrameActiveBetweenArrayOutput
}

type RulesetRuleTimeFrameActiveBetweenArray []RulesetRuleTimeFrameActiveBetweenInput

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

func (i RulesetRuleTimeFrameActiveBetweenArray) ToRulesetRuleTimeFrameActiveBetweenArrayOutput() RulesetRuleTimeFrameActiveBetweenArrayOutput {
	return i.ToRulesetRuleTimeFrameActiveBetweenArrayOutputWithContext(context.Background())
}

func (i RulesetRuleTimeFrameActiveBetweenArray) ToRulesetRuleTimeFrameActiveBetweenArrayOutputWithContext(ctx context.Context) RulesetRuleTimeFrameActiveBetweenArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleTimeFrameActiveBetweenArrayOutput)
}

type RulesetRuleTimeFrameActiveBetweenOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleTimeFrameActiveBetweenOutput) ToRulesetRuleTimeFrameActiveBetweenOutput() RulesetRuleTimeFrameActiveBetweenOutput {
	return o
}

func (o RulesetRuleTimeFrameActiveBetweenOutput) ToRulesetRuleTimeFrameActiveBetweenOutputWithContext(ctx context.Context) RulesetRuleTimeFrameActiveBetweenOutput {
	return o
}

// Ending of the scheduled time when the rule should execute.  Unix timestamp in milliseconds.
func (o RulesetRuleTimeFrameActiveBetweenOutput) EndTime() pulumi.IntPtrOutput {
	return o.ApplyT(func(v RulesetRuleTimeFrameActiveBetween) *int { return v.EndTime }).(pulumi.IntPtrOutput)
}

// Time when the schedule will start. Unix timestamp in milliseconds. For example, if you have a rule with a `startTime` of `0` and a `duration` of `60,000` then that rule would be active from `00:00` to `00:01`. If the `startTime` was `3,600,000` the it would be active starting at `01:00`.
func (o RulesetRuleTimeFrameActiveBetweenOutput) StartTime() pulumi.IntPtrOutput {
	return o.ApplyT(func(v RulesetRuleTimeFrameActiveBetween) *int { return v.StartTime }).(pulumi.IntPtrOutput)
}

type RulesetRuleTimeFrameActiveBetweenArrayOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleTimeFrameActiveBetweenArrayOutput) ToRulesetRuleTimeFrameActiveBetweenArrayOutput() RulesetRuleTimeFrameActiveBetweenArrayOutput {
	return o
}

func (o RulesetRuleTimeFrameActiveBetweenArrayOutput) ToRulesetRuleTimeFrameActiveBetweenArrayOutputWithContext(ctx context.Context) RulesetRuleTimeFrameActiveBetweenArrayOutput {
	return o
}

func (o RulesetRuleTimeFrameActiveBetweenArrayOutput) Index(i pulumi.IntInput) RulesetRuleTimeFrameActiveBetweenOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) RulesetRuleTimeFrameActiveBetween {
		return vs[0].([]RulesetRuleTimeFrameActiveBetween)[vs[1].(int)]
	}).(RulesetRuleTimeFrameActiveBetweenOutput)
}

type RulesetRuleTimeFrameScheduledWeekly struct {
	// Length of time the schedule will be active.  Unix timestamp in milliseconds.
	Duration *int `pulumi:"duration"`
	// Time when the schedule will start. Unix timestamp in milliseconds. For example, if you have a rule with a `startTime` of `0` and a `duration` of `60,000` then that rule would be active from `00:00` to `00:01`. If the `startTime` was `3,600,000` the it would be active starting at `01:00`.
	StartTime *int `pulumi:"startTime"`
	// Timezone for the given schedule.
	Timezone *string `pulumi:"timezone"`
	// An integer array representing which days during the week the rule executes. For example `weekdays = [1,3,7]` would execute on Monday, Wednesday and Sunday.
	Weekdays []int `pulumi:"weekdays"`
}

// RulesetRuleTimeFrameScheduledWeeklyInput is an input type that accepts RulesetRuleTimeFrameScheduledWeeklyArgs and RulesetRuleTimeFrameScheduledWeeklyOutput values.
// You can construct a concrete instance of `RulesetRuleTimeFrameScheduledWeeklyInput` via:
//
// 		 RulesetRuleTimeFrameScheduledWeeklyArgs{...}
//
type RulesetRuleTimeFrameScheduledWeeklyInput interface {
	pulumi.Input

	ToRulesetRuleTimeFrameScheduledWeeklyOutput() RulesetRuleTimeFrameScheduledWeeklyOutput
	ToRulesetRuleTimeFrameScheduledWeeklyOutputWithContext(context.Context) RulesetRuleTimeFrameScheduledWeeklyOutput
}

type RulesetRuleTimeFrameScheduledWeeklyArgs struct {
	// Length of time the schedule will be active.  Unix timestamp in milliseconds.
	Duration pulumi.IntPtrInput `pulumi:"duration"`
	// Time when the schedule will start. Unix timestamp in milliseconds. For example, if you have a rule with a `startTime` of `0` and a `duration` of `60,000` then that rule would be active from `00:00` to `00:01`. If the `startTime` was `3,600,000` the it would be active starting at `01:00`.
	StartTime pulumi.IntPtrInput `pulumi:"startTime"`
	// Timezone for the given schedule.
	Timezone pulumi.StringPtrInput `pulumi:"timezone"`
	// An integer array representing which days during the week the rule executes. For example `weekdays = [1,3,7]` would execute on Monday, Wednesday and Sunday.
	Weekdays pulumi.IntArrayInput `pulumi:"weekdays"`
}

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

func (i RulesetRuleTimeFrameScheduledWeeklyArgs) ToRulesetRuleTimeFrameScheduledWeeklyOutput() RulesetRuleTimeFrameScheduledWeeklyOutput {
	return i.ToRulesetRuleTimeFrameScheduledWeeklyOutputWithContext(context.Background())
}

func (i RulesetRuleTimeFrameScheduledWeeklyArgs) ToRulesetRuleTimeFrameScheduledWeeklyOutputWithContext(ctx context.Context) RulesetRuleTimeFrameScheduledWeeklyOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleTimeFrameScheduledWeeklyOutput)
}

// RulesetRuleTimeFrameScheduledWeeklyArrayInput is an input type that accepts RulesetRuleTimeFrameScheduledWeeklyArray and RulesetRuleTimeFrameScheduledWeeklyArrayOutput values.
// You can construct a concrete instance of `RulesetRuleTimeFrameScheduledWeeklyArrayInput` via:
//
// 		 RulesetRuleTimeFrameScheduledWeeklyArray{ RulesetRuleTimeFrameScheduledWeeklyArgs{...} }
//
type RulesetRuleTimeFrameScheduledWeeklyArrayInput interface {
	pulumi.Input

	ToRulesetRuleTimeFrameScheduledWeeklyArrayOutput() RulesetRuleTimeFrameScheduledWeeklyArrayOutput
	ToRulesetRuleTimeFrameScheduledWeeklyArrayOutputWithContext(context.Context) RulesetRuleTimeFrameScheduledWeeklyArrayOutput
}

type RulesetRuleTimeFrameScheduledWeeklyArray []RulesetRuleTimeFrameScheduledWeeklyInput

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

func (i RulesetRuleTimeFrameScheduledWeeklyArray) ToRulesetRuleTimeFrameScheduledWeeklyArrayOutput() RulesetRuleTimeFrameScheduledWeeklyArrayOutput {
	return i.ToRulesetRuleTimeFrameScheduledWeeklyArrayOutputWithContext(context.Background())
}

func (i RulesetRuleTimeFrameScheduledWeeklyArray) ToRulesetRuleTimeFrameScheduledWeeklyArrayOutputWithContext(ctx context.Context) RulesetRuleTimeFrameScheduledWeeklyArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetRuleTimeFrameScheduledWeeklyArrayOutput)
}

type RulesetRuleTimeFrameScheduledWeeklyOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleTimeFrameScheduledWeeklyOutput) ToRulesetRuleTimeFrameScheduledWeeklyOutput() RulesetRuleTimeFrameScheduledWeeklyOutput {
	return o
}

func (o RulesetRuleTimeFrameScheduledWeeklyOutput) ToRulesetRuleTimeFrameScheduledWeeklyOutputWithContext(ctx context.Context) RulesetRuleTimeFrameScheduledWeeklyOutput {
	return o
}

// Length of time the schedule will be active.  Unix timestamp in milliseconds.
func (o RulesetRuleTimeFrameScheduledWeeklyOutput) Duration() pulumi.IntPtrOutput {
	return o.ApplyT(func(v RulesetRuleTimeFrameScheduledWeekly) *int { return v.Duration }).(pulumi.IntPtrOutput)
}

// Time when the schedule will start. Unix timestamp in milliseconds. For example, if you have a rule with a `startTime` of `0` and a `duration` of `60,000` then that rule would be active from `00:00` to `00:01`. If the `startTime` was `3,600,000` the it would be active starting at `01:00`.
func (o RulesetRuleTimeFrameScheduledWeeklyOutput) StartTime() pulumi.IntPtrOutput {
	return o.ApplyT(func(v RulesetRuleTimeFrameScheduledWeekly) *int { return v.StartTime }).(pulumi.IntPtrOutput)
}

// Timezone for the given schedule.
func (o RulesetRuleTimeFrameScheduledWeeklyOutput) Timezone() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RulesetRuleTimeFrameScheduledWeekly) *string { return v.Timezone }).(pulumi.StringPtrOutput)
}

// An integer array representing which days during the week the rule executes. For example `weekdays = [1,3,7]` would execute on Monday, Wednesday and Sunday.
func (o RulesetRuleTimeFrameScheduledWeeklyOutput) Weekdays() pulumi.IntArrayOutput {
	return o.ApplyT(func(v RulesetRuleTimeFrameScheduledWeekly) []int { return v.Weekdays }).(pulumi.IntArrayOutput)
}

type RulesetRuleTimeFrameScheduledWeeklyArrayOutput struct{ *pulumi.OutputState }

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

func (o RulesetRuleTimeFrameScheduledWeeklyArrayOutput) ToRulesetRuleTimeFrameScheduledWeeklyArrayOutput() RulesetRuleTimeFrameScheduledWeeklyArrayOutput {
	return o
}

func (o RulesetRuleTimeFrameScheduledWeeklyArrayOutput) ToRulesetRuleTimeFrameScheduledWeeklyArrayOutputWithContext(ctx context.Context) RulesetRuleTimeFrameScheduledWeeklyArrayOutput {
	return o
}

func (o RulesetRuleTimeFrameScheduledWeeklyArrayOutput) Index(i pulumi.IntInput) RulesetRuleTimeFrameScheduledWeeklyOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) RulesetRuleTimeFrameScheduledWeekly {
		return vs[0].([]RulesetRuleTimeFrameScheduledWeekly)[vs[1].(int)]
	}).(RulesetRuleTimeFrameScheduledWeeklyOutput)
}

type RulesetTeam struct {
	// The ID of the ruleset.
	Id string `pulumi:"id"`
}

// RulesetTeamInput is an input type that accepts RulesetTeamArgs and RulesetTeamOutput values.
// You can construct a concrete instance of `RulesetTeamInput` via:
//
// 		 RulesetTeamArgs{...}
//
type RulesetTeamInput interface {
	pulumi.Input

	ToRulesetTeamOutput() RulesetTeamOutput
	ToRulesetTeamOutputWithContext(context.Context) RulesetTeamOutput
}

type RulesetTeamArgs struct {
	// The ID of the ruleset.
	Id pulumi.StringInput `pulumi:"id"`
}

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

func (i RulesetTeamArgs) ToRulesetTeamOutput() RulesetTeamOutput {
	return i.ToRulesetTeamOutputWithContext(context.Background())
}

func (i RulesetTeamArgs) ToRulesetTeamOutputWithContext(ctx context.Context) RulesetTeamOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetTeamOutput)
}

func (i RulesetTeamArgs) ToRulesetTeamPtrOutput() RulesetTeamPtrOutput {
	return i.ToRulesetTeamPtrOutputWithContext(context.Background())
}

func (i RulesetTeamArgs) ToRulesetTeamPtrOutputWithContext(ctx context.Context) RulesetTeamPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetTeamOutput).ToRulesetTeamPtrOutputWithContext(ctx)
}

// RulesetTeamPtrInput is an input type that accepts RulesetTeamArgs, RulesetTeamPtr and RulesetTeamPtrOutput values.
// You can construct a concrete instance of `RulesetTeamPtrInput` via:
//
// 		 RulesetTeamArgs{...}
//
//  or:
//
// 		 nil
//
type RulesetTeamPtrInput interface {
	pulumi.Input

	ToRulesetTeamPtrOutput() RulesetTeamPtrOutput
	ToRulesetTeamPtrOutputWithContext(context.Context) RulesetTeamPtrOutput
}

type rulesetTeamPtrType RulesetTeamArgs

func RulesetTeamPtr(v *RulesetTeamArgs) RulesetTeamPtrInput {
	return (*rulesetTeamPtrType)(v)
}

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

func (i *rulesetTeamPtrType) ToRulesetTeamPtrOutput() RulesetTeamPtrOutput {
	return i.ToRulesetTeamPtrOutputWithContext(context.Background())
}

func (i *rulesetTeamPtrType) ToRulesetTeamPtrOutputWithContext(ctx context.Context) RulesetTeamPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RulesetTeamPtrOutput)
}

type RulesetTeamOutput struct{ *pulumi.OutputState }

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

func (o RulesetTeamOutput) ToRulesetTeamOutput() RulesetTeamOutput {
	return o
}

func (o RulesetTeamOutput) ToRulesetTeamOutputWithContext(ctx context.Context) RulesetTeamOutput {
	return o
}

func (o RulesetTeamOutput) ToRulesetTeamPtrOutput() RulesetTeamPtrOutput {
	return o.ToRulesetTeamPtrOutputWithContext(context.Background())
}

func (o RulesetTeamOutput) ToRulesetTeamPtrOutputWithContext(ctx context.Context) RulesetTeamPtrOutput {
	return o.ApplyT(func(v RulesetTeam) *RulesetTeam {
		return &v
	}).(RulesetTeamPtrOutput)
}

// The ID of the ruleset.
func (o RulesetTeamOutput) Id() pulumi.StringOutput {
	return o.ApplyT(func(v RulesetTeam) string { return v.Id }).(pulumi.StringOutput)
}

type RulesetTeamPtrOutput struct{ *pulumi.OutputState }

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

func (o RulesetTeamPtrOutput) ToRulesetTeamPtrOutput() RulesetTeamPtrOutput {
	return o
}

func (o RulesetTeamPtrOutput) ToRulesetTeamPtrOutputWithContext(ctx context.Context) RulesetTeamPtrOutput {
	return o
}

func (o RulesetTeamPtrOutput) Elem() RulesetTeamOutput {
	return o.ApplyT(func(v *RulesetTeam) RulesetTeam { return *v }).(RulesetTeamOutput)
}

// The ID of the ruleset.
func (o RulesetTeamPtrOutput) Id() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *RulesetTeam) *string {
		if v == nil {
			return nil
		}
		return &v.Id
	}).(pulumi.StringPtrOutput)
}

type ScheduleLayer struct {
	// The end time of the schedule layer. If not specified, the layer does not end.
	End *string `pulumi:"end"`
	// The ID of the schedule
	Id *string `pulumi:"id"`
	// The name of the schedule layer.
	Name *string `pulumi:"name"`
	// A schedule layer restriction block. Restriction blocks documented below.
	Restrictions []ScheduleLayerRestriction `pulumi:"restrictions"`
	// The duration of each on-call shift in `seconds`.
	RotationTurnLengthSeconds int `pulumi:"rotationTurnLengthSeconds"`
	// The effective start time of the schedule layer. This can be before the start time of the schedule.
	RotationVirtualStart string `pulumi:"rotationVirtualStart"`
	// The start time of the schedule layer. This value will not be read back from the PagerDuty API because the API will always return a new `start` time, which represents the last updated time of the schedule layer.
	Start string `pulumi:"start"`
	// The ordered list of users on this layer. The position of the user on the list determines their order in the layer.
	Users []string `pulumi:"users"`
}

// ScheduleLayerInput is an input type that accepts ScheduleLayerArgs and ScheduleLayerOutput values.
// You can construct a concrete instance of `ScheduleLayerInput` via:
//
// 		 ScheduleLayerArgs{...}
//
type ScheduleLayerInput interface {
	pulumi.Input

	ToScheduleLayerOutput() ScheduleLayerOutput
	ToScheduleLayerOutputWithContext(context.Context) ScheduleLayerOutput
}

type ScheduleLayerArgs struct {
	// The end time of the schedule layer. If not specified, the layer does not end.
	End pulumi.StringPtrInput `pulumi:"end"`
	// The ID of the schedule
	Id pulumi.StringPtrInput `pulumi:"id"`
	// The name of the schedule layer.
	Name pulumi.StringPtrInput `pulumi:"name"`
	// A schedule layer restriction block. Restriction blocks documented below.
	Restrictions ScheduleLayerRestrictionArrayInput `pulumi:"restrictions"`
	// The duration of each on-call shift in `seconds`.
	RotationTurnLengthSeconds pulumi.IntInput `pulumi:"rotationTurnLengthSeconds"`
	// The effective start time of the schedule layer. This can be before the start time of the schedule.
	RotationVirtualStart pulumi.StringInput `pulumi:"rotationVirtualStart"`
	// The start time of the schedule layer. This value will not be read back from the PagerDuty API because the API will always return a new `start` time, which represents the last updated time of the schedule layer.
	Start pulumi.StringInput `pulumi:"start"`
	// The ordered list of users on this layer. The position of the user on the list determines their order in the layer.
	Users pulumi.StringArrayInput `pulumi:"users"`
}

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

func (i ScheduleLayerArgs) ToScheduleLayerOutput() ScheduleLayerOutput {
	return i.ToScheduleLayerOutputWithContext(context.Background())
}

func (i ScheduleLayerArgs) ToScheduleLayerOutputWithContext(ctx context.Context) ScheduleLayerOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ScheduleLayerOutput)
}

// ScheduleLayerArrayInput is an input type that accepts ScheduleLayerArray and ScheduleLayerArrayOutput values.
// You can construct a concrete instance of `ScheduleLayerArrayInput` via:
//
// 		 ScheduleLayerArray{ ScheduleLayerArgs{...} }
//
type ScheduleLayerArrayInput interface {
	pulumi.Input

	ToScheduleLayerArrayOutput() ScheduleLayerArrayOutput
	ToScheduleLayerArrayOutputWithContext(context.Context) ScheduleLayerArrayOutput
}

type ScheduleLayerArray []ScheduleLayerInput

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

func (i ScheduleLayerArray) ToScheduleLayerArrayOutput() ScheduleLayerArrayOutput {
	return i.ToScheduleLayerArrayOutputWithContext(context.Background())
}

func (i ScheduleLayerArray) ToScheduleLayerArrayOutputWithContext(ctx context.Context) ScheduleLayerArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ScheduleLayerArrayOutput)
}

type ScheduleLayerOutput struct{ *pulumi.OutputState }

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

func (o ScheduleLayerOutput) ToScheduleLayerOutput() ScheduleLayerOutput {
	return o
}

func (o ScheduleLayerOutput) ToScheduleLayerOutputWithContext(ctx context.Context) ScheduleLayerOutput {
	return o
}

// The end time of the schedule layer. If not specified, the layer does not end.
func (o ScheduleLayerOutput) End() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ScheduleLayer) *string { return v.End }).(pulumi.StringPtrOutput)
}

// The ID of the schedule
func (o ScheduleLayerOutput) Id() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ScheduleLayer) *string { return v.Id }).(pulumi.StringPtrOutput)
}

// The name of the schedule layer.
func (o ScheduleLayerOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ScheduleLayer) *string { return v.Name }).(pulumi.StringPtrOutput)
}

// A schedule layer restriction block. Restriction blocks documented below.
func (o ScheduleLayerOutput) Restrictions() ScheduleLayerRestrictionArrayOutput {
	return o.ApplyT(func(v ScheduleLayer) []ScheduleLayerRestriction { return v.Restrictions }).(ScheduleLayerRestrictionArrayOutput)
}

// The duration of each on-call shift in `seconds`.
func (o ScheduleLayerOutput) RotationTurnLengthSeconds() pulumi.IntOutput {
	return o.ApplyT(func(v ScheduleLayer) int { return v.RotationTurnLengthSeconds }).(pulumi.IntOutput)
}

// The effective start time of the schedule layer. This can be before the start time of the schedule.
func (o ScheduleLayerOutput) RotationVirtualStart() pulumi.StringOutput {
	return o.ApplyT(func(v ScheduleLayer) string { return v.RotationVirtualStart }).(pulumi.StringOutput)
}

// The start time of the schedule layer. This value will not be read back from the PagerDuty API because the API will always return a new `start` time, which represents the last updated time of the schedule layer.
func (o ScheduleLayerOutput) Start() pulumi.StringOutput {
	return o.ApplyT(func(v ScheduleLayer) string { return v.Start }).(pulumi.StringOutput)
}

// The ordered list of users on this layer. The position of the user on the list determines their order in the layer.
func (o ScheduleLayerOutput) Users() pulumi.StringArrayOutput {
	return o.ApplyT(func(v ScheduleLayer) []string { return v.Users }).(pulumi.StringArrayOutput)
}

type ScheduleLayerArrayOutput struct{ *pulumi.OutputState }

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

func (o ScheduleLayerArrayOutput) ToScheduleLayerArrayOutput() ScheduleLayerArrayOutput {
	return o
}

func (o ScheduleLayerArrayOutput) ToScheduleLayerArrayOutputWithContext(ctx context.Context) ScheduleLayerArrayOutput {
	return o
}

func (o ScheduleLayerArrayOutput) Index(i pulumi.IntInput) ScheduleLayerOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ScheduleLayer {
		return vs[0].([]ScheduleLayer)[vs[1].(int)]
	}).(ScheduleLayerOutput)
}

type ScheduleLayerRestriction struct {
	// The duration of the restriction in `seconds`.
	DurationSeconds int `pulumi:"durationSeconds"`
	// Number of the day when restriction starts. From 1 to 7 where 1 is Monday and 7 is Sunday.
	StartDayOfWeek *int `pulumi:"startDayOfWeek"`
	// The start time in `HH:mm:ss` format.
	StartTimeOfDay string `pulumi:"startTimeOfDay"`
	// Can be `dailyRestriction` or `weeklyRestriction`
	Type string `pulumi:"type"`
}

// ScheduleLayerRestrictionInput is an input type that accepts ScheduleLayerRestrictionArgs and ScheduleLayerRestrictionOutput values.
// You can construct a concrete instance of `ScheduleLayerRestrictionInput` via:
//
// 		 ScheduleLayerRestrictionArgs{...}
//
type ScheduleLayerRestrictionInput interface {
	pulumi.Input

	ToScheduleLayerRestrictionOutput() ScheduleLayerRestrictionOutput
	ToScheduleLayerRestrictionOutputWithContext(context.Context) ScheduleLayerRestrictionOutput
}

type ScheduleLayerRestrictionArgs struct {
	// The duration of the restriction in `seconds`.
	DurationSeconds pulumi.IntInput `pulumi:"durationSeconds"`
	// Number of the day when restriction starts. From 1 to 7 where 1 is Monday and 7 is Sunday.
	StartDayOfWeek pulumi.IntPtrInput `pulumi:"startDayOfWeek"`
	// The start time in `HH:mm:ss` format.
	StartTimeOfDay pulumi.StringInput `pulumi:"startTimeOfDay"`
	// Can be `dailyRestriction` or `weeklyRestriction`
	Type pulumi.StringInput `pulumi:"type"`
}

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

func (i ScheduleLayerRestrictionArgs) ToScheduleLayerRestrictionOutput() ScheduleLayerRestrictionOutput {
	return i.ToScheduleLayerRestrictionOutputWithContext(context.Background())
}

func (i ScheduleLayerRestrictionArgs) ToScheduleLayerRestrictionOutputWithContext(ctx context.Context) ScheduleLayerRestrictionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ScheduleLayerRestrictionOutput)
}

// ScheduleLayerRestrictionArrayInput is an input type that accepts ScheduleLayerRestrictionArray and ScheduleLayerRestrictionArrayOutput values.
// You can construct a concrete instance of `ScheduleLayerRestrictionArrayInput` via:
//
// 		 ScheduleLayerRestrictionArray{ ScheduleLayerRestrictionArgs{...} }
//
type ScheduleLayerRestrictionArrayInput interface {
	pulumi.Input

	ToScheduleLayerRestrictionArrayOutput() ScheduleLayerRestrictionArrayOutput
	ToScheduleLayerRestrictionArrayOutputWithContext(context.Context) ScheduleLayerRestrictionArrayOutput
}

type ScheduleLayerRestrictionArray []ScheduleLayerRestrictionInput

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

func (i ScheduleLayerRestrictionArray) ToScheduleLayerRestrictionArrayOutput() ScheduleLayerRestrictionArrayOutput {
	return i.ToScheduleLayerRestrictionArrayOutputWithContext(context.Background())
}

func (i ScheduleLayerRestrictionArray) ToScheduleLayerRestrictionArrayOutputWithContext(ctx context.Context) ScheduleLayerRestrictionArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ScheduleLayerRestrictionArrayOutput)
}

type ScheduleLayerRestrictionOutput struct{ *pulumi.OutputState }

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

func (o ScheduleLayerRestrictionOutput) ToScheduleLayerRestrictionOutput() ScheduleLayerRestrictionOutput {
	return o
}

func (o ScheduleLayerRestrictionOutput) ToScheduleLayerRestrictionOutputWithContext(ctx context.Context) ScheduleLayerRestrictionOutput {
	return o
}

// The duration of the restriction in `seconds`.
func (o ScheduleLayerRestrictionOutput) DurationSeconds() pulumi.IntOutput {
	return o.ApplyT(func(v ScheduleLayerRestriction) int { return v.DurationSeconds }).(pulumi.IntOutput)
}

// Number of the day when restriction starts. From 1 to 7 where 1 is Monday and 7 is Sunday.
func (o ScheduleLayerRestrictionOutput) StartDayOfWeek() pulumi.IntPtrOutput {
	return o.ApplyT(func(v ScheduleLayerRestriction) *int { return v.StartDayOfWeek }).(pulumi.IntPtrOutput)
}

// The start time in `HH:mm:ss` format.
func (o ScheduleLayerRestrictionOutput) StartTimeOfDay() pulumi.StringOutput {
	return o.ApplyT(func(v ScheduleLayerRestriction) string { return v.StartTimeOfDay }).(pulumi.StringOutput)
}

// Can be `dailyRestriction` or `weeklyRestriction`
func (o ScheduleLayerRestrictionOutput) Type() pulumi.StringOutput {
	return o.ApplyT(func(v ScheduleLayerRestriction) string { return v.Type }).(pulumi.StringOutput)
}

type ScheduleLayerRestrictionArrayOutput struct{ *pulumi.OutputState }

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

func (o ScheduleLayerRestrictionArrayOutput) ToScheduleLayerRestrictionArrayOutput() ScheduleLayerRestrictionArrayOutput {
	return o
}

func (o ScheduleLayerRestrictionArrayOutput) ToScheduleLayerRestrictionArrayOutputWithContext(ctx context.Context) ScheduleLayerRestrictionArrayOutput {
	return o
}

func (o ScheduleLayerRestrictionArrayOutput) Index(i pulumi.IntInput) ScheduleLayerRestrictionOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ScheduleLayerRestriction {
		return vs[0].([]ScheduleLayerRestriction)[vs[1].(int)]
	}).(ScheduleLayerRestrictionOutput)
}

type ServiceDependencyDependency struct {
	// The service that id dependent on the supporting service.
	DependentServices []ServiceDependencyDependencyDependentService `pulumi:"dependentServices"`
	// The service that supports  the  dependent service.
	SupportingServices []ServiceDependencyDependencySupportingService `pulumi:"supportingServices"`
	Type               *string                                        `pulumi:"type"`
}

// ServiceDependencyDependencyInput is an input type that accepts ServiceDependencyDependencyArgs and ServiceDependencyDependencyOutput values.
// You can construct a concrete instance of `ServiceDependencyDependencyInput` via:
//
// 		 ServiceDependencyDependencyArgs{...}
//
type ServiceDependencyDependencyInput interface {
	pulumi.Input

	ToServiceDependencyDependencyOutput() ServiceDependencyDependencyOutput
	ToServiceDependencyDependencyOutputWithContext(context.Context) ServiceDependencyDependencyOutput
}

type ServiceDependencyDependencyArgs struct {
	// The service that id dependent on the supporting service.
	DependentServices ServiceDependencyDependencyDependentServiceArrayInput `pulumi:"dependentServices"`
	// The service that supports  the  dependent service.
	SupportingServices ServiceDependencyDependencySupportingServiceArrayInput `pulumi:"supportingServices"`
	Type               pulumi.StringPtrInput                                  `pulumi:"type"`
}

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

func (i ServiceDependencyDependencyArgs) ToServiceDependencyDependencyOutput() ServiceDependencyDependencyOutput {
	return i.ToServiceDependencyDependencyOutputWithContext(context.Background())
}

func (i ServiceDependencyDependencyArgs) ToServiceDependencyDependencyOutputWithContext(ctx context.Context) ServiceDependencyDependencyOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceDependencyDependencyOutput)
}

// ServiceDependencyDependencyArrayInput is an input type that accepts ServiceDependencyDependencyArray and ServiceDependencyDependencyArrayOutput values.
// You can construct a concrete instance of `ServiceDependencyDependencyArrayInput` via:
//
// 		 ServiceDependencyDependencyArray{ ServiceDependencyDependencyArgs{...} }
//
type ServiceDependencyDependencyArrayInput interface {
	pulumi.Input

	ToServiceDependencyDependencyArrayOutput() ServiceDependencyDependencyArrayOutput
	ToServiceDependencyDependencyArrayOutputWithContext(context.Context) ServiceDependencyDependencyArrayOutput
}

type ServiceDependencyDependencyArray []ServiceDependencyDependencyInput

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

func (i ServiceDependencyDependencyArray) ToServiceDependencyDependencyArrayOutput() ServiceDependencyDependencyArrayOutput {
	return i.ToServiceDependencyDependencyArrayOutputWithContext(context.Background())
}

func (i ServiceDependencyDependencyArray) ToServiceDependencyDependencyArrayOutputWithContext(ctx context.Context) ServiceDependencyDependencyArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceDependencyDependencyArrayOutput)
}

type ServiceDependencyDependencyOutput struct{ *pulumi.OutputState }

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

func (o ServiceDependencyDependencyOutput) ToServiceDependencyDependencyOutput() ServiceDependencyDependencyOutput {
	return o
}

func (o ServiceDependencyDependencyOutput) ToServiceDependencyDependencyOutputWithContext(ctx context.Context) ServiceDependencyDependencyOutput {
	return o
}

// The service that id dependent on the supporting service.
func (o ServiceDependencyDependencyOutput) DependentServices() ServiceDependencyDependencyDependentServiceArrayOutput {
	return o.ApplyT(func(v ServiceDependencyDependency) []ServiceDependencyDependencyDependentService {
		return v.DependentServices
	}).(ServiceDependencyDependencyDependentServiceArrayOutput)
}

// The service that supports  the  dependent service.
func (o ServiceDependencyDependencyOutput) SupportingServices() ServiceDependencyDependencySupportingServiceArrayOutput {
	return o.ApplyT(func(v ServiceDependencyDependency) []ServiceDependencyDependencySupportingService {
		return v.SupportingServices
	}).(ServiceDependencyDependencySupportingServiceArrayOutput)
}

func (o ServiceDependencyDependencyOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceDependencyDependency) *string { return v.Type }).(pulumi.StringPtrOutput)
}

type ServiceDependencyDependencyArrayOutput struct{ *pulumi.OutputState }

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

func (o ServiceDependencyDependencyArrayOutput) ToServiceDependencyDependencyArrayOutput() ServiceDependencyDependencyArrayOutput {
	return o
}

func (o ServiceDependencyDependencyArrayOutput) ToServiceDependencyDependencyArrayOutputWithContext(ctx context.Context) ServiceDependencyDependencyArrayOutput {
	return o
}

func (o ServiceDependencyDependencyArrayOutput) Index(i pulumi.IntInput) ServiceDependencyDependencyOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ServiceDependencyDependency {
		return vs[0].([]ServiceDependencyDependency)[vs[1].(int)]
	}).(ServiceDependencyDependencyOutput)
}

type ServiceDependencyDependencyDependentService struct {
	// The ID of the service dependency.
	Id   string `pulumi:"id"`
	Type string `pulumi:"type"`
}

// ServiceDependencyDependencyDependentServiceInput is an input type that accepts ServiceDependencyDependencyDependentServiceArgs and ServiceDependencyDependencyDependentServiceOutput values.
// You can construct a concrete instance of `ServiceDependencyDependencyDependentServiceInput` via:
//
// 		 ServiceDependencyDependencyDependentServiceArgs{...}
//
type ServiceDependencyDependencyDependentServiceInput interface {
	pulumi.Input

	ToServiceDependencyDependencyDependentServiceOutput() ServiceDependencyDependencyDependentServiceOutput
	ToServiceDependencyDependencyDependentServiceOutputWithContext(context.Context) ServiceDependencyDependencyDependentServiceOutput
}

type ServiceDependencyDependencyDependentServiceArgs struct {
	// The ID of the service dependency.
	Id   pulumi.StringInput `pulumi:"id"`
	Type pulumi.StringInput `pulumi:"type"`
}

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

func (i ServiceDependencyDependencyDependentServiceArgs) ToServiceDependencyDependencyDependentServiceOutput() ServiceDependencyDependencyDependentServiceOutput {
	return i.ToServiceDependencyDependencyDependentServiceOutputWithContext(context.Background())
}

func (i ServiceDependencyDependencyDependentServiceArgs) ToServiceDependencyDependencyDependentServiceOutputWithContext(ctx context.Context) ServiceDependencyDependencyDependentServiceOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceDependencyDependencyDependentServiceOutput)
}

// ServiceDependencyDependencyDependentServiceArrayInput is an input type that accepts ServiceDependencyDependencyDependentServiceArray and ServiceDependencyDependencyDependentServiceArrayOutput values.
// You can construct a concrete instance of `ServiceDependencyDependencyDependentServiceArrayInput` via:
//
// 		 ServiceDependencyDependencyDependentServiceArray{ ServiceDependencyDependencyDependentServiceArgs{...} }
//
type ServiceDependencyDependencyDependentServiceArrayInput interface {
	pulumi.Input

	ToServiceDependencyDependencyDependentServiceArrayOutput() ServiceDependencyDependencyDependentServiceArrayOutput
	ToServiceDependencyDependencyDependentServiceArrayOutputWithContext(context.Context) ServiceDependencyDependencyDependentServiceArrayOutput
}

type ServiceDependencyDependencyDependentServiceArray []ServiceDependencyDependencyDependentServiceInput

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

func (i ServiceDependencyDependencyDependentServiceArray) ToServiceDependencyDependencyDependentServiceArrayOutput() ServiceDependencyDependencyDependentServiceArrayOutput {
	return i.ToServiceDependencyDependencyDependentServiceArrayOutputWithContext(context.Background())
}

func (i ServiceDependencyDependencyDependentServiceArray) ToServiceDependencyDependencyDependentServiceArrayOutputWithContext(ctx context.Context) ServiceDependencyDependencyDependentServiceArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceDependencyDependencyDependentServiceArrayOutput)
}

type ServiceDependencyDependencyDependentServiceOutput struct{ *pulumi.OutputState }

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

func (o ServiceDependencyDependencyDependentServiceOutput) ToServiceDependencyDependencyDependentServiceOutput() ServiceDependencyDependencyDependentServiceOutput {
	return o
}

func (o ServiceDependencyDependencyDependentServiceOutput) ToServiceDependencyDependencyDependentServiceOutputWithContext(ctx context.Context) ServiceDependencyDependencyDependentServiceOutput {
	return o
}

// The ID of the service dependency.
func (o ServiceDependencyDependencyDependentServiceOutput) Id() pulumi.StringOutput {
	return o.ApplyT(func(v ServiceDependencyDependencyDependentService) string { return v.Id }).(pulumi.StringOutput)
}

func (o ServiceDependencyDependencyDependentServiceOutput) Type() pulumi.StringOutput {
	return o.ApplyT(func(v ServiceDependencyDependencyDependentService) string { return v.Type }).(pulumi.StringOutput)
}

type ServiceDependencyDependencyDependentServiceArrayOutput struct{ *pulumi.OutputState }

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

func (o ServiceDependencyDependencyDependentServiceArrayOutput) ToServiceDependencyDependencyDependentServiceArrayOutput() ServiceDependencyDependencyDependentServiceArrayOutput {
	return o
}

func (o ServiceDependencyDependencyDependentServiceArrayOutput) ToServiceDependencyDependencyDependentServiceArrayOutputWithContext(ctx context.Context) ServiceDependencyDependencyDependentServiceArrayOutput {
	return o
}

func (o ServiceDependencyDependencyDependentServiceArrayOutput) Index(i pulumi.IntInput) ServiceDependencyDependencyDependentServiceOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ServiceDependencyDependencyDependentService {
		return vs[0].([]ServiceDependencyDependencyDependentService)[vs[1].(int)]
	}).(ServiceDependencyDependencyDependentServiceOutput)
}

type ServiceDependencyDependencySupportingService struct {
	// The ID of the service dependency.
	Id   string `pulumi:"id"`
	Type string `pulumi:"type"`
}

// ServiceDependencyDependencySupportingServiceInput is an input type that accepts ServiceDependencyDependencySupportingServiceArgs and ServiceDependencyDependencySupportingServiceOutput values.
// You can construct a concrete instance of `ServiceDependencyDependencySupportingServiceInput` via:
//
// 		 ServiceDependencyDependencySupportingServiceArgs{...}
//
type ServiceDependencyDependencySupportingServiceInput interface {
	pulumi.Input

	ToServiceDependencyDependencySupportingServiceOutput() ServiceDependencyDependencySupportingServiceOutput
	ToServiceDependencyDependencySupportingServiceOutputWithContext(context.Context) ServiceDependencyDependencySupportingServiceOutput
}

type ServiceDependencyDependencySupportingServiceArgs struct {
	// The ID of the service dependency.
	Id   pulumi.StringInput `pulumi:"id"`
	Type pulumi.StringInput `pulumi:"type"`
}

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

func (i ServiceDependencyDependencySupportingServiceArgs) ToServiceDependencyDependencySupportingServiceOutput() ServiceDependencyDependencySupportingServiceOutput {
	return i.ToServiceDependencyDependencySupportingServiceOutputWithContext(context.Background())
}

func (i ServiceDependencyDependencySupportingServiceArgs) ToServiceDependencyDependencySupportingServiceOutputWithContext(ctx context.Context) ServiceDependencyDependencySupportingServiceOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceDependencyDependencySupportingServiceOutput)
}

// ServiceDependencyDependencySupportingServiceArrayInput is an input type that accepts ServiceDependencyDependencySupportingServiceArray and ServiceDependencyDependencySupportingServiceArrayOutput values.
// You can construct a concrete instance of `ServiceDependencyDependencySupportingServiceArrayInput` via:
//
// 		 ServiceDependencyDependencySupportingServiceArray{ ServiceDependencyDependencySupportingServiceArgs{...} }
//
type ServiceDependencyDependencySupportingServiceArrayInput interface {
	pulumi.Input

	ToServiceDependencyDependencySupportingServiceArrayOutput() ServiceDependencyDependencySupportingServiceArrayOutput
	ToServiceDependencyDependencySupportingServiceArrayOutputWithContext(context.Context) ServiceDependencyDependencySupportingServiceArrayOutput
}

type ServiceDependencyDependencySupportingServiceArray []ServiceDependencyDependencySupportingServiceInput

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

func (i ServiceDependencyDependencySupportingServiceArray) ToServiceDependencyDependencySupportingServiceArrayOutput() ServiceDependencyDependencySupportingServiceArrayOutput {
	return i.ToServiceDependencyDependencySupportingServiceArrayOutputWithContext(context.Background())
}

func (i ServiceDependencyDependencySupportingServiceArray) ToServiceDependencyDependencySupportingServiceArrayOutputWithContext(ctx context.Context) ServiceDependencyDependencySupportingServiceArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceDependencyDependencySupportingServiceArrayOutput)
}

type ServiceDependencyDependencySupportingServiceOutput struct{ *pulumi.OutputState }

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

func (o ServiceDependencyDependencySupportingServiceOutput) ToServiceDependencyDependencySupportingServiceOutput() ServiceDependencyDependencySupportingServiceOutput {
	return o
}

func (o ServiceDependencyDependencySupportingServiceOutput) ToServiceDependencyDependencySupportingServiceOutputWithContext(ctx context.Context) ServiceDependencyDependencySupportingServiceOutput {
	return o
}

// The ID of the service dependency.
func (o ServiceDependencyDependencySupportingServiceOutput) Id() pulumi.StringOutput {
	return o.ApplyT(func(v ServiceDependencyDependencySupportingService) string { return v.Id }).(pulumi.StringOutput)
}

func (o ServiceDependencyDependencySupportingServiceOutput) Type() pulumi.StringOutput {
	return o.ApplyT(func(v ServiceDependencyDependencySupportingService) string { return v.Type }).(pulumi.StringOutput)
}

type ServiceDependencyDependencySupportingServiceArrayOutput struct{ *pulumi.OutputState }

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

func (o ServiceDependencyDependencySupportingServiceArrayOutput) ToServiceDependencyDependencySupportingServiceArrayOutput() ServiceDependencyDependencySupportingServiceArrayOutput {
	return o
}

func (o ServiceDependencyDependencySupportingServiceArrayOutput) ToServiceDependencyDependencySupportingServiceArrayOutputWithContext(ctx context.Context) ServiceDependencyDependencySupportingServiceArrayOutput {
	return o
}

func (o ServiceDependencyDependencySupportingServiceArrayOutput) Index(i pulumi.IntInput) ServiceDependencyDependencySupportingServiceOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ServiceDependencyDependencySupportingService {
		return vs[0].([]ServiceDependencyDependencySupportingService)[vs[1].(int)]
	}).(ServiceDependencyDependencySupportingServiceOutput)
}

type ServiceIncidentUrgencyRule struct {
	// Incidents' urgency during support hours.
	DuringSupportHours *ServiceIncidentUrgencyRuleDuringSupportHours `pulumi:"duringSupportHours"`
	// Incidents' urgency outside of support hours.
	OutsideSupportHours *ServiceIncidentUrgencyRuleOutsideSupportHours `pulumi:"outsideSupportHours"`
	// The type of scheduled action. Currently, this must be set to `urgencyChange`.
	Type string `pulumi:"type"`
	// The urgency: `low` Notify responders (does not escalate), `high` (follows escalation rules) or `severityBased` Set's the urgency of the incident based on the severity set by the triggering monitoring tool.
	Urgency *string `pulumi:"urgency"`
}

// ServiceIncidentUrgencyRuleInput is an input type that accepts ServiceIncidentUrgencyRuleArgs and ServiceIncidentUrgencyRuleOutput values.
// You can construct a concrete instance of `ServiceIncidentUrgencyRuleInput` via:
//
// 		 ServiceIncidentUrgencyRuleArgs{...}
//
type ServiceIncidentUrgencyRuleInput interface {
	pulumi.Input

	ToServiceIncidentUrgencyRuleOutput() ServiceIncidentUrgencyRuleOutput
	ToServiceIncidentUrgencyRuleOutputWithContext(context.Context) ServiceIncidentUrgencyRuleOutput
}

type ServiceIncidentUrgencyRuleArgs struct {
	// Incidents' urgency during support hours.
	DuringSupportHours ServiceIncidentUrgencyRuleDuringSupportHoursPtrInput `pulumi:"duringSupportHours"`
	// Incidents' urgency outside of support hours.
	OutsideSupportHours ServiceIncidentUrgencyRuleOutsideSupportHoursPtrInput `pulumi:"outsideSupportHours"`
	// The type of scheduled action. Currently, this must be set to `urgencyChange`.
	Type pulumi.StringInput `pulumi:"type"`
	// The urgency: `low` Notify responders (does not escalate), `high` (follows escalation rules) or `severityBased` Set's the urgency of the incident based on the severity set by the triggering monitoring tool.
	Urgency pulumi.StringPtrInput `pulumi:"urgency"`
}

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

func (i ServiceIncidentUrgencyRuleArgs) ToServiceIncidentUrgencyRuleOutput() ServiceIncidentUrgencyRuleOutput {
	return i.ToServiceIncidentUrgencyRuleOutputWithContext(context.Background())
}

func (i ServiceIncidentUrgencyRuleArgs) ToServiceIncidentUrgencyRuleOutputWithContext(ctx context.Context) ServiceIncidentUrgencyRuleOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceIncidentUrgencyRuleOutput)
}

func (i ServiceIncidentUrgencyRuleArgs) ToServiceIncidentUrgencyRulePtrOutput() ServiceIncidentUrgencyRulePtrOutput {
	return i.ToServiceIncidentUrgencyRulePtrOutputWithContext(context.Background())
}

func (i ServiceIncidentUrgencyRuleArgs) ToServiceIncidentUrgencyRulePtrOutputWithContext(ctx context.Context) ServiceIncidentUrgencyRulePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceIncidentUrgencyRuleOutput).ToServiceIncidentUrgencyRulePtrOutputWithContext(ctx)
}

// ServiceIncidentUrgencyRulePtrInput is an input type that accepts ServiceIncidentUrgencyRuleArgs, ServiceIncidentUrgencyRulePtr and ServiceIncidentUrgencyRulePtrOutput values.
// You can construct a concrete instance of `ServiceIncidentUrgencyRulePtrInput` via:
//
// 		 ServiceIncidentUrgencyRuleArgs{...}
//
//  or:
//
// 		 nil
//
type ServiceIncidentUrgencyRulePtrInput interface {
	pulumi.Input

	ToServiceIncidentUrgencyRulePtrOutput() ServiceIncidentUrgencyRulePtrOutput
	ToServiceIncidentUrgencyRulePtrOutputWithContext(context.Context) ServiceIncidentUrgencyRulePtrOutput
}

type serviceIncidentUrgencyRulePtrType ServiceIncidentUrgencyRuleArgs

func ServiceIncidentUrgencyRulePtr(v *ServiceIncidentUrgencyRuleArgs) ServiceIncidentUrgencyRulePtrInput {
	return (*serviceIncidentUrgencyRulePtrType)(v)
}

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

func (i *serviceIncidentUrgencyRulePtrType) ToServiceIncidentUrgencyRulePtrOutput() ServiceIncidentUrgencyRulePtrOutput {
	return i.ToServiceIncidentUrgencyRulePtrOutputWithContext(context.Background())
}

func (i *serviceIncidentUrgencyRulePtrType) ToServiceIncidentUrgencyRulePtrOutputWithContext(ctx context.Context) ServiceIncidentUrgencyRulePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceIncidentUrgencyRulePtrOutput)
}

type ServiceIncidentUrgencyRuleOutput struct{ *pulumi.OutputState }

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

func (o ServiceIncidentUrgencyRuleOutput) ToServiceIncidentUrgencyRuleOutput() ServiceIncidentUrgencyRuleOutput {
	return o
}

func (o ServiceIncidentUrgencyRuleOutput) ToServiceIncidentUrgencyRuleOutputWithContext(ctx context.Context) ServiceIncidentUrgencyRuleOutput {
	return o
}

func (o ServiceIncidentUrgencyRuleOutput) ToServiceIncidentUrgencyRulePtrOutput() ServiceIncidentUrgencyRulePtrOutput {
	return o.ToServiceIncidentUrgencyRulePtrOutputWithContext(context.Background())
}

func (o ServiceIncidentUrgencyRuleOutput) ToServiceIncidentUrgencyRulePtrOutputWithContext(ctx context.Context) ServiceIncidentUrgencyRulePtrOutput {
	return o.ApplyT(func(v ServiceIncidentUrgencyRule) *ServiceIncidentUrgencyRule {
		return &v
	}).(ServiceIncidentUrgencyRulePtrOutput)
}

// Incidents' urgency during support hours.
func (o ServiceIncidentUrgencyRuleOutput) DuringSupportHours() ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput {
	return o.ApplyT(func(v ServiceIncidentUrgencyRule) *ServiceIncidentUrgencyRuleDuringSupportHours {
		return v.DuringSupportHours
	}).(ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput)
}

// Incidents' urgency outside of support hours.
func (o ServiceIncidentUrgencyRuleOutput) OutsideSupportHours() ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput {
	return o.ApplyT(func(v ServiceIncidentUrgencyRule) *ServiceIncidentUrgencyRuleOutsideSupportHours {
		return v.OutsideSupportHours
	}).(ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput)
}

// The type of scheduled action. Currently, this must be set to `urgencyChange`.
func (o ServiceIncidentUrgencyRuleOutput) Type() pulumi.StringOutput {
	return o.ApplyT(func(v ServiceIncidentUrgencyRule) string { return v.Type }).(pulumi.StringOutput)
}

// The urgency: `low` Notify responders (does not escalate), `high` (follows escalation rules) or `severityBased` Set's the urgency of the incident based on the severity set by the triggering monitoring tool.
func (o ServiceIncidentUrgencyRuleOutput) Urgency() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceIncidentUrgencyRule) *string { return v.Urgency }).(pulumi.StringPtrOutput)
}

type ServiceIncidentUrgencyRulePtrOutput struct{ *pulumi.OutputState }

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

func (o ServiceIncidentUrgencyRulePtrOutput) ToServiceIncidentUrgencyRulePtrOutput() ServiceIncidentUrgencyRulePtrOutput {
	return o
}

func (o ServiceIncidentUrgencyRulePtrOutput) ToServiceIncidentUrgencyRulePtrOutputWithContext(ctx context.Context) ServiceIncidentUrgencyRulePtrOutput {
	return o
}

func (o ServiceIncidentUrgencyRulePtrOutput) Elem() ServiceIncidentUrgencyRuleOutput {
	return o.ApplyT(func(v *ServiceIncidentUrgencyRule) ServiceIncidentUrgencyRule { return *v }).(ServiceIncidentUrgencyRuleOutput)
}

// Incidents' urgency during support hours.
func (o ServiceIncidentUrgencyRulePtrOutput) DuringSupportHours() ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput {
	return o.ApplyT(func(v *ServiceIncidentUrgencyRule) *ServiceIncidentUrgencyRuleDuringSupportHours {
		if v == nil {
			return nil
		}
		return v.DuringSupportHours
	}).(ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput)
}

// Incidents' urgency outside of support hours.
func (o ServiceIncidentUrgencyRulePtrOutput) OutsideSupportHours() ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput {
	return o.ApplyT(func(v *ServiceIncidentUrgencyRule) *ServiceIncidentUrgencyRuleOutsideSupportHours {
		if v == nil {
			return nil
		}
		return v.OutsideSupportHours
	}).(ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput)
}

// The type of scheduled action. Currently, this must be set to `urgencyChange`.
func (o ServiceIncidentUrgencyRulePtrOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceIncidentUrgencyRule) *string {
		if v == nil {
			return nil
		}
		return &v.Type
	}).(pulumi.StringPtrOutput)
}

// The urgency: `low` Notify responders (does not escalate), `high` (follows escalation rules) or `severityBased` Set's the urgency of the incident based on the severity set by the triggering monitoring tool.
func (o ServiceIncidentUrgencyRulePtrOutput) Urgency() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceIncidentUrgencyRule) *string {
		if v == nil {
			return nil
		}
		return v.Urgency
	}).(pulumi.StringPtrOutput)
}

type ServiceIncidentUrgencyRuleDuringSupportHours struct {
	// The type of scheduled action. Currently, this must be set to `urgencyChange`.
	Type *string `pulumi:"type"`
	// The urgency: `low` Notify responders (does not escalate), `high` (follows escalation rules) or `severityBased` Set's the urgency of the incident based on the severity set by the triggering monitoring tool.
	Urgency *string `pulumi:"urgency"`
}

// ServiceIncidentUrgencyRuleDuringSupportHoursInput is an input type that accepts ServiceIncidentUrgencyRuleDuringSupportHoursArgs and ServiceIncidentUrgencyRuleDuringSupportHoursOutput values.
// You can construct a concrete instance of `ServiceIncidentUrgencyRuleDuringSupportHoursInput` via:
//
// 		 ServiceIncidentUrgencyRuleDuringSupportHoursArgs{...}
//
type ServiceIncidentUrgencyRuleDuringSupportHoursInput interface {
	pulumi.Input

	ToServiceIncidentUrgencyRuleDuringSupportHoursOutput() ServiceIncidentUrgencyRuleDuringSupportHoursOutput
	ToServiceIncidentUrgencyRuleDuringSupportHoursOutputWithContext(context.Context) ServiceIncidentUrgencyRuleDuringSupportHoursOutput
}

type ServiceIncidentUrgencyRuleDuringSupportHoursArgs struct {
	// The type of scheduled action. Currently, this must be set to `urgencyChange`.
	Type pulumi.StringPtrInput `pulumi:"type"`
	// The urgency: `low` Notify responders (does not escalate), `high` (follows escalation rules) or `severityBased` Set's the urgency of the incident based on the severity set by the triggering monitoring tool.
	Urgency pulumi.StringPtrInput `pulumi:"urgency"`
}

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

func (i ServiceIncidentUrgencyRuleDuringSupportHoursArgs) ToServiceIncidentUrgencyRuleDuringSupportHoursOutput() ServiceIncidentUrgencyRuleDuringSupportHoursOutput {
	return i.ToServiceIncidentUrgencyRuleDuringSupportHoursOutputWithContext(context.Background())
}

func (i ServiceIncidentUrgencyRuleDuringSupportHoursArgs) ToServiceIncidentUrgencyRuleDuringSupportHoursOutputWithContext(ctx context.Context) ServiceIncidentUrgencyRuleDuringSupportHoursOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceIncidentUrgencyRuleDuringSupportHoursOutput)
}

func (i ServiceIncidentUrgencyRuleDuringSupportHoursArgs) ToServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput() ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput {
	return i.ToServiceIncidentUrgencyRuleDuringSupportHoursPtrOutputWithContext(context.Background())
}

func (i ServiceIncidentUrgencyRuleDuringSupportHoursArgs) ToServiceIncidentUrgencyRuleDuringSupportHoursPtrOutputWithContext(ctx context.Context) ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceIncidentUrgencyRuleDuringSupportHoursOutput).ToServiceIncidentUrgencyRuleDuringSupportHoursPtrOutputWithContext(ctx)
}

// ServiceIncidentUrgencyRuleDuringSupportHoursPtrInput is an input type that accepts ServiceIncidentUrgencyRuleDuringSupportHoursArgs, ServiceIncidentUrgencyRuleDuringSupportHoursPtr and ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput values.
// You can construct a concrete instance of `ServiceIncidentUrgencyRuleDuringSupportHoursPtrInput` via:
//
// 		 ServiceIncidentUrgencyRuleDuringSupportHoursArgs{...}
//
//  or:
//
// 		 nil
//
type ServiceIncidentUrgencyRuleDuringSupportHoursPtrInput interface {
	pulumi.Input

	ToServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput() ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput
	ToServiceIncidentUrgencyRuleDuringSupportHoursPtrOutputWithContext(context.Context) ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput
}

type serviceIncidentUrgencyRuleDuringSupportHoursPtrType ServiceIncidentUrgencyRuleDuringSupportHoursArgs

func ServiceIncidentUrgencyRuleDuringSupportHoursPtr(v *ServiceIncidentUrgencyRuleDuringSupportHoursArgs) ServiceIncidentUrgencyRuleDuringSupportHoursPtrInput {
	return (*serviceIncidentUrgencyRuleDuringSupportHoursPtrType)(v)
}

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

func (i *serviceIncidentUrgencyRuleDuringSupportHoursPtrType) ToServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput() ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput {
	return i.ToServiceIncidentUrgencyRuleDuringSupportHoursPtrOutputWithContext(context.Background())
}

func (i *serviceIncidentUrgencyRuleDuringSupportHoursPtrType) ToServiceIncidentUrgencyRuleDuringSupportHoursPtrOutputWithContext(ctx context.Context) ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput)
}

type ServiceIncidentUrgencyRuleDuringSupportHoursOutput struct{ *pulumi.OutputState }

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

func (o ServiceIncidentUrgencyRuleDuringSupportHoursOutput) ToServiceIncidentUrgencyRuleDuringSupportHoursOutput() ServiceIncidentUrgencyRuleDuringSupportHoursOutput {
	return o
}

func (o ServiceIncidentUrgencyRuleDuringSupportHoursOutput) ToServiceIncidentUrgencyRuleDuringSupportHoursOutputWithContext(ctx context.Context) ServiceIncidentUrgencyRuleDuringSupportHoursOutput {
	return o
}

func (o ServiceIncidentUrgencyRuleDuringSupportHoursOutput) ToServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput() ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput {
	return o.ToServiceIncidentUrgencyRuleDuringSupportHoursPtrOutputWithContext(context.Background())
}

func (o ServiceIncidentUrgencyRuleDuringSupportHoursOutput) ToServiceIncidentUrgencyRuleDuringSupportHoursPtrOutputWithContext(ctx context.Context) ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput {
	return o.ApplyT(func(v ServiceIncidentUrgencyRuleDuringSupportHours) *ServiceIncidentUrgencyRuleDuringSupportHours {
		return &v
	}).(ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput)
}

// The type of scheduled action. Currently, this must be set to `urgencyChange`.
func (o ServiceIncidentUrgencyRuleDuringSupportHoursOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceIncidentUrgencyRuleDuringSupportHours) *string { return v.Type }).(pulumi.StringPtrOutput)
}

// The urgency: `low` Notify responders (does not escalate), `high` (follows escalation rules) or `severityBased` Set's the urgency of the incident based on the severity set by the triggering monitoring tool.
func (o ServiceIncidentUrgencyRuleDuringSupportHoursOutput) Urgency() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceIncidentUrgencyRuleDuringSupportHours) *string { return v.Urgency }).(pulumi.StringPtrOutput)
}

type ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput struct{ *pulumi.OutputState }

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

func (o ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput) ToServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput() ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput {
	return o
}

func (o ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput) ToServiceIncidentUrgencyRuleDuringSupportHoursPtrOutputWithContext(ctx context.Context) ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput {
	return o
}

func (o ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput) Elem() ServiceIncidentUrgencyRuleDuringSupportHoursOutput {
	return o.ApplyT(func(v *ServiceIncidentUrgencyRuleDuringSupportHours) ServiceIncidentUrgencyRuleDuringSupportHours {
		return *v
	}).(ServiceIncidentUrgencyRuleDuringSupportHoursOutput)
}

// The type of scheduled action. Currently, this must be set to `urgencyChange`.
func (o ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceIncidentUrgencyRuleDuringSupportHours) *string {
		if v == nil {
			return nil
		}
		return v.Type
	}).(pulumi.StringPtrOutput)
}

// The urgency: `low` Notify responders (does not escalate), `high` (follows escalation rules) or `severityBased` Set's the urgency of the incident based on the severity set by the triggering monitoring tool.
func (o ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput) Urgency() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceIncidentUrgencyRuleDuringSupportHours) *string {
		if v == nil {
			return nil
		}
		return v.Urgency
	}).(pulumi.StringPtrOutput)
}

type ServiceIncidentUrgencyRuleOutsideSupportHours struct {
	// The type of scheduled action. Currently, this must be set to `urgencyChange`.
	Type *string `pulumi:"type"`
	// The urgency: `low` Notify responders (does not escalate), `high` (follows escalation rules) or `severityBased` Set's the urgency of the incident based on the severity set by the triggering monitoring tool.
	Urgency *string `pulumi:"urgency"`
}

// ServiceIncidentUrgencyRuleOutsideSupportHoursInput is an input type that accepts ServiceIncidentUrgencyRuleOutsideSupportHoursArgs and ServiceIncidentUrgencyRuleOutsideSupportHoursOutput values.
// You can construct a concrete instance of `ServiceIncidentUrgencyRuleOutsideSupportHoursInput` via:
//
// 		 ServiceIncidentUrgencyRuleOutsideSupportHoursArgs{...}
//
type ServiceIncidentUrgencyRuleOutsideSupportHoursInput interface {
	pulumi.Input

	ToServiceIncidentUrgencyRuleOutsideSupportHoursOutput() ServiceIncidentUrgencyRuleOutsideSupportHoursOutput
	ToServiceIncidentUrgencyRuleOutsideSupportHoursOutputWithContext(context.Context) ServiceIncidentUrgencyRuleOutsideSupportHoursOutput
}

type ServiceIncidentUrgencyRuleOutsideSupportHoursArgs struct {
	// The type of scheduled action. Currently, this must be set to `urgencyChange`.
	Type pulumi.StringPtrInput `pulumi:"type"`
	// The urgency: `low` Notify responders (does not escalate), `high` (follows escalation rules) or `severityBased` Set's the urgency of the incident based on the severity set by the triggering monitoring tool.
	Urgency pulumi.StringPtrInput `pulumi:"urgency"`
}

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

func (i ServiceIncidentUrgencyRuleOutsideSupportHoursArgs) ToServiceIncidentUrgencyRuleOutsideSupportHoursOutput() ServiceIncidentUrgencyRuleOutsideSupportHoursOutput {
	return i.ToServiceIncidentUrgencyRuleOutsideSupportHoursOutputWithContext(context.Background())
}

func (i ServiceIncidentUrgencyRuleOutsideSupportHoursArgs) ToServiceIncidentUrgencyRuleOutsideSupportHoursOutputWithContext(ctx context.Context) ServiceIncidentUrgencyRuleOutsideSupportHoursOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceIncidentUrgencyRuleOutsideSupportHoursOutput)
}

func (i ServiceIncidentUrgencyRuleOutsideSupportHoursArgs) ToServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput() ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput {
	return i.ToServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutputWithContext(context.Background())
}

func (i ServiceIncidentUrgencyRuleOutsideSupportHoursArgs) ToServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutputWithContext(ctx context.Context) ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceIncidentUrgencyRuleOutsideSupportHoursOutput).ToServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutputWithContext(ctx)
}

// ServiceIncidentUrgencyRuleOutsideSupportHoursPtrInput is an input type that accepts ServiceIncidentUrgencyRuleOutsideSupportHoursArgs, ServiceIncidentUrgencyRuleOutsideSupportHoursPtr and ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput values.
// You can construct a concrete instance of `ServiceIncidentUrgencyRuleOutsideSupportHoursPtrInput` via:
//
// 		 ServiceIncidentUrgencyRuleOutsideSupportHoursArgs{...}
//
//  or:
//
// 		 nil
//
type ServiceIncidentUrgencyRuleOutsideSupportHoursPtrInput interface {
	pulumi.Input

	ToServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput() ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput
	ToServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutputWithContext(context.Context) ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput
}

type serviceIncidentUrgencyRuleOutsideSupportHoursPtrType ServiceIncidentUrgencyRuleOutsideSupportHoursArgs

func ServiceIncidentUrgencyRuleOutsideSupportHoursPtr(v *ServiceIncidentUrgencyRuleOutsideSupportHoursArgs) ServiceIncidentUrgencyRuleOutsideSupportHoursPtrInput {
	return (*serviceIncidentUrgencyRuleOutsideSupportHoursPtrType)(v)
}

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

func (i *serviceIncidentUrgencyRuleOutsideSupportHoursPtrType) ToServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput() ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput {
	return i.ToServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutputWithContext(context.Background())
}

func (i *serviceIncidentUrgencyRuleOutsideSupportHoursPtrType) ToServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutputWithContext(ctx context.Context) ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput)
}

type ServiceIncidentUrgencyRuleOutsideSupportHoursOutput struct{ *pulumi.OutputState }

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

func (o ServiceIncidentUrgencyRuleOutsideSupportHoursOutput) ToServiceIncidentUrgencyRuleOutsideSupportHoursOutput() ServiceIncidentUrgencyRuleOutsideSupportHoursOutput {
	return o
}

func (o ServiceIncidentUrgencyRuleOutsideSupportHoursOutput) ToServiceIncidentUrgencyRuleOutsideSupportHoursOutputWithContext(ctx context.Context) ServiceIncidentUrgencyRuleOutsideSupportHoursOutput {
	return o
}

func (o ServiceIncidentUrgencyRuleOutsideSupportHoursOutput) ToServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput() ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput {
	return o.ToServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutputWithContext(context.Background())
}

func (o ServiceIncidentUrgencyRuleOutsideSupportHoursOutput) ToServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutputWithContext(ctx context.Context) ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput {
	return o.ApplyT(func(v ServiceIncidentUrgencyRuleOutsideSupportHours) *ServiceIncidentUrgencyRuleOutsideSupportHours {
		return &v
	}).(ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput)
}

// The type of scheduled action. Currently, this must be set to `urgencyChange`.
func (o ServiceIncidentUrgencyRuleOutsideSupportHoursOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceIncidentUrgencyRuleOutsideSupportHours) *string { return v.Type }).(pulumi.StringPtrOutput)
}

// The urgency: `low` Notify responders (does not escalate), `high` (follows escalation rules) or `severityBased` Set's the urgency of the incident based on the severity set by the triggering monitoring tool.
func (o ServiceIncidentUrgencyRuleOutsideSupportHoursOutput) Urgency() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceIncidentUrgencyRuleOutsideSupportHours) *string { return v.Urgency }).(pulumi.StringPtrOutput)
}

type ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput struct{ *pulumi.OutputState }

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

func (o ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput) ToServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput() ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput {
	return o
}

func (o ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput) ToServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutputWithContext(ctx context.Context) ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput {
	return o
}

func (o ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput) Elem() ServiceIncidentUrgencyRuleOutsideSupportHoursOutput {
	return o.ApplyT(func(v *ServiceIncidentUrgencyRuleOutsideSupportHours) ServiceIncidentUrgencyRuleOutsideSupportHours {
		return *v
	}).(ServiceIncidentUrgencyRuleOutsideSupportHoursOutput)
}

// The type of scheduled action. Currently, this must be set to `urgencyChange`.
func (o ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceIncidentUrgencyRuleOutsideSupportHours) *string {
		if v == nil {
			return nil
		}
		return v.Type
	}).(pulumi.StringPtrOutput)
}

// The urgency: `low` Notify responders (does not escalate), `high` (follows escalation rules) or `severityBased` Set's the urgency of the incident based on the severity set by the triggering monitoring tool.
func (o ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput) Urgency() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceIncidentUrgencyRuleOutsideSupportHours) *string {
		if v == nil {
			return nil
		}
		return v.Urgency
	}).(pulumi.StringPtrOutput)
}

type ServiceScheduledAction struct {
	// A block representing when the scheduled action will occur.
	Ats []ServiceScheduledActionAt `pulumi:"ats"`
	// The urgency to change to: `low` (does not escalate), or `high` (follows escalation rules).
	ToUrgency *string `pulumi:"toUrgency"`
	// The type of scheduled action. Currently, this must be set to `urgencyChange`.
	Type *string `pulumi:"type"`
}

// ServiceScheduledActionInput is an input type that accepts ServiceScheduledActionArgs and ServiceScheduledActionOutput values.
// You can construct a concrete instance of `ServiceScheduledActionInput` via:
//
// 		 ServiceScheduledActionArgs{...}
//
type ServiceScheduledActionInput interface {
	pulumi.Input

	ToServiceScheduledActionOutput() ServiceScheduledActionOutput
	ToServiceScheduledActionOutputWithContext(context.Context) ServiceScheduledActionOutput
}

type ServiceScheduledActionArgs struct {
	// A block representing when the scheduled action will occur.
	Ats ServiceScheduledActionAtArrayInput `pulumi:"ats"`
	// The urgency to change to: `low` (does not escalate), or `high` (follows escalation rules).
	ToUrgency pulumi.StringPtrInput `pulumi:"toUrgency"`
	// The type of scheduled action. Currently, this must be set to `urgencyChange`.
	Type pulumi.StringPtrInput `pulumi:"type"`
}

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

func (i ServiceScheduledActionArgs) ToServiceScheduledActionOutput() ServiceScheduledActionOutput {
	return i.ToServiceScheduledActionOutputWithContext(context.Background())
}

func (i ServiceScheduledActionArgs) ToServiceScheduledActionOutputWithContext(ctx context.Context) ServiceScheduledActionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceScheduledActionOutput)
}

// ServiceScheduledActionArrayInput is an input type that accepts ServiceScheduledActionArray and ServiceScheduledActionArrayOutput values.
// You can construct a concrete instance of `ServiceScheduledActionArrayInput` via:
//
// 		 ServiceScheduledActionArray{ ServiceScheduledActionArgs{...} }
//
type ServiceScheduledActionArrayInput interface {
	pulumi.Input

	ToServiceScheduledActionArrayOutput() ServiceScheduledActionArrayOutput
	ToServiceScheduledActionArrayOutputWithContext(context.Context) ServiceScheduledActionArrayOutput
}

type ServiceScheduledActionArray []ServiceScheduledActionInput

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

func (i ServiceScheduledActionArray) ToServiceScheduledActionArrayOutput() ServiceScheduledActionArrayOutput {
	return i.ToServiceScheduledActionArrayOutputWithContext(context.Background())
}

func (i ServiceScheduledActionArray) ToServiceScheduledActionArrayOutputWithContext(ctx context.Context) ServiceScheduledActionArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceScheduledActionArrayOutput)
}

type ServiceScheduledActionOutput struct{ *pulumi.OutputState }

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

func (o ServiceScheduledActionOutput) ToServiceScheduledActionOutput() ServiceScheduledActionOutput {
	return o
}

func (o ServiceScheduledActionOutput) ToServiceScheduledActionOutputWithContext(ctx context.Context) ServiceScheduledActionOutput {
	return o
}

// A block representing when the scheduled action will occur.
func (o ServiceScheduledActionOutput) Ats() ServiceScheduledActionAtArrayOutput {
	return o.ApplyT(func(v ServiceScheduledAction) []ServiceScheduledActionAt { return v.Ats }).(ServiceScheduledActionAtArrayOutput)
}

// The urgency to change to: `low` (does not escalate), or `high` (follows escalation rules).
func (o ServiceScheduledActionOutput) ToUrgency() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceScheduledAction) *string { return v.ToUrgency }).(pulumi.StringPtrOutput)
}

// The type of scheduled action. Currently, this must be set to `urgencyChange`.
func (o ServiceScheduledActionOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceScheduledAction) *string { return v.Type }).(pulumi.StringPtrOutput)
}

type ServiceScheduledActionArrayOutput struct{ *pulumi.OutputState }

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

func (o ServiceScheduledActionArrayOutput) ToServiceScheduledActionArrayOutput() ServiceScheduledActionArrayOutput {
	return o
}

func (o ServiceScheduledActionArrayOutput) ToServiceScheduledActionArrayOutputWithContext(ctx context.Context) ServiceScheduledActionArrayOutput {
	return o
}

func (o ServiceScheduledActionArrayOutput) Index(i pulumi.IntInput) ServiceScheduledActionOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ServiceScheduledAction {
		return vs[0].([]ServiceScheduledAction)[vs[1].(int)]
	}).(ServiceScheduledActionOutput)
}

type ServiceScheduledActionAt struct {
	// Designates either the start or the end of the scheduled action. Can be `supportHoursStart` or `supportHoursEnd`.
	Name *string `pulumi:"name"`
	// The type of time specification. Currently, this must be set to `namedTime`.
	Type *string `pulumi:"type"`
}

// ServiceScheduledActionAtInput is an input type that accepts ServiceScheduledActionAtArgs and ServiceScheduledActionAtOutput values.
// You can construct a concrete instance of `ServiceScheduledActionAtInput` via:
//
// 		 ServiceScheduledActionAtArgs{...}
//
type ServiceScheduledActionAtInput interface {
	pulumi.Input

	ToServiceScheduledActionAtOutput() ServiceScheduledActionAtOutput
	ToServiceScheduledActionAtOutputWithContext(context.Context) ServiceScheduledActionAtOutput
}

type ServiceScheduledActionAtArgs struct {
	// Designates either the start or the end of the scheduled action. Can be `supportHoursStart` or `supportHoursEnd`.
	Name pulumi.StringPtrInput `pulumi:"name"`
	// The type of time specification. Currently, this must be set to `namedTime`.
	Type pulumi.StringPtrInput `pulumi:"type"`
}

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

func (i ServiceScheduledActionAtArgs) ToServiceScheduledActionAtOutput() ServiceScheduledActionAtOutput {
	return i.ToServiceScheduledActionAtOutputWithContext(context.Background())
}

func (i ServiceScheduledActionAtArgs) ToServiceScheduledActionAtOutputWithContext(ctx context.Context) ServiceScheduledActionAtOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceScheduledActionAtOutput)
}

// ServiceScheduledActionAtArrayInput is an input type that accepts ServiceScheduledActionAtArray and ServiceScheduledActionAtArrayOutput values.
// You can construct a concrete instance of `ServiceScheduledActionAtArrayInput` via:
//
// 		 ServiceScheduledActionAtArray{ ServiceScheduledActionAtArgs{...} }
//
type ServiceScheduledActionAtArrayInput interface {
	pulumi.Input

	ToServiceScheduledActionAtArrayOutput() ServiceScheduledActionAtArrayOutput
	ToServiceScheduledActionAtArrayOutputWithContext(context.Context) ServiceScheduledActionAtArrayOutput
}

type ServiceScheduledActionAtArray []ServiceScheduledActionAtInput

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

func (i ServiceScheduledActionAtArray) ToServiceScheduledActionAtArrayOutput() ServiceScheduledActionAtArrayOutput {
	return i.ToServiceScheduledActionAtArrayOutputWithContext(context.Background())
}

func (i ServiceScheduledActionAtArray) ToServiceScheduledActionAtArrayOutputWithContext(ctx context.Context) ServiceScheduledActionAtArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceScheduledActionAtArrayOutput)
}

type ServiceScheduledActionAtOutput struct{ *pulumi.OutputState }

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

func (o ServiceScheduledActionAtOutput) ToServiceScheduledActionAtOutput() ServiceScheduledActionAtOutput {
	return o
}

func (o ServiceScheduledActionAtOutput) ToServiceScheduledActionAtOutputWithContext(ctx context.Context) ServiceScheduledActionAtOutput {
	return o
}

// Designates either the start or the end of the scheduled action. Can be `supportHoursStart` or `supportHoursEnd`.
func (o ServiceScheduledActionAtOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceScheduledActionAt) *string { return v.Name }).(pulumi.StringPtrOutput)
}

// The type of time specification. Currently, this must be set to `namedTime`.
func (o ServiceScheduledActionAtOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceScheduledActionAt) *string { return v.Type }).(pulumi.StringPtrOutput)
}

type ServiceScheduledActionAtArrayOutput struct{ *pulumi.OutputState }

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

func (o ServiceScheduledActionAtArrayOutput) ToServiceScheduledActionAtArrayOutput() ServiceScheduledActionAtArrayOutput {
	return o
}

func (o ServiceScheduledActionAtArrayOutput) ToServiceScheduledActionAtArrayOutputWithContext(ctx context.Context) ServiceScheduledActionAtArrayOutput {
	return o
}

func (o ServiceScheduledActionAtArrayOutput) Index(i pulumi.IntInput) ServiceScheduledActionAtOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ServiceScheduledActionAt {
		return vs[0].([]ServiceScheduledActionAt)[vs[1].(int)]
	}).(ServiceScheduledActionAtOutput)
}

type ServiceSupportHours struct {
	// Array of days of week as integers. `1` to `7`, `1` being
	// Monday and `7` being Sunday.
	DaysOfWeeks []int `pulumi:"daysOfWeeks"`
	// The support hours' ending time of day.
	EndTime *string `pulumi:"endTime"`
	// The support hours' starting time of day.
	StartTime *string `pulumi:"startTime"`
	// The time zone for the support hours.
	TimeZone *string `pulumi:"timeZone"`
	// The type of scheduled action. Currently, this must be set to `urgencyChange`.
	Type *string `pulumi:"type"`
}

// ServiceSupportHoursInput is an input type that accepts ServiceSupportHoursArgs and ServiceSupportHoursOutput values.
// You can construct a concrete instance of `ServiceSupportHoursInput` via:
//
// 		 ServiceSupportHoursArgs{...}
//
type ServiceSupportHoursInput interface {
	pulumi.Input

	ToServiceSupportHoursOutput() ServiceSupportHoursOutput
	ToServiceSupportHoursOutputWithContext(context.Context) ServiceSupportHoursOutput
}

type ServiceSupportHoursArgs struct {
	// Array of days of week as integers. `1` to `7`, `1` being
	// Monday and `7` being Sunday.
	DaysOfWeeks pulumi.IntArrayInput `pulumi:"daysOfWeeks"`
	// The support hours' ending time of day.
	EndTime pulumi.StringPtrInput `pulumi:"endTime"`
	// The support hours' starting time of day.
	StartTime pulumi.StringPtrInput `pulumi:"startTime"`
	// The time zone for the support hours.
	TimeZone pulumi.StringPtrInput `pulumi:"timeZone"`
	// The type of scheduled action. Currently, this must be set to `urgencyChange`.
	Type pulumi.StringPtrInput `pulumi:"type"`
}

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

func (i ServiceSupportHoursArgs) ToServiceSupportHoursOutput() ServiceSupportHoursOutput {
	return i.ToServiceSupportHoursOutputWithContext(context.Background())
}

func (i ServiceSupportHoursArgs) ToServiceSupportHoursOutputWithContext(ctx context.Context) ServiceSupportHoursOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceSupportHoursOutput)
}

func (i ServiceSupportHoursArgs) ToServiceSupportHoursPtrOutput() ServiceSupportHoursPtrOutput {
	return i.ToServiceSupportHoursPtrOutputWithContext(context.Background())
}

func (i ServiceSupportHoursArgs) ToServiceSupportHoursPtrOutputWithContext(ctx context.Context) ServiceSupportHoursPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceSupportHoursOutput).ToServiceSupportHoursPtrOutputWithContext(ctx)
}

// ServiceSupportHoursPtrInput is an input type that accepts ServiceSupportHoursArgs, ServiceSupportHoursPtr and ServiceSupportHoursPtrOutput values.
// You can construct a concrete instance of `ServiceSupportHoursPtrInput` via:
//
// 		 ServiceSupportHoursArgs{...}
//
//  or:
//
// 		 nil
//
type ServiceSupportHoursPtrInput interface {
	pulumi.Input

	ToServiceSupportHoursPtrOutput() ServiceSupportHoursPtrOutput
	ToServiceSupportHoursPtrOutputWithContext(context.Context) ServiceSupportHoursPtrOutput
}

type serviceSupportHoursPtrType ServiceSupportHoursArgs

func ServiceSupportHoursPtr(v *ServiceSupportHoursArgs) ServiceSupportHoursPtrInput {
	return (*serviceSupportHoursPtrType)(v)
}

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

func (i *serviceSupportHoursPtrType) ToServiceSupportHoursPtrOutput() ServiceSupportHoursPtrOutput {
	return i.ToServiceSupportHoursPtrOutputWithContext(context.Background())
}

func (i *serviceSupportHoursPtrType) ToServiceSupportHoursPtrOutputWithContext(ctx context.Context) ServiceSupportHoursPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceSupportHoursPtrOutput)
}

type ServiceSupportHoursOutput struct{ *pulumi.OutputState }

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

func (o ServiceSupportHoursOutput) ToServiceSupportHoursOutput() ServiceSupportHoursOutput {
	return o
}

func (o ServiceSupportHoursOutput) ToServiceSupportHoursOutputWithContext(ctx context.Context) ServiceSupportHoursOutput {
	return o
}

func (o ServiceSupportHoursOutput) ToServiceSupportHoursPtrOutput() ServiceSupportHoursPtrOutput {
	return o.ToServiceSupportHoursPtrOutputWithContext(context.Background())
}

func (o ServiceSupportHoursOutput) ToServiceSupportHoursPtrOutputWithContext(ctx context.Context) ServiceSupportHoursPtrOutput {
	return o.ApplyT(func(v ServiceSupportHours) *ServiceSupportHours {
		return &v
	}).(ServiceSupportHoursPtrOutput)
}

// Array of days of week as integers. `1` to `7`, `1` being
// Monday and `7` being Sunday.
func (o ServiceSupportHoursOutput) DaysOfWeeks() pulumi.IntArrayOutput {
	return o.ApplyT(func(v ServiceSupportHours) []int { return v.DaysOfWeeks }).(pulumi.IntArrayOutput)
}

// The support hours' ending time of day.
func (o ServiceSupportHoursOutput) EndTime() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceSupportHours) *string { return v.EndTime }).(pulumi.StringPtrOutput)
}

// The support hours' starting time of day.
func (o ServiceSupportHoursOutput) StartTime() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceSupportHours) *string { return v.StartTime }).(pulumi.StringPtrOutput)
}

// The time zone for the support hours.
func (o ServiceSupportHoursOutput) TimeZone() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceSupportHours) *string { return v.TimeZone }).(pulumi.StringPtrOutput)
}

// The type of scheduled action. Currently, this must be set to `urgencyChange`.
func (o ServiceSupportHoursOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceSupportHours) *string { return v.Type }).(pulumi.StringPtrOutput)
}

type ServiceSupportHoursPtrOutput struct{ *pulumi.OutputState }

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

func (o ServiceSupportHoursPtrOutput) ToServiceSupportHoursPtrOutput() ServiceSupportHoursPtrOutput {
	return o
}

func (o ServiceSupportHoursPtrOutput) ToServiceSupportHoursPtrOutputWithContext(ctx context.Context) ServiceSupportHoursPtrOutput {
	return o
}

func (o ServiceSupportHoursPtrOutput) Elem() ServiceSupportHoursOutput {
	return o.ApplyT(func(v *ServiceSupportHours) ServiceSupportHours { return *v }).(ServiceSupportHoursOutput)
}

// Array of days of week as integers. `1` to `7`, `1` being
// Monday and `7` being Sunday.
func (o ServiceSupportHoursPtrOutput) DaysOfWeeks() pulumi.IntArrayOutput {
	return o.ApplyT(func(v *ServiceSupportHours) []int {
		if v == nil {
			return nil
		}
		return v.DaysOfWeeks
	}).(pulumi.IntArrayOutput)
}

// The support hours' ending time of day.
func (o ServiceSupportHoursPtrOutput) EndTime() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceSupportHours) *string {
		if v == nil {
			return nil
		}
		return v.EndTime
	}).(pulumi.StringPtrOutput)
}

// The support hours' starting time of day.
func (o ServiceSupportHoursPtrOutput) StartTime() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceSupportHours) *string {
		if v == nil {
			return nil
		}
		return v.StartTime
	}).(pulumi.StringPtrOutput)
}

// The time zone for the support hours.
func (o ServiceSupportHoursPtrOutput) TimeZone() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceSupportHours) *string {
		if v == nil {
			return nil
		}
		return v.TimeZone
	}).(pulumi.StringPtrOutput)
}

// The type of scheduled action. Currently, this must be set to `urgencyChange`.
func (o ServiceSupportHoursPtrOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceSupportHours) *string {
		if v == nil {
			return nil
		}
		return v.Type
	}).(pulumi.StringPtrOutput)
}

type UserNotificationRuleContactMethod struct {
	// The id of the referenced contact method.
	Id string `pulumi:"id"`
	// The type of contact method. Can be `emailContactMethod`, `phoneContactMethod`, `pushNotificationContactMethod` or `smsContactMethod`.
	Type string `pulumi:"type"`
}

// UserNotificationRuleContactMethodInput is an input type that accepts UserNotificationRuleContactMethodArgs and UserNotificationRuleContactMethodOutput values.
// You can construct a concrete instance of `UserNotificationRuleContactMethodInput` via:
//
// 		 UserNotificationRuleContactMethodArgs{...}
//
type UserNotificationRuleContactMethodInput interface {
	pulumi.Input

	ToUserNotificationRuleContactMethodOutput() UserNotificationRuleContactMethodOutput
	ToUserNotificationRuleContactMethodOutputWithContext(context.Context) UserNotificationRuleContactMethodOutput
}

type UserNotificationRuleContactMethodArgs struct {
	// The id of the referenced contact method.
	Id pulumi.StringInput `pulumi:"id"`
	// The type of contact method. Can be `emailContactMethod`, `phoneContactMethod`, `pushNotificationContactMethod` or `smsContactMethod`.
	Type pulumi.StringInput `pulumi:"type"`
}

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

func (i UserNotificationRuleContactMethodArgs) ToUserNotificationRuleContactMethodOutput() UserNotificationRuleContactMethodOutput {
	return i.ToUserNotificationRuleContactMethodOutputWithContext(context.Background())
}

func (i UserNotificationRuleContactMethodArgs) ToUserNotificationRuleContactMethodOutputWithContext(ctx context.Context) UserNotificationRuleContactMethodOutput {
	return pulumi.ToOutputWithContext(ctx, i).(UserNotificationRuleContactMethodOutput)
}

func (i UserNotificationRuleContactMethodArgs) ToUserNotificationRuleContactMethodPtrOutput() UserNotificationRuleContactMethodPtrOutput {
	return i.ToUserNotificationRuleContactMethodPtrOutputWithContext(context.Background())
}

func (i UserNotificationRuleContactMethodArgs) ToUserNotificationRuleContactMethodPtrOutputWithContext(ctx context.Context) UserNotificationRuleContactMethodPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(UserNotificationRuleContactMethodOutput).ToUserNotificationRuleContactMethodPtrOutputWithContext(ctx)
}

// UserNotificationRuleContactMethodPtrInput is an input type that accepts UserNotificationRuleContactMethodArgs, UserNotificationRuleContactMethodPtr and UserNotificationRuleContactMethodPtrOutput values.
// You can construct a concrete instance of `UserNotificationRuleContactMethodPtrInput` via:
//
// 		 UserNotificationRuleContactMethodArgs{...}
//
//  or:
//
// 		 nil
//
type UserNotificationRuleContactMethodPtrInput interface {
	pulumi.Input

	ToUserNotificationRuleContactMethodPtrOutput() UserNotificationRuleContactMethodPtrOutput
	ToUserNotificationRuleContactMethodPtrOutputWithContext(context.Context) UserNotificationRuleContactMethodPtrOutput
}

type userNotificationRuleContactMethodPtrType UserNotificationRuleContactMethodArgs

func UserNotificationRuleContactMethodPtr(v *UserNotificationRuleContactMethodArgs) UserNotificationRuleContactMethodPtrInput {
	return (*userNotificationRuleContactMethodPtrType)(v)
}

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

func (i *userNotificationRuleContactMethodPtrType) ToUserNotificationRuleContactMethodPtrOutput() UserNotificationRuleContactMethodPtrOutput {
	return i.ToUserNotificationRuleContactMethodPtrOutputWithContext(context.Background())
}

func (i *userNotificationRuleContactMethodPtrType) ToUserNotificationRuleContactMethodPtrOutputWithContext(ctx context.Context) UserNotificationRuleContactMethodPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(UserNotificationRuleContactMethodPtrOutput)
}

type UserNotificationRuleContactMethodOutput struct{ *pulumi.OutputState }

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

func (o UserNotificationRuleContactMethodOutput) ToUserNotificationRuleContactMethodOutput() UserNotificationRuleContactMethodOutput {
	return o
}

func (o UserNotificationRuleContactMethodOutput) ToUserNotificationRuleContactMethodOutputWithContext(ctx context.Context) UserNotificationRuleContactMethodOutput {
	return o
}

func (o UserNotificationRuleContactMethodOutput) ToUserNotificationRuleContactMethodPtrOutput() UserNotificationRuleContactMethodPtrOutput {
	return o.ToUserNotificationRuleContactMethodPtrOutputWithContext(context.Background())
}

func (o UserNotificationRuleContactMethodOutput) ToUserNotificationRuleContactMethodPtrOutputWithContext(ctx context.Context) UserNotificationRuleContactMethodPtrOutput {
	return o.ApplyT(func(v UserNotificationRuleContactMethod) *UserNotificationRuleContactMethod {
		return &v
	}).(UserNotificationRuleContactMethodPtrOutput)
}

// The id of the referenced contact method.
func (o UserNotificationRuleContactMethodOutput) Id() pulumi.StringOutput {
	return o.ApplyT(func(v UserNotificationRuleContactMethod) string { return v.Id }).(pulumi.StringOutput)
}

// The type of contact method. Can be `emailContactMethod`, `phoneContactMethod`, `pushNotificationContactMethod` or `smsContactMethod`.
func (o UserNotificationRuleContactMethodOutput) Type() pulumi.StringOutput {
	return o.ApplyT(func(v UserNotificationRuleContactMethod) string { return v.Type }).(pulumi.StringOutput)
}

type UserNotificationRuleContactMethodPtrOutput struct{ *pulumi.OutputState }

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

func (o UserNotificationRuleContactMethodPtrOutput) ToUserNotificationRuleContactMethodPtrOutput() UserNotificationRuleContactMethodPtrOutput {
	return o
}

func (o UserNotificationRuleContactMethodPtrOutput) ToUserNotificationRuleContactMethodPtrOutputWithContext(ctx context.Context) UserNotificationRuleContactMethodPtrOutput {
	return o
}

func (o UserNotificationRuleContactMethodPtrOutput) Elem() UserNotificationRuleContactMethodOutput {
	return o.ApplyT(func(v *UserNotificationRuleContactMethod) UserNotificationRuleContactMethod { return *v }).(UserNotificationRuleContactMethodOutput)
}

// The id of the referenced contact method.
func (o UserNotificationRuleContactMethodPtrOutput) Id() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *UserNotificationRuleContactMethod) *string {
		if v == nil {
			return nil
		}
		return &v.Id
	}).(pulumi.StringPtrOutput)
}

// The type of contact method. Can be `emailContactMethod`, `phoneContactMethod`, `pushNotificationContactMethod` or `smsContactMethod`.
func (o UserNotificationRuleContactMethodPtrOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *UserNotificationRuleContactMethod) *string {
		if v == nil {
			return nil
		}
		return &v.Type
	}).(pulumi.StringPtrOutput)
}

func init() {
	pulumi.RegisterOutputType(EscalationPolicyRuleOutput{})
	pulumi.RegisterOutputType(EscalationPolicyRuleArrayOutput{})
	pulumi.RegisterOutputType(EscalationPolicyRuleTargetOutput{})
	pulumi.RegisterOutputType(EscalationPolicyRuleTargetArrayOutput{})
	pulumi.RegisterOutputType(RulesetRuleActionsOutput{})
	pulumi.RegisterOutputType(RulesetRuleActionsPtrOutput{})
	pulumi.RegisterOutputType(RulesetRuleActionsAnnotateOutput{})
	pulumi.RegisterOutputType(RulesetRuleActionsAnnotateArrayOutput{})
	pulumi.RegisterOutputType(RulesetRuleActionsEventActionOutput{})
	pulumi.RegisterOutputType(RulesetRuleActionsEventActionArrayOutput{})
	pulumi.RegisterOutputType(RulesetRuleActionsExtractionOutput{})
	pulumi.RegisterOutputType(RulesetRuleActionsExtractionArrayOutput{})
	pulumi.RegisterOutputType(RulesetRuleActionsPriorityOutput{})
	pulumi.RegisterOutputType(RulesetRuleActionsPriorityArrayOutput{})
	pulumi.RegisterOutputType(RulesetRuleActionsRouteOutput{})
	pulumi.RegisterOutputType(RulesetRuleActionsRouteArrayOutput{})
	pulumi.RegisterOutputType(RulesetRuleActionsSeverityOutput{})
	pulumi.RegisterOutputType(RulesetRuleActionsSeverityArrayOutput{})
	pulumi.RegisterOutputType(RulesetRuleActionsSuppressOutput{})
	pulumi.RegisterOutputType(RulesetRuleActionsSuppressArrayOutput{})
	pulumi.RegisterOutputType(RulesetRuleConditionsOutput{})
	pulumi.RegisterOutputType(RulesetRuleConditionsPtrOutput{})
	pulumi.RegisterOutputType(RulesetRuleConditionsSubconditionOutput{})
	pulumi.RegisterOutputType(RulesetRuleConditionsSubconditionArrayOutput{})
	pulumi.RegisterOutputType(RulesetRuleConditionsSubconditionParameterOutput{})
	pulumi.RegisterOutputType(RulesetRuleConditionsSubconditionParameterArrayOutput{})
	pulumi.RegisterOutputType(RulesetRuleTimeFrameOutput{})
	pulumi.RegisterOutputType(RulesetRuleTimeFramePtrOutput{})
	pulumi.RegisterOutputType(RulesetRuleTimeFrameActiveBetweenOutput{})
	pulumi.RegisterOutputType(RulesetRuleTimeFrameActiveBetweenArrayOutput{})
	pulumi.RegisterOutputType(RulesetRuleTimeFrameScheduledWeeklyOutput{})
	pulumi.RegisterOutputType(RulesetRuleTimeFrameScheduledWeeklyArrayOutput{})
	pulumi.RegisterOutputType(RulesetTeamOutput{})
	pulumi.RegisterOutputType(RulesetTeamPtrOutput{})
	pulumi.RegisterOutputType(ScheduleLayerOutput{})
	pulumi.RegisterOutputType(ScheduleLayerArrayOutput{})
	pulumi.RegisterOutputType(ScheduleLayerRestrictionOutput{})
	pulumi.RegisterOutputType(ScheduleLayerRestrictionArrayOutput{})
	pulumi.RegisterOutputType(ServiceDependencyDependencyOutput{})
	pulumi.RegisterOutputType(ServiceDependencyDependencyArrayOutput{})
	pulumi.RegisterOutputType(ServiceDependencyDependencyDependentServiceOutput{})
	pulumi.RegisterOutputType(ServiceDependencyDependencyDependentServiceArrayOutput{})
	pulumi.RegisterOutputType(ServiceDependencyDependencySupportingServiceOutput{})
	pulumi.RegisterOutputType(ServiceDependencyDependencySupportingServiceArrayOutput{})
	pulumi.RegisterOutputType(ServiceIncidentUrgencyRuleOutput{})
	pulumi.RegisterOutputType(ServiceIncidentUrgencyRulePtrOutput{})
	pulumi.RegisterOutputType(ServiceIncidentUrgencyRuleDuringSupportHoursOutput{})
	pulumi.RegisterOutputType(ServiceIncidentUrgencyRuleDuringSupportHoursPtrOutput{})
	pulumi.RegisterOutputType(ServiceIncidentUrgencyRuleOutsideSupportHoursOutput{})
	pulumi.RegisterOutputType(ServiceIncidentUrgencyRuleOutsideSupportHoursPtrOutput{})
	pulumi.RegisterOutputType(ServiceScheduledActionOutput{})
	pulumi.RegisterOutputType(ServiceScheduledActionArrayOutput{})
	pulumi.RegisterOutputType(ServiceScheduledActionAtOutput{})
	pulumi.RegisterOutputType(ServiceScheduledActionAtArrayOutput{})
	pulumi.RegisterOutputType(ServiceSupportHoursOutput{})
	pulumi.RegisterOutputType(ServiceSupportHoursPtrOutput{})
	pulumi.RegisterOutputType(UserNotificationRuleContactMethodOutput{})
	pulumi.RegisterOutputType(UserNotificationRuleContactMethodPtrOutput{})
}