opsgenie

package
v1.3.7 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 23, 2024 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Overview

A Pulumi package for creating and managing opsgenie cloud resources.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AlertPolicy 

type AlertPolicy struct {
	pulumi.CustomResourceState

	// Actions to add to the alerts original actions value as a list of strings. If `ignoreOriginalActions` field is set to `true`, this will replace the original actions.
	Actions pulumi.StringArrayOutput `pulumi:"actions"`
	// Description of the alert. You can use `{{description}}` to refer to the original alert description. Default: `{{description}}`
	AlertDescription pulumi.StringPtrOutput `pulumi:"alertDescription"`
	// Alias of the alert. You can use `{{alias}}` to refer to the original alias. Default: `{{alias}}`
	Alias pulumi.StringPtrOutput `pulumi:"alias"`
	// It will trigger other modify policies if set to `true`. Default: `false`
	ContinuePolicy pulumi.BoolPtrOutput `pulumi:"continuePolicy"`
	// If policy should be enabled. Default: `true`
	Enabled pulumi.BoolPtrOutput `pulumi:"enabled"`
	// Entity field of the alert. You can use `{{entity}}` to refer to the original entity. Default: `{{entity}}`
	Entity pulumi.StringPtrOutput `pulumi:"entity"`
	// A alert filter which will be applied. This filter can be empty: `filter {}` - this means `match-all`. This is a block, structure is documented below.
	Filters AlertPolicyFilterArrayOutput `pulumi:"filters"`
	// If set to `true`, policy will ignore the original actions of the alert. Default: `false`
	IgnoreOriginalActions pulumi.BoolPtrOutput `pulumi:"ignoreOriginalActions"`
	// If set to `true`, policy will ignore the original details of the alert. Default: `false`
	IgnoreOriginalDetails pulumi.BoolPtrOutput `pulumi:"ignoreOriginalDetails"`
	// If set to `true`, policy will ignore the original responders of the alert. Default: `false`
	IgnoreOriginalResponders pulumi.BoolPtrOutput `pulumi:"ignoreOriginalResponders"`
	// If set to `true`, policy will ignore the original tags of the alert. Default: `false`
	IgnoreOriginalTags pulumi.BoolPtrOutput `pulumi:"ignoreOriginalTags"`
	// Message of the alerts
	Message pulumi.StringOutput `pulumi:"message"`
	// Name of the alert policy
	Name pulumi.StringOutput `pulumi:"name"`
	// Description of the policy. This can be max 512 characters.
	PolicyDescription pulumi.StringPtrOutput `pulumi:"policyDescription"`
	// Priority of the alert. Should be one of `P1`, `P2`, `P3`, `P4`, or `P5`
	Priority pulumi.StringPtrOutput `pulumi:"priority"`
	// Responders to add to the alerts original responders value as a list of teams, users or the reserved word none or all. If `ignoreOriginalResponders` field is set to `true`, this will replace the original responders. The possible values for responders are: `user`, `team`, `escalation`, `schedule`. This is a block, structure is documented below.
	Responders AlertPolicyResponderArrayOutput `pulumi:"responders"`
	// Source field of the alert. You can use `{{source}}` to refer to the original source. Default: `{{source}}`
	Source pulumi.StringPtrOutput `pulumi:"source"`
	// Tags to add to the alerts original tags value as a list of strings. If `ignoreOriginalResponders` field is set to `true`, this will replace the original responders.
	Tags pulumi.StringArrayOutput `pulumi:"tags"`
	// Id of team that this policy belongs to.
	TeamId pulumi.StringPtrOutput `pulumi:"teamId"`
	// Time restrictions specified in this field must be met for this policy to work. This is a block, structure is documented below.
	TimeRestrictions AlertPolicyTimeRestrictionArrayOutput `pulumi:"timeRestrictions"`
}

Manages a Alert Policy within Opsgenie.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		test, err := opsgenie.NewTeam(ctx, "test", &opsgenie.TeamArgs{
			Name:        pulumi.String("example team"),
			Description: pulumi.String("This team deals with all the things"),
		})
		if err != nil {
			return err
		}
		_, err = opsgenie.NewAlertPolicy(ctx, "test", &opsgenie.AlertPolicyArgs{
			Filters: opsgenie.AlertPolicyFilterArray{
				nil,
			},
			Name:              pulumi.String("example policy"),
			TeamId:            test.ID(),
			PolicyDescription: pulumi.String("This is sample policy"),
			Message:           pulumi.String("{{message}}"),
			TimeRestrictions: opsgenie.AlertPolicyTimeRestrictionArray{
				&opsgenie.AlertPolicyTimeRestrictionArgs{
					Type: pulumi.String("weekday-and-time-of-day"),
					RestrictionList: opsgenie.AlertPolicyTimeRestrictionRestrictionListArray{
						&opsgenie.AlertPolicyTimeRestrictionRestrictionListArgs{
							EndDay:    pulumi.String("monday"),
							EndHour:   pulumi.Int(7),
							EndMin:    pulumi.Int(0),
							StartDay:  pulumi.String("sunday"),
							StartHour: pulumi.Int(21),
							StartMin:  pulumi.Int(0),
						},
						&opsgenie.AlertPolicyTimeRestrictionRestrictionListArgs{
							EndDay:    pulumi.String("tuesday"),
							EndHour:   pulumi.Int(7),
							EndMin:    pulumi.Int(0),
							StartDay:  pulumi.String("monday"),
							StartHour: pulumi.Int(22),
							StartMin:  pulumi.Int(0),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Alert policies can be imported using the `team_id/policy_id`, e.g.

```sh $ pulumi import opsgenie:index/alertPolicy:AlertPolicy test team_id/policy_id` ```

You can import global polices using only policy identifier

```sh $ pulumi import opsgenie:index/alertPolicy:AlertPolicy test policy_id` ```

func GetAlertPolicy 

func GetAlertPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *AlertPolicyState, opts ...pulumi.ResourceOption) (*AlertPolicy, error)

GetAlertPolicy gets an existing AlertPolicy resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewAlertPolicy 

func NewAlertPolicy(ctx *pulumi.Context,
	name string, args *AlertPolicyArgs, opts ...pulumi.ResourceOption) (*AlertPolicy, error)

NewAlertPolicy registers a new resource with the given unique name, arguments, and options.

func (*AlertPolicy) ElementType 

func (*AlertPolicy) ElementType() reflect.Type

func (*AlertPolicy) ToAlertPolicyOutput 

func (i *AlertPolicy) ToAlertPolicyOutput() AlertPolicyOutput

func (*AlertPolicy) ToAlertPolicyOutputWithContext 

func (i *AlertPolicy) ToAlertPolicyOutputWithContext(ctx context.Context) AlertPolicyOutput

type AlertPolicyArgs 

type AlertPolicyArgs struct {
	// Actions to add to the alerts original actions value as a list of strings. If `ignoreOriginalActions` field is set to `true`, this will replace the original actions.
	Actions pulumi.StringArrayInput
	// Description of the alert. You can use `{{description}}` to refer to the original alert description. Default: `{{description}}`
	AlertDescription pulumi.StringPtrInput
	// Alias of the alert. You can use `{{alias}}` to refer to the original alias. Default: `{{alias}}`
	Alias pulumi.StringPtrInput
	// It will trigger other modify policies if set to `true`. Default: `false`
	ContinuePolicy pulumi.BoolPtrInput
	// If policy should be enabled. Default: `true`
	Enabled pulumi.BoolPtrInput
	// Entity field of the alert. You can use `{{entity}}` to refer to the original entity. Default: `{{entity}}`
	Entity pulumi.StringPtrInput
	// A alert filter which will be applied. This filter can be empty: `filter {}` - this means `match-all`. This is a block, structure is documented below.
	Filters AlertPolicyFilterArrayInput
	// If set to `true`, policy will ignore the original actions of the alert. Default: `false`
	IgnoreOriginalActions pulumi.BoolPtrInput
	// If set to `true`, policy will ignore the original details of the alert. Default: `false`
	IgnoreOriginalDetails pulumi.BoolPtrInput
	// If set to `true`, policy will ignore the original responders of the alert. Default: `false`
	IgnoreOriginalResponders pulumi.BoolPtrInput
	// If set to `true`, policy will ignore the original tags of the alert. Default: `false`
	IgnoreOriginalTags pulumi.BoolPtrInput
	// Message of the alerts
	Message pulumi.StringInput
	// Name of the alert policy
	Name pulumi.StringPtrInput
	// Description of the policy. This can be max 512 characters.
	PolicyDescription pulumi.StringPtrInput
	// Priority of the alert. Should be one of `P1`, `P2`, `P3`, `P4`, or `P5`
	Priority pulumi.StringPtrInput
	// Responders to add to the alerts original responders value as a list of teams, users or the reserved word none or all. If `ignoreOriginalResponders` field is set to `true`, this will replace the original responders. The possible values for responders are: `user`, `team`, `escalation`, `schedule`. This is a block, structure is documented below.
	Responders AlertPolicyResponderArrayInput
	// Source field of the alert. You can use `{{source}}` to refer to the original source. Default: `{{source}}`
	Source pulumi.StringPtrInput
	// Tags to add to the alerts original tags value as a list of strings. If `ignoreOriginalResponders` field is set to `true`, this will replace the original responders.
	Tags pulumi.StringArrayInput
	// Id of team that this policy belongs to.
	TeamId pulumi.StringPtrInput
	// Time restrictions specified in this field must be met for this policy to work. This is a block, structure is documented below.
	TimeRestrictions AlertPolicyTimeRestrictionArrayInput
}

The set of arguments for constructing a AlertPolicy resource.

func (AlertPolicyArgs) ElementType 

func (AlertPolicyArgs) ElementType() reflect.Type

type AlertPolicyArray added in v0.1.3 

type AlertPolicyArray []AlertPolicyInput

func (AlertPolicyArray) ElementType added in v0.1.3 

func (AlertPolicyArray) ElementType() reflect.Type

func (AlertPolicyArray) ToAlertPolicyArrayOutput added in v0.1.3 

func (i AlertPolicyArray) ToAlertPolicyArrayOutput() AlertPolicyArrayOutput

func (AlertPolicyArray) ToAlertPolicyArrayOutputWithContext added in v0.1.3 

func (i AlertPolicyArray) ToAlertPolicyArrayOutputWithContext(ctx context.Context) AlertPolicyArrayOutput

type AlertPolicyArrayInput added in v0.1.3 

type AlertPolicyArrayInput interface {
	pulumi.Input

	ToAlertPolicyArrayOutput() AlertPolicyArrayOutput
	ToAlertPolicyArrayOutputWithContext(context.Context) AlertPolicyArrayOutput
}

AlertPolicyArrayInput is an input type that accepts AlertPolicyArray and AlertPolicyArrayOutput values. You can construct a concrete instance of `AlertPolicyArrayInput` via: 

AlertPolicyArray{ AlertPolicyArgs{...} }

type AlertPolicyArrayOutput added in v0.1.3 

type AlertPolicyArrayOutput struct{ *pulumi.OutputState }

func (AlertPolicyArrayOutput) ElementType added in v0.1.3 

func (AlertPolicyArrayOutput) ElementType() reflect.Type

func (AlertPolicyArrayOutput) Index added in v0.1.3 

func (o AlertPolicyArrayOutput) Index(i pulumi.IntInput) AlertPolicyOutput

func (AlertPolicyArrayOutput) ToAlertPolicyArrayOutput added in v0.1.3 

func (o AlertPolicyArrayOutput) ToAlertPolicyArrayOutput() AlertPolicyArrayOutput

func (AlertPolicyArrayOutput) ToAlertPolicyArrayOutputWithContext added in v0.1.3 

func (o AlertPolicyArrayOutput) ToAlertPolicyArrayOutputWithContext(ctx context.Context) AlertPolicyArrayOutput

type AlertPolicyFilter 

type AlertPolicyFilter struct {
	// Conditions applied to filter. This is a block, structure is documented below.
	Conditions []AlertPolicyFilterCondition `pulumi:"conditions"`
	// A filter type, supported types are: `match-all`, `match-any-condition`, `match-all-conditions`. Default: `match-all`
	Type *string `pulumi:"type"`
}

type AlertPolicyFilterArgs 

type AlertPolicyFilterArgs struct {
	// Conditions applied to filter. This is a block, structure is documented below.
	Conditions AlertPolicyFilterConditionArrayInput `pulumi:"conditions"`
	// A filter type, supported types are: `match-all`, `match-any-condition`, `match-all-conditions`. Default: `match-all`
	Type pulumi.StringPtrInput `pulumi:"type"`
}

func (AlertPolicyFilterArgs) ElementType 

func (AlertPolicyFilterArgs) ElementType() reflect.Type

func (AlertPolicyFilterArgs) ToAlertPolicyFilterOutput 

func (i AlertPolicyFilterArgs) ToAlertPolicyFilterOutput() AlertPolicyFilterOutput

func (AlertPolicyFilterArgs) ToAlertPolicyFilterOutputWithContext 

func (i AlertPolicyFilterArgs) ToAlertPolicyFilterOutputWithContext(ctx context.Context) AlertPolicyFilterOutput

type AlertPolicyFilterArray 

type AlertPolicyFilterArray []AlertPolicyFilterInput

func (AlertPolicyFilterArray) ElementType 

func (AlertPolicyFilterArray) ElementType() reflect.Type

func (AlertPolicyFilterArray) ToAlertPolicyFilterArrayOutput 

func (i AlertPolicyFilterArray) ToAlertPolicyFilterArrayOutput() AlertPolicyFilterArrayOutput

func (AlertPolicyFilterArray) ToAlertPolicyFilterArrayOutputWithContext 

func (i AlertPolicyFilterArray) ToAlertPolicyFilterArrayOutputWithContext(ctx context.Context) AlertPolicyFilterArrayOutput

type AlertPolicyFilterArrayInput 

type AlertPolicyFilterArrayInput interface {
	pulumi.Input

	ToAlertPolicyFilterArrayOutput() AlertPolicyFilterArrayOutput
	ToAlertPolicyFilterArrayOutputWithContext(context.Context) AlertPolicyFilterArrayOutput
}

AlertPolicyFilterArrayInput is an input type that accepts AlertPolicyFilterArray and AlertPolicyFilterArrayOutput values. You can construct a concrete instance of `AlertPolicyFilterArrayInput` via: 

AlertPolicyFilterArray{ AlertPolicyFilterArgs{...} }

type AlertPolicyFilterArrayOutput 

type AlertPolicyFilterArrayOutput struct{ *pulumi.OutputState }

func (AlertPolicyFilterArrayOutput) ElementType 

func (AlertPolicyFilterArrayOutput) ElementType() reflect.Type

func (AlertPolicyFilterArrayOutput) Index 

func (o AlertPolicyFilterArrayOutput) Index(i pulumi.IntInput) AlertPolicyFilterOutput

func (AlertPolicyFilterArrayOutput) ToAlertPolicyFilterArrayOutput 

func (o AlertPolicyFilterArrayOutput) ToAlertPolicyFilterArrayOutput() AlertPolicyFilterArrayOutput

func (AlertPolicyFilterArrayOutput) ToAlertPolicyFilterArrayOutputWithContext 

func (o AlertPolicyFilterArrayOutput) ToAlertPolicyFilterArrayOutputWithContext(ctx context.Context) AlertPolicyFilterArrayOutput

type AlertPolicyFilterCondition 

type AlertPolicyFilterCondition struct {
	// User defined value that will be compared with alert field according to the operation. Default: empty string
	ExpectedValue *string `pulumi:"expectedValue"`
	// Specifies which alert field will be used in condition. Possible values are `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `responders`, `teams`, `priority`
	Field string `pulumi:"field"`
	// If `field` is set as extra-properties, key could be used for key-value pair
	Key *string `pulumi:"key"`
	// Indicates behaviour of the given operation. Default: `false`
	Not *bool `pulumi:"not"`
	// It is the operation that will be executed for the given field and key. Possible operations are `matches`, `contains`, `starts-with`, `ends-with`, `equals`, `contains-key`, `contains-value`, `greater-than`, `less-than`, `is-empty`, `equals-ignore-whitespace`.
	Operation string `pulumi:"operation"`
	// Order of the condition in conditions list
	Order *int `pulumi:"order"`
}

type AlertPolicyFilterConditionArgs 

type AlertPolicyFilterConditionArgs struct {
	// User defined value that will be compared with alert field according to the operation. Default: empty string
	ExpectedValue pulumi.StringPtrInput `pulumi:"expectedValue"`
	// Specifies which alert field will be used in condition. Possible values are `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `responders`, `teams`, `priority`
	Field pulumi.StringInput `pulumi:"field"`
	// If `field` is set as extra-properties, key could be used for key-value pair
	Key pulumi.StringPtrInput `pulumi:"key"`
	// Indicates behaviour of the given operation. Default: `false`
	Not pulumi.BoolPtrInput `pulumi:"not"`
	// It is the operation that will be executed for the given field and key. Possible operations are `matches`, `contains`, `starts-with`, `ends-with`, `equals`, `contains-key`, `contains-value`, `greater-than`, `less-than`, `is-empty`, `equals-ignore-whitespace`.
	Operation pulumi.StringInput `pulumi:"operation"`
	// Order of the condition in conditions list
	Order pulumi.IntPtrInput `pulumi:"order"`
}

func (AlertPolicyFilterConditionArgs) ElementType 

func (AlertPolicyFilterConditionArgs) ElementType() reflect.Type

func (AlertPolicyFilterConditionArgs) ToAlertPolicyFilterConditionOutput 

func (i AlertPolicyFilterConditionArgs) ToAlertPolicyFilterConditionOutput() AlertPolicyFilterConditionOutput

func (AlertPolicyFilterConditionArgs) ToAlertPolicyFilterConditionOutputWithContext 

func (i AlertPolicyFilterConditionArgs) ToAlertPolicyFilterConditionOutputWithContext(ctx context.Context) AlertPolicyFilterConditionOutput

type AlertPolicyFilterConditionArray 

type AlertPolicyFilterConditionArray []AlertPolicyFilterConditionInput

func (AlertPolicyFilterConditionArray) ElementType 

func (AlertPolicyFilterConditionArray) ElementType() reflect.Type

func (AlertPolicyFilterConditionArray) ToAlertPolicyFilterConditionArrayOutput 

func (i AlertPolicyFilterConditionArray) ToAlertPolicyFilterConditionArrayOutput() AlertPolicyFilterConditionArrayOutput

func (AlertPolicyFilterConditionArray) ToAlertPolicyFilterConditionArrayOutputWithContext 

func (i AlertPolicyFilterConditionArray) ToAlertPolicyFilterConditionArrayOutputWithContext(ctx context.Context) AlertPolicyFilterConditionArrayOutput

type AlertPolicyFilterConditionArrayInput 

type AlertPolicyFilterConditionArrayInput interface {
	pulumi.Input

	ToAlertPolicyFilterConditionArrayOutput() AlertPolicyFilterConditionArrayOutput
	ToAlertPolicyFilterConditionArrayOutputWithContext(context.Context) AlertPolicyFilterConditionArrayOutput
}

AlertPolicyFilterConditionArrayInput is an input type that accepts AlertPolicyFilterConditionArray and AlertPolicyFilterConditionArrayOutput values. You can construct a concrete instance of `AlertPolicyFilterConditionArrayInput` via: 

AlertPolicyFilterConditionArray{ AlertPolicyFilterConditionArgs{...} }

type AlertPolicyFilterConditionArrayOutput 

type AlertPolicyFilterConditionArrayOutput struct{ *pulumi.OutputState }

func (AlertPolicyFilterConditionArrayOutput) ElementType 

func (AlertPolicyFilterConditionArrayOutput) ElementType() reflect.Type

func (AlertPolicyFilterConditionArrayOutput) Index 

func (o AlertPolicyFilterConditionArrayOutput) Index(i pulumi.IntInput) AlertPolicyFilterConditionOutput

func (AlertPolicyFilterConditionArrayOutput) ToAlertPolicyFilterConditionArrayOutput 

func (o AlertPolicyFilterConditionArrayOutput) ToAlertPolicyFilterConditionArrayOutput() AlertPolicyFilterConditionArrayOutput

func (AlertPolicyFilterConditionArrayOutput) ToAlertPolicyFilterConditionArrayOutputWithContext 

func (o AlertPolicyFilterConditionArrayOutput) ToAlertPolicyFilterConditionArrayOutputWithContext(ctx context.Context) AlertPolicyFilterConditionArrayOutput

type AlertPolicyFilterConditionInput 

type AlertPolicyFilterConditionInput interface {
	pulumi.Input

	ToAlertPolicyFilterConditionOutput() AlertPolicyFilterConditionOutput
	ToAlertPolicyFilterConditionOutputWithContext(context.Context) AlertPolicyFilterConditionOutput
}

AlertPolicyFilterConditionInput is an input type that accepts AlertPolicyFilterConditionArgs and AlertPolicyFilterConditionOutput values. You can construct a concrete instance of `AlertPolicyFilterConditionInput` via: 

AlertPolicyFilterConditionArgs{...}

type AlertPolicyFilterConditionOutput 

type AlertPolicyFilterConditionOutput struct{ *pulumi.OutputState }

func (AlertPolicyFilterConditionOutput) ElementType 

func (AlertPolicyFilterConditionOutput) ElementType() reflect.Type

func (AlertPolicyFilterConditionOutput) ExpectedValue 

func (o AlertPolicyFilterConditionOutput) ExpectedValue() pulumi.StringPtrOutput

User defined value that will be compared with alert field according to the operation. Default: empty string

func (AlertPolicyFilterConditionOutput) Field 

func (o AlertPolicyFilterConditionOutput) Field() pulumi.StringOutput

Specifies which alert field will be used in condition. Possible values are `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `responders`, `teams`, `priority`

func (AlertPolicyFilterConditionOutput) Key 

func (o AlertPolicyFilterConditionOutput) Key() pulumi.StringPtrOutput

If `field` is set as extra-properties, key could be used for key-value pair

func (AlertPolicyFilterConditionOutput) Not 

func (o AlertPolicyFilterConditionOutput) Not() pulumi.BoolPtrOutput

Indicates behaviour of the given operation. Default: `false`

func (AlertPolicyFilterConditionOutput) Operation 

func (o AlertPolicyFilterConditionOutput) Operation() pulumi.StringOutput

It is the operation that will be executed for the given field and key. Possible operations are `matches`, `contains`, `starts-with`, `ends-with`, `equals`, `contains-key`, `contains-value`, `greater-than`, `less-than`, `is-empty`, `equals-ignore-whitespace`.

func (AlertPolicyFilterConditionOutput) Order 

func (o AlertPolicyFilterConditionOutput) Order() pulumi.IntPtrOutput

Order of the condition in conditions list

func (AlertPolicyFilterConditionOutput) ToAlertPolicyFilterConditionOutput 

func (o AlertPolicyFilterConditionOutput) ToAlertPolicyFilterConditionOutput() AlertPolicyFilterConditionOutput

func (AlertPolicyFilterConditionOutput) ToAlertPolicyFilterConditionOutputWithContext 

func (o AlertPolicyFilterConditionOutput) ToAlertPolicyFilterConditionOutputWithContext(ctx context.Context) AlertPolicyFilterConditionOutput

type AlertPolicyFilterInput 

type AlertPolicyFilterInput interface {
	pulumi.Input

	ToAlertPolicyFilterOutput() AlertPolicyFilterOutput
	ToAlertPolicyFilterOutputWithContext(context.Context) AlertPolicyFilterOutput
}

AlertPolicyFilterInput is an input type that accepts AlertPolicyFilterArgs and AlertPolicyFilterOutput values. You can construct a concrete instance of `AlertPolicyFilterInput` via: 

AlertPolicyFilterArgs{...}

type AlertPolicyFilterOutput 

type AlertPolicyFilterOutput struct{ *pulumi.OutputState }

func (AlertPolicyFilterOutput) Conditions 

func (o AlertPolicyFilterOutput) Conditions() AlertPolicyFilterConditionArrayOutput

Conditions applied to filter. This is a block, structure is documented below.

func (AlertPolicyFilterOutput) ElementType 

func (AlertPolicyFilterOutput) ElementType() reflect.Type

func (AlertPolicyFilterOutput) ToAlertPolicyFilterOutput 

func (o AlertPolicyFilterOutput) ToAlertPolicyFilterOutput() AlertPolicyFilterOutput

func (AlertPolicyFilterOutput) ToAlertPolicyFilterOutputWithContext 

func (o AlertPolicyFilterOutput) ToAlertPolicyFilterOutputWithContext(ctx context.Context) AlertPolicyFilterOutput

func (AlertPolicyFilterOutput) Type 

func (o AlertPolicyFilterOutput) Type() pulumi.StringPtrOutput

A filter type, supported types are: `match-all`, `match-any-condition`, `match-all-conditions`. Default: `match-all`

type AlertPolicyInput 

type AlertPolicyInput interface {
	pulumi.Input

	ToAlertPolicyOutput() AlertPolicyOutput
	ToAlertPolicyOutputWithContext(ctx context.Context) AlertPolicyOutput
}

type AlertPolicyMap added in v0.1.3 

type AlertPolicyMap map[string]AlertPolicyInput

func (AlertPolicyMap) ElementType added in v0.1.3 

func (AlertPolicyMap) ElementType() reflect.Type

func (AlertPolicyMap) ToAlertPolicyMapOutput added in v0.1.3 

func (i AlertPolicyMap) ToAlertPolicyMapOutput() AlertPolicyMapOutput

func (AlertPolicyMap) ToAlertPolicyMapOutputWithContext added in v0.1.3 

func (i AlertPolicyMap) ToAlertPolicyMapOutputWithContext(ctx context.Context) AlertPolicyMapOutput

type AlertPolicyMapInput added in v0.1.3 

type AlertPolicyMapInput interface {
	pulumi.Input

	ToAlertPolicyMapOutput() AlertPolicyMapOutput
	ToAlertPolicyMapOutputWithContext(context.Context) AlertPolicyMapOutput
}

AlertPolicyMapInput is an input type that accepts AlertPolicyMap and AlertPolicyMapOutput values. You can construct a concrete instance of `AlertPolicyMapInput` via: 

AlertPolicyMap{ "key": AlertPolicyArgs{...} }

type AlertPolicyMapOutput added in v0.1.3 

type AlertPolicyMapOutput struct{ *pulumi.OutputState }

func (AlertPolicyMapOutput) ElementType added in v0.1.3 

func (AlertPolicyMapOutput) ElementType() reflect.Type

func (AlertPolicyMapOutput) MapIndex added in v0.1.3 

func (o AlertPolicyMapOutput) MapIndex(k pulumi.StringInput) AlertPolicyOutput

func (AlertPolicyMapOutput) ToAlertPolicyMapOutput added in v0.1.3 

func (o AlertPolicyMapOutput) ToAlertPolicyMapOutput() AlertPolicyMapOutput

func (AlertPolicyMapOutput) ToAlertPolicyMapOutputWithContext added in v0.1.3 

func (o AlertPolicyMapOutput) ToAlertPolicyMapOutputWithContext(ctx context.Context) AlertPolicyMapOutput

type AlertPolicyOutput 

type AlertPolicyOutput struct{ *pulumi.OutputState }

func (AlertPolicyOutput) Actions added in v1.1.9 

func (o AlertPolicyOutput) Actions() pulumi.StringArrayOutput

Actions to add to the alerts original actions value as a list of strings. If `ignoreOriginalActions` field is set to `true`, this will replace the original actions.

func (AlertPolicyOutput) AlertDescription added in v1.1.9 

func (o AlertPolicyOutput) AlertDescription() pulumi.StringPtrOutput

Description of the alert. You can use `{{description}}` to refer to the original alert description. Default: `{{description}}`

func (AlertPolicyOutput) Alias added in v1.1.9 

func (o AlertPolicyOutput) Alias() pulumi.StringPtrOutput

Alias of the alert. You can use `{{alias}}` to refer to the original alias. Default: `{{alias}}`

func (AlertPolicyOutput) ContinuePolicy added in v1.1.9 

func (o AlertPolicyOutput) ContinuePolicy() pulumi.BoolPtrOutput

It will trigger other modify policies if set to `true`. Default: `false`

func (AlertPolicyOutput) ElementType 

func (AlertPolicyOutput) ElementType() reflect.Type

func (AlertPolicyOutput) Enabled added in v1.1.9 

func (o AlertPolicyOutput) Enabled() pulumi.BoolPtrOutput

If policy should be enabled. Default: `true`

func (AlertPolicyOutput) Entity added in v1.1.9 

func (o AlertPolicyOutput) Entity() pulumi.StringPtrOutput

Entity field of the alert. You can use `{{entity}}` to refer to the original entity. Default: `{{entity}}`

func (AlertPolicyOutput) Filters added in v1.1.9 

func (o AlertPolicyOutput) Filters() AlertPolicyFilterArrayOutput

A alert filter which will be applied. This filter can be empty: `filter {}` - this means `match-all`. This is a block, structure is documented below.

func (AlertPolicyOutput) IgnoreOriginalActions added in v1.1.9 

func (o AlertPolicyOutput) IgnoreOriginalActions() pulumi.BoolPtrOutput

If set to `true`, policy will ignore the original actions of the alert. Default: `false`

func (AlertPolicyOutput) IgnoreOriginalDetails added in v1.1.9 

func (o AlertPolicyOutput) IgnoreOriginalDetails() pulumi.BoolPtrOutput

If set to `true`, policy will ignore the original details of the alert. Default: `false`

func (AlertPolicyOutput) IgnoreOriginalResponders added in v1.1.9 

func (o AlertPolicyOutput) IgnoreOriginalResponders() pulumi.BoolPtrOutput

If set to `true`, policy will ignore the original responders of the alert. Default: `false`

func (AlertPolicyOutput) IgnoreOriginalTags added in v1.1.9 

func (o AlertPolicyOutput) IgnoreOriginalTags() pulumi.BoolPtrOutput

If set to `true`, policy will ignore the original tags of the alert. Default: `false`

func (AlertPolicyOutput) Message added in v1.1.9 

func (o AlertPolicyOutput) Message() pulumi.StringOutput

Message of the alerts

func (AlertPolicyOutput) Name added in v1.1.9 

func (o AlertPolicyOutput) Name() pulumi.StringOutput

Name of the alert policy

func (AlertPolicyOutput) PolicyDescription added in v1.1.9 

func (o AlertPolicyOutput) PolicyDescription() pulumi.StringPtrOutput

Description of the policy. This can be max 512 characters.

func (AlertPolicyOutput) Priority added in v1.1.9 

func (o AlertPolicyOutput) Priority() pulumi.StringPtrOutput

Priority of the alert. Should be one of `P1`, `P2`, `P3`, `P4`, or `P5`

func (AlertPolicyOutput) Responders added in v1.1.9 

func (o AlertPolicyOutput) Responders() AlertPolicyResponderArrayOutput

Responders to add to the alerts original responders value as a list of teams, users or the reserved word none or all. If `ignoreOriginalResponders` field is set to `true`, this will replace the original responders. The possible values for responders are: `user`, `team`, `escalation`, `schedule`. This is a block, structure is documented below.

func (AlertPolicyOutput) Source added in v1.1.9 

func (o AlertPolicyOutput) Source() pulumi.StringPtrOutput

Source field of the alert. You can use `{{source}}` to refer to the original source. Default: `{{source}}`

func (AlertPolicyOutput) Tags added in v1.1.9 

func (o AlertPolicyOutput) Tags() pulumi.StringArrayOutput

Tags to add to the alerts original tags value as a list of strings. If `ignoreOriginalResponders` field is set to `true`, this will replace the original responders.

func (AlertPolicyOutput) TeamId added in v1.1.9 

func (o AlertPolicyOutput) TeamId() pulumi.StringPtrOutput

Id of team that this policy belongs to.

func (AlertPolicyOutput) TimeRestrictions added in v1.1.9 

func (o AlertPolicyOutput) TimeRestrictions() AlertPolicyTimeRestrictionArrayOutput

Time restrictions specified in this field must be met for this policy to work. This is a block, structure is documented below.

func (AlertPolicyOutput) ToAlertPolicyOutput 

func (o AlertPolicyOutput) ToAlertPolicyOutput() AlertPolicyOutput

func (AlertPolicyOutput) ToAlertPolicyOutputWithContext 

func (o AlertPolicyOutput) ToAlertPolicyOutputWithContext(ctx context.Context) AlertPolicyOutput

type AlertPolicyResponder 

type AlertPolicyResponder struct {
	// ID of the responder
	Id string `pulumi:"id"`
	// Name of the responder
	Name *string `pulumi:"name"`
	// Type of responder. Acceptable values are: `user`, `team`, `escalation` or `schedule`
	Type string `pulumi:"type"`
	// Username of the responder
	Username *string `pulumi:"username"`
}

type AlertPolicyResponderArgs 

type AlertPolicyResponderArgs struct {
	// ID of the responder
	Id pulumi.StringInput `pulumi:"id"`
	// Name of the responder
	Name pulumi.StringPtrInput `pulumi:"name"`
	// Type of responder. Acceptable values are: `user`, `team`, `escalation` or `schedule`
	Type pulumi.StringInput `pulumi:"type"`
	// Username of the responder
	Username pulumi.StringPtrInput `pulumi:"username"`
}

func (AlertPolicyResponderArgs) ElementType 

func (AlertPolicyResponderArgs) ElementType() reflect.Type

func (AlertPolicyResponderArgs) ToAlertPolicyResponderOutput 

func (i AlertPolicyResponderArgs) ToAlertPolicyResponderOutput() AlertPolicyResponderOutput

func (AlertPolicyResponderArgs) ToAlertPolicyResponderOutputWithContext 

func (i AlertPolicyResponderArgs) ToAlertPolicyResponderOutputWithContext(ctx context.Context) AlertPolicyResponderOutput

type AlertPolicyResponderArray 

type AlertPolicyResponderArray []AlertPolicyResponderInput

func (AlertPolicyResponderArray) ElementType 

func (AlertPolicyResponderArray) ElementType() reflect.Type

func (AlertPolicyResponderArray) ToAlertPolicyResponderArrayOutput 

func (i AlertPolicyResponderArray) ToAlertPolicyResponderArrayOutput() AlertPolicyResponderArrayOutput

func (AlertPolicyResponderArray) ToAlertPolicyResponderArrayOutputWithContext 

func (i AlertPolicyResponderArray) ToAlertPolicyResponderArrayOutputWithContext(ctx context.Context) AlertPolicyResponderArrayOutput

type AlertPolicyResponderArrayInput 

type AlertPolicyResponderArrayInput interface {
	pulumi.Input

	ToAlertPolicyResponderArrayOutput() AlertPolicyResponderArrayOutput
	ToAlertPolicyResponderArrayOutputWithContext(context.Context) AlertPolicyResponderArrayOutput
}

AlertPolicyResponderArrayInput is an input type that accepts AlertPolicyResponderArray and AlertPolicyResponderArrayOutput values. You can construct a concrete instance of `AlertPolicyResponderArrayInput` via: 

AlertPolicyResponderArray{ AlertPolicyResponderArgs{...} }

type AlertPolicyResponderArrayOutput 

type AlertPolicyResponderArrayOutput struct{ *pulumi.OutputState }

func (AlertPolicyResponderArrayOutput) ElementType 

func (AlertPolicyResponderArrayOutput) ElementType() reflect.Type

func (AlertPolicyResponderArrayOutput) Index 

func (o AlertPolicyResponderArrayOutput) Index(i pulumi.IntInput) AlertPolicyResponderOutput

func (AlertPolicyResponderArrayOutput) ToAlertPolicyResponderArrayOutput 

func (o AlertPolicyResponderArrayOutput) ToAlertPolicyResponderArrayOutput() AlertPolicyResponderArrayOutput

func (AlertPolicyResponderArrayOutput) ToAlertPolicyResponderArrayOutputWithContext 

func (o AlertPolicyResponderArrayOutput) ToAlertPolicyResponderArrayOutputWithContext(ctx context.Context) AlertPolicyResponderArrayOutput

type AlertPolicyResponderInput 

type AlertPolicyResponderInput interface {
	pulumi.Input

	ToAlertPolicyResponderOutput() AlertPolicyResponderOutput
	ToAlertPolicyResponderOutputWithContext(context.Context) AlertPolicyResponderOutput
}

AlertPolicyResponderInput is an input type that accepts AlertPolicyResponderArgs and AlertPolicyResponderOutput values. You can construct a concrete instance of `AlertPolicyResponderInput` via: 

AlertPolicyResponderArgs{...}

type AlertPolicyResponderOutput 

type AlertPolicyResponderOutput struct{ *pulumi.OutputState }

func (AlertPolicyResponderOutput) ElementType 

func (AlertPolicyResponderOutput) ElementType() reflect.Type

func (AlertPolicyResponderOutput) Id 

func (o AlertPolicyResponderOutput) Id() pulumi.StringOutput

ID of the responder

func (AlertPolicyResponderOutput) Name 

func (o AlertPolicyResponderOutput) Name() pulumi.StringPtrOutput

Name of the responder

func (AlertPolicyResponderOutput) ToAlertPolicyResponderOutput 

func (o AlertPolicyResponderOutput) ToAlertPolicyResponderOutput() AlertPolicyResponderOutput

func (AlertPolicyResponderOutput) ToAlertPolicyResponderOutputWithContext 

func (o AlertPolicyResponderOutput) ToAlertPolicyResponderOutputWithContext(ctx context.Context) AlertPolicyResponderOutput

func (AlertPolicyResponderOutput) Type 

func (o AlertPolicyResponderOutput) Type() pulumi.StringOutput

Type of responder. Acceptable values are: `user`, `team`, `escalation` or `schedule`

func (AlertPolicyResponderOutput) Username 

func (o AlertPolicyResponderOutput) Username() pulumi.StringPtrOutput

Username of the responder

type AlertPolicyState 

type AlertPolicyState struct {
	// Actions to add to the alerts original actions value as a list of strings. If `ignoreOriginalActions` field is set to `true`, this will replace the original actions.
	Actions pulumi.StringArrayInput
	// Description of the alert. You can use `{{description}}` to refer to the original alert description. Default: `{{description}}`
	AlertDescription pulumi.StringPtrInput
	// Alias of the alert. You can use `{{alias}}` to refer to the original alias. Default: `{{alias}}`
	Alias pulumi.StringPtrInput
	// It will trigger other modify policies if set to `true`. Default: `false`
	ContinuePolicy pulumi.BoolPtrInput
	// If policy should be enabled. Default: `true`
	Enabled pulumi.BoolPtrInput
	// Entity field of the alert. You can use `{{entity}}` to refer to the original entity. Default: `{{entity}}`
	Entity pulumi.StringPtrInput
	// A alert filter which will be applied. This filter can be empty: `filter {}` - this means `match-all`. This is a block, structure is documented below.
	Filters AlertPolicyFilterArrayInput
	// If set to `true`, policy will ignore the original actions of the alert. Default: `false`
	IgnoreOriginalActions pulumi.BoolPtrInput
	// If set to `true`, policy will ignore the original details of the alert. Default: `false`
	IgnoreOriginalDetails pulumi.BoolPtrInput
	// If set to `true`, policy will ignore the original responders of the alert. Default: `false`
	IgnoreOriginalResponders pulumi.BoolPtrInput
	// If set to `true`, policy will ignore the original tags of the alert. Default: `false`
	IgnoreOriginalTags pulumi.BoolPtrInput
	// Message of the alerts
	Message pulumi.StringPtrInput
	// Name of the alert policy
	Name pulumi.StringPtrInput
	// Description of the policy. This can be max 512 characters.
	PolicyDescription pulumi.StringPtrInput
	// Priority of the alert. Should be one of `P1`, `P2`, `P3`, `P4`, or `P5`
	Priority pulumi.StringPtrInput
	// Responders to add to the alerts original responders value as a list of teams, users or the reserved word none or all. If `ignoreOriginalResponders` field is set to `true`, this will replace the original responders. The possible values for responders are: `user`, `team`, `escalation`, `schedule`. This is a block, structure is documented below.
	Responders AlertPolicyResponderArrayInput
	// Source field of the alert. You can use `{{source}}` to refer to the original source. Default: `{{source}}`
	Source pulumi.StringPtrInput
	// Tags to add to the alerts original tags value as a list of strings. If `ignoreOriginalResponders` field is set to `true`, this will replace the original responders.
	Tags pulumi.StringArrayInput
	// Id of team that this policy belongs to.
	TeamId pulumi.StringPtrInput
	// Time restrictions specified in this field must be met for this policy to work. This is a block, structure is documented below.
	TimeRestrictions AlertPolicyTimeRestrictionArrayInput
}

func (AlertPolicyState) ElementType 

func (AlertPolicyState) ElementType() reflect.Type

type AlertPolicyTimeRestriction 

type AlertPolicyTimeRestriction struct {
	// A definition of hourly definition applied daily, this has to be used with combination: type = `time-of-day`. This is a block, structure is documented below.
	Restriction []AlertPolicyTimeRestrictionRestriction `pulumi:"restriction"`
	// List of days and hours definitions for field type = `weekday-and-time-of-day`. This is a block, structure is documented below.
	RestrictionList []AlertPolicyTimeRestrictionRestrictionList `pulumi:"restrictionList"`
	// Defines if restriction should apply daily on given hours or on certain days and hours. Possible values are: `time-of-day`, `weekday-and-time-of-day`
	Type string `pulumi:"type"`
}

type AlertPolicyTimeRestrictionArgs 

type AlertPolicyTimeRestrictionArgs struct {
	// A definition of hourly definition applied daily, this has to be used with combination: type = `time-of-day`. This is a block, structure is documented below.
	Restriction AlertPolicyTimeRestrictionRestrictionArrayInput `pulumi:"restriction"`
	// List of days and hours definitions for field type = `weekday-and-time-of-day`. This is a block, structure is documented below.
	RestrictionList AlertPolicyTimeRestrictionRestrictionListArrayInput `pulumi:"restrictionList"`
	// Defines if restriction should apply daily on given hours or on certain days and hours. Possible values are: `time-of-day`, `weekday-and-time-of-day`
	Type pulumi.StringInput `pulumi:"type"`
}

func (AlertPolicyTimeRestrictionArgs) ElementType 

func (AlertPolicyTimeRestrictionArgs) ElementType() reflect.Type

func (AlertPolicyTimeRestrictionArgs) ToAlertPolicyTimeRestrictionOutput 

func (i AlertPolicyTimeRestrictionArgs) ToAlertPolicyTimeRestrictionOutput() AlertPolicyTimeRestrictionOutput

func (AlertPolicyTimeRestrictionArgs) ToAlertPolicyTimeRestrictionOutputWithContext 

func (i AlertPolicyTimeRestrictionArgs) ToAlertPolicyTimeRestrictionOutputWithContext(ctx context.Context) AlertPolicyTimeRestrictionOutput

type AlertPolicyTimeRestrictionArray 

type AlertPolicyTimeRestrictionArray []AlertPolicyTimeRestrictionInput

func (AlertPolicyTimeRestrictionArray) ElementType 

func (AlertPolicyTimeRestrictionArray) ElementType() reflect.Type

func (AlertPolicyTimeRestrictionArray) ToAlertPolicyTimeRestrictionArrayOutput 

func (i AlertPolicyTimeRestrictionArray) ToAlertPolicyTimeRestrictionArrayOutput() AlertPolicyTimeRestrictionArrayOutput

func (AlertPolicyTimeRestrictionArray) ToAlertPolicyTimeRestrictionArrayOutputWithContext 

func (i AlertPolicyTimeRestrictionArray) ToAlertPolicyTimeRestrictionArrayOutputWithContext(ctx context.Context) AlertPolicyTimeRestrictionArrayOutput

type AlertPolicyTimeRestrictionArrayInput 

type AlertPolicyTimeRestrictionArrayInput interface {
	pulumi.Input

	ToAlertPolicyTimeRestrictionArrayOutput() AlertPolicyTimeRestrictionArrayOutput
	ToAlertPolicyTimeRestrictionArrayOutputWithContext(context.Context) AlertPolicyTimeRestrictionArrayOutput
}

AlertPolicyTimeRestrictionArrayInput is an input type that accepts AlertPolicyTimeRestrictionArray and AlertPolicyTimeRestrictionArrayOutput values. You can construct a concrete instance of `AlertPolicyTimeRestrictionArrayInput` via: 

AlertPolicyTimeRestrictionArray{ AlertPolicyTimeRestrictionArgs{...} }

type AlertPolicyTimeRestrictionArrayOutput 

type AlertPolicyTimeRestrictionArrayOutput struct{ *pulumi.OutputState }

func (AlertPolicyTimeRestrictionArrayOutput) ElementType 

func (AlertPolicyTimeRestrictionArrayOutput) ElementType() reflect.Type

func (AlertPolicyTimeRestrictionArrayOutput) Index 

func (o AlertPolicyTimeRestrictionArrayOutput) Index(i pulumi.IntInput) AlertPolicyTimeRestrictionOutput

func (AlertPolicyTimeRestrictionArrayOutput) ToAlertPolicyTimeRestrictionArrayOutput 

func (o AlertPolicyTimeRestrictionArrayOutput) ToAlertPolicyTimeRestrictionArrayOutput() AlertPolicyTimeRestrictionArrayOutput

func (AlertPolicyTimeRestrictionArrayOutput) ToAlertPolicyTimeRestrictionArrayOutputWithContext 

func (o AlertPolicyTimeRestrictionArrayOutput) ToAlertPolicyTimeRestrictionArrayOutputWithContext(ctx context.Context) AlertPolicyTimeRestrictionArrayOutput

type AlertPolicyTimeRestrictionInput 

type AlertPolicyTimeRestrictionInput interface {
	pulumi.Input

	ToAlertPolicyTimeRestrictionOutput() AlertPolicyTimeRestrictionOutput
	ToAlertPolicyTimeRestrictionOutputWithContext(context.Context) AlertPolicyTimeRestrictionOutput
}

AlertPolicyTimeRestrictionInput is an input type that accepts AlertPolicyTimeRestrictionArgs and AlertPolicyTimeRestrictionOutput values. You can construct a concrete instance of `AlertPolicyTimeRestrictionInput` via: 

AlertPolicyTimeRestrictionArgs{...}

type AlertPolicyTimeRestrictionOutput 

type AlertPolicyTimeRestrictionOutput struct{ *pulumi.OutputState }

func (AlertPolicyTimeRestrictionOutput) ElementType 

func (AlertPolicyTimeRestrictionOutput) ElementType() reflect.Type

func (AlertPolicyTimeRestrictionOutput) Restriction added in v1.1.7 

func (o AlertPolicyTimeRestrictionOutput) Restriction() AlertPolicyTimeRestrictionRestrictionArrayOutput

A definition of hourly definition applied daily, this has to be used with combination: type = `time-of-day`. This is a block, structure is documented below.

func (AlertPolicyTimeRestrictionOutput) RestrictionList added in v1.1.7 

func (o AlertPolicyTimeRestrictionOutput) RestrictionList() AlertPolicyTimeRestrictionRestrictionListArrayOutput

List of days and hours definitions for field type = `weekday-and-time-of-day`. This is a block, structure is documented below.

func (AlertPolicyTimeRestrictionOutput) ToAlertPolicyTimeRestrictionOutput 

func (o AlertPolicyTimeRestrictionOutput) ToAlertPolicyTimeRestrictionOutput() AlertPolicyTimeRestrictionOutput

func (AlertPolicyTimeRestrictionOutput) ToAlertPolicyTimeRestrictionOutputWithContext 

func (o AlertPolicyTimeRestrictionOutput) ToAlertPolicyTimeRestrictionOutputWithContext(ctx context.Context) AlertPolicyTimeRestrictionOutput

func (AlertPolicyTimeRestrictionOutput) Type 

func (o AlertPolicyTimeRestrictionOutput) Type() pulumi.StringOutput

Defines if restriction should apply daily on given hours or on certain days and hours. Possible values are: `time-of-day`, `weekday-and-time-of-day`

type AlertPolicyTimeRestrictionRestriction 

type AlertPolicyTimeRestrictionRestriction struct {
	// Ending hour of restriction.
	EndHour int `pulumi:"endHour"`
	// Ending minute of restriction on defined `endHour`
	EndMin int `pulumi:"endMin"`
	// Starting hour of restriction.
	StartHour int `pulumi:"startHour"`
	// Staring minute of restriction on defined `startHour`
	StartMin int `pulumi:"startMin"`
}

type AlertPolicyTimeRestrictionRestrictionArgs 

type AlertPolicyTimeRestrictionRestrictionArgs struct {
	// Ending hour of restriction.
	EndHour pulumi.IntInput `pulumi:"endHour"`
	// Ending minute of restriction on defined `endHour`
	EndMin pulumi.IntInput `pulumi:"endMin"`
	// Starting hour of restriction.
	StartHour pulumi.IntInput `pulumi:"startHour"`
	// Staring minute of restriction on defined `startHour`
	StartMin pulumi.IntInput `pulumi:"startMin"`
}

func (AlertPolicyTimeRestrictionRestrictionArgs) ElementType 

func (AlertPolicyTimeRestrictionRestrictionArgs) ElementType() reflect.Type

func (AlertPolicyTimeRestrictionRestrictionArgs) ToAlertPolicyTimeRestrictionRestrictionOutput 

func (i AlertPolicyTimeRestrictionRestrictionArgs) ToAlertPolicyTimeRestrictionRestrictionOutput() AlertPolicyTimeRestrictionRestrictionOutput

func (AlertPolicyTimeRestrictionRestrictionArgs) ToAlertPolicyTimeRestrictionRestrictionOutputWithContext 

func (i AlertPolicyTimeRestrictionRestrictionArgs) ToAlertPolicyTimeRestrictionRestrictionOutputWithContext(ctx context.Context) AlertPolicyTimeRestrictionRestrictionOutput

type AlertPolicyTimeRestrictionRestrictionArray 

type AlertPolicyTimeRestrictionRestrictionArray []AlertPolicyTimeRestrictionRestrictionInput

func (AlertPolicyTimeRestrictionRestrictionArray) ElementType 

func (AlertPolicyTimeRestrictionRestrictionArray) ElementType() reflect.Type

func (AlertPolicyTimeRestrictionRestrictionArray) ToAlertPolicyTimeRestrictionRestrictionArrayOutput 

func (i AlertPolicyTimeRestrictionRestrictionArray) ToAlertPolicyTimeRestrictionRestrictionArrayOutput() AlertPolicyTimeRestrictionRestrictionArrayOutput

func (AlertPolicyTimeRestrictionRestrictionArray) ToAlertPolicyTimeRestrictionRestrictionArrayOutputWithContext 

func (i AlertPolicyTimeRestrictionRestrictionArray) ToAlertPolicyTimeRestrictionRestrictionArrayOutputWithContext(ctx context.Context) AlertPolicyTimeRestrictionRestrictionArrayOutput

type AlertPolicyTimeRestrictionRestrictionArrayInput 

type AlertPolicyTimeRestrictionRestrictionArrayInput interface {
	pulumi.Input

	ToAlertPolicyTimeRestrictionRestrictionArrayOutput() AlertPolicyTimeRestrictionRestrictionArrayOutput
	ToAlertPolicyTimeRestrictionRestrictionArrayOutputWithContext(context.Context) AlertPolicyTimeRestrictionRestrictionArrayOutput
}

AlertPolicyTimeRestrictionRestrictionArrayInput is an input type that accepts AlertPolicyTimeRestrictionRestrictionArray and AlertPolicyTimeRestrictionRestrictionArrayOutput values. You can construct a concrete instance of `AlertPolicyTimeRestrictionRestrictionArrayInput` via: 

AlertPolicyTimeRestrictionRestrictionArray{ AlertPolicyTimeRestrictionRestrictionArgs{...} }

type AlertPolicyTimeRestrictionRestrictionArrayOutput 

type AlertPolicyTimeRestrictionRestrictionArrayOutput struct{ *pulumi.OutputState }

func (AlertPolicyTimeRestrictionRestrictionArrayOutput) ElementType 

func (AlertPolicyTimeRestrictionRestrictionArrayOutput) ElementType() reflect.Type

func (AlertPolicyTimeRestrictionRestrictionArrayOutput) Index 

func (o AlertPolicyTimeRestrictionRestrictionArrayOutput) Index(i pulumi.IntInput) AlertPolicyTimeRestrictionRestrictionOutput

func (AlertPolicyTimeRestrictionRestrictionArrayOutput) ToAlertPolicyTimeRestrictionRestrictionArrayOutput 

func (o AlertPolicyTimeRestrictionRestrictionArrayOutput) ToAlertPolicyTimeRestrictionRestrictionArrayOutput() AlertPolicyTimeRestrictionRestrictionArrayOutput

func (AlertPolicyTimeRestrictionRestrictionArrayOutput) ToAlertPolicyTimeRestrictionRestrictionArrayOutputWithContext 

func (o AlertPolicyTimeRestrictionRestrictionArrayOutput) ToAlertPolicyTimeRestrictionRestrictionArrayOutputWithContext(ctx context.Context) AlertPolicyTimeRestrictionRestrictionArrayOutput

type AlertPolicyTimeRestrictionRestrictionInput 

type AlertPolicyTimeRestrictionRestrictionInput interface {
	pulumi.Input

	ToAlertPolicyTimeRestrictionRestrictionOutput() AlertPolicyTimeRestrictionRestrictionOutput
	ToAlertPolicyTimeRestrictionRestrictionOutputWithContext(context.Context) AlertPolicyTimeRestrictionRestrictionOutput
}

AlertPolicyTimeRestrictionRestrictionInput is an input type that accepts AlertPolicyTimeRestrictionRestrictionArgs and AlertPolicyTimeRestrictionRestrictionOutput values. You can construct a concrete instance of `AlertPolicyTimeRestrictionRestrictionInput` via: 

AlertPolicyTimeRestrictionRestrictionArgs{...}

type AlertPolicyTimeRestrictionRestrictionList added in v1.1.7 

type AlertPolicyTimeRestrictionRestrictionList struct {
	// Ending day of restriction (eg. `wednesday`)
	EndDay string `pulumi:"endDay"`
	// Ending hour of restriction on defined `endDay`
	EndHour int `pulumi:"endHour"`
	// Ending minute of restriction on defined `endHour`
	EndMin int `pulumi:"endMin"`
	// Starting day of restriction (eg. `monday`)
	StartDay string `pulumi:"startDay"`
	// Starting hour of restriction on defined `startDay`
	StartHour int `pulumi:"startHour"`
	// Staring minute of restriction on defined `startHour`
	StartMin int `pulumi:"startMin"`
}

type AlertPolicyTimeRestrictionRestrictionListArgs added in v1.1.7 

type AlertPolicyTimeRestrictionRestrictionListArgs struct {
	// Ending day of restriction (eg. `wednesday`)
	EndDay pulumi.StringInput `pulumi:"endDay"`
	// Ending hour of restriction on defined `endDay`
	EndHour pulumi.IntInput `pulumi:"endHour"`
	// Ending minute of restriction on defined `endHour`
	EndMin pulumi.IntInput `pulumi:"endMin"`
	// Starting day of restriction (eg. `monday`)
	StartDay pulumi.StringInput `pulumi:"startDay"`
	// Starting hour of restriction on defined `startDay`
	StartHour pulumi.IntInput `pulumi:"startHour"`
	// Staring minute of restriction on defined `startHour`
	StartMin pulumi.IntInput `pulumi:"startMin"`
}

func (AlertPolicyTimeRestrictionRestrictionListArgs) ElementType added in v1.1.7 

func (AlertPolicyTimeRestrictionRestrictionListArgs) ElementType() reflect.Type

func (AlertPolicyTimeRestrictionRestrictionListArgs) ToAlertPolicyTimeRestrictionRestrictionListOutput added in v1.1.7 

func (i AlertPolicyTimeRestrictionRestrictionListArgs) ToAlertPolicyTimeRestrictionRestrictionListOutput() AlertPolicyTimeRestrictionRestrictionListOutput

func (AlertPolicyTimeRestrictionRestrictionListArgs) ToAlertPolicyTimeRestrictionRestrictionListOutputWithContext added in v1.1.7 

func (i AlertPolicyTimeRestrictionRestrictionListArgs) ToAlertPolicyTimeRestrictionRestrictionListOutputWithContext(ctx context.Context) AlertPolicyTimeRestrictionRestrictionListOutput

type AlertPolicyTimeRestrictionRestrictionListArray added in v1.1.7 

type AlertPolicyTimeRestrictionRestrictionListArray []AlertPolicyTimeRestrictionRestrictionListInput

func (AlertPolicyTimeRestrictionRestrictionListArray) ElementType added in v1.1.7 

func (AlertPolicyTimeRestrictionRestrictionListArray) ElementType() reflect.Type

func (AlertPolicyTimeRestrictionRestrictionListArray) ToAlertPolicyTimeRestrictionRestrictionListArrayOutput added in v1.1.7 

func (i AlertPolicyTimeRestrictionRestrictionListArray) ToAlertPolicyTimeRestrictionRestrictionListArrayOutput() AlertPolicyTimeRestrictionRestrictionListArrayOutput

func (AlertPolicyTimeRestrictionRestrictionListArray) ToAlertPolicyTimeRestrictionRestrictionListArrayOutputWithContext added in v1.1.7 

func (i AlertPolicyTimeRestrictionRestrictionListArray) ToAlertPolicyTimeRestrictionRestrictionListArrayOutputWithContext(ctx context.Context) AlertPolicyTimeRestrictionRestrictionListArrayOutput

type AlertPolicyTimeRestrictionRestrictionListArrayInput added in v1.1.7 

type AlertPolicyTimeRestrictionRestrictionListArrayInput interface {
	pulumi.Input

	ToAlertPolicyTimeRestrictionRestrictionListArrayOutput() AlertPolicyTimeRestrictionRestrictionListArrayOutput
	ToAlertPolicyTimeRestrictionRestrictionListArrayOutputWithContext(context.Context) AlertPolicyTimeRestrictionRestrictionListArrayOutput
}

AlertPolicyTimeRestrictionRestrictionListArrayInput is an input type that accepts AlertPolicyTimeRestrictionRestrictionListArray and AlertPolicyTimeRestrictionRestrictionListArrayOutput values. You can construct a concrete instance of `AlertPolicyTimeRestrictionRestrictionListArrayInput` via: 

AlertPolicyTimeRestrictionRestrictionListArray{ AlertPolicyTimeRestrictionRestrictionListArgs{...} }

type AlertPolicyTimeRestrictionRestrictionListArrayOutput added in v1.1.7 

type AlertPolicyTimeRestrictionRestrictionListArrayOutput struct{ *pulumi.OutputState }

func (AlertPolicyTimeRestrictionRestrictionListArrayOutput) ElementType added in v1.1.7 

func (AlertPolicyTimeRestrictionRestrictionListArrayOutput) ElementType() reflect.Type

func (AlertPolicyTimeRestrictionRestrictionListArrayOutput) Index added in v1.1.7 

func (o AlertPolicyTimeRestrictionRestrictionListArrayOutput) Index(i pulumi.IntInput) AlertPolicyTimeRestrictionRestrictionListOutput

func (AlertPolicyTimeRestrictionRestrictionListArrayOutput) ToAlertPolicyTimeRestrictionRestrictionListArrayOutput added in v1.1.7 

func (o AlertPolicyTimeRestrictionRestrictionListArrayOutput) ToAlertPolicyTimeRestrictionRestrictionListArrayOutput() AlertPolicyTimeRestrictionRestrictionListArrayOutput

func (AlertPolicyTimeRestrictionRestrictionListArrayOutput) ToAlertPolicyTimeRestrictionRestrictionListArrayOutputWithContext added in v1.1.7 

func (o AlertPolicyTimeRestrictionRestrictionListArrayOutput) ToAlertPolicyTimeRestrictionRestrictionListArrayOutputWithContext(ctx context.Context) AlertPolicyTimeRestrictionRestrictionListArrayOutput

type AlertPolicyTimeRestrictionRestrictionListInput added in v1.1.7 

type AlertPolicyTimeRestrictionRestrictionListInput interface {
	pulumi.Input

	ToAlertPolicyTimeRestrictionRestrictionListOutput() AlertPolicyTimeRestrictionRestrictionListOutput
	ToAlertPolicyTimeRestrictionRestrictionListOutputWithContext(context.Context) AlertPolicyTimeRestrictionRestrictionListOutput
}

AlertPolicyTimeRestrictionRestrictionListInput is an input type that accepts AlertPolicyTimeRestrictionRestrictionListArgs and AlertPolicyTimeRestrictionRestrictionListOutput values. You can construct a concrete instance of `AlertPolicyTimeRestrictionRestrictionListInput` via: 

AlertPolicyTimeRestrictionRestrictionListArgs{...}

type AlertPolicyTimeRestrictionRestrictionListOutput added in v1.1.7 

type AlertPolicyTimeRestrictionRestrictionListOutput struct{ *pulumi.OutputState }

func (AlertPolicyTimeRestrictionRestrictionListOutput) ElementType added in v1.1.7 

func (AlertPolicyTimeRestrictionRestrictionListOutput) ElementType() reflect.Type

func (AlertPolicyTimeRestrictionRestrictionListOutput) EndDay added in v1.1.7 

func (o AlertPolicyTimeRestrictionRestrictionListOutput) EndDay() pulumi.StringOutput

Ending day of restriction (eg. `wednesday`)

func (AlertPolicyTimeRestrictionRestrictionListOutput) EndHour added in v1.1.7 

func (o AlertPolicyTimeRestrictionRestrictionListOutput) EndHour() pulumi.IntOutput

Ending hour of restriction on defined `endDay`

func (AlertPolicyTimeRestrictionRestrictionListOutput) EndMin added in v1.1.7 

func (o AlertPolicyTimeRestrictionRestrictionListOutput) EndMin() pulumi.IntOutput

Ending minute of restriction on defined `endHour`

func (AlertPolicyTimeRestrictionRestrictionListOutput) StartDay added in v1.1.7 

func (o AlertPolicyTimeRestrictionRestrictionListOutput) StartDay() pulumi.StringOutput

Starting day of restriction (eg. `monday`)

func (AlertPolicyTimeRestrictionRestrictionListOutput) StartHour added in v1.1.7 

func (o AlertPolicyTimeRestrictionRestrictionListOutput) StartHour() pulumi.IntOutput

Starting hour of restriction on defined `startDay`

func (AlertPolicyTimeRestrictionRestrictionListOutput) StartMin added in v1.1.7 

func (o AlertPolicyTimeRestrictionRestrictionListOutput) StartMin() pulumi.IntOutput

Staring minute of restriction on defined `startHour`

func (AlertPolicyTimeRestrictionRestrictionListOutput) ToAlertPolicyTimeRestrictionRestrictionListOutput added in v1.1.7 

func (o AlertPolicyTimeRestrictionRestrictionListOutput) ToAlertPolicyTimeRestrictionRestrictionListOutput() AlertPolicyTimeRestrictionRestrictionListOutput

func (AlertPolicyTimeRestrictionRestrictionListOutput) ToAlertPolicyTimeRestrictionRestrictionListOutputWithContext added in v1.1.7 

func (o AlertPolicyTimeRestrictionRestrictionListOutput) ToAlertPolicyTimeRestrictionRestrictionListOutputWithContext(ctx context.Context) AlertPolicyTimeRestrictionRestrictionListOutput

type AlertPolicyTimeRestrictionRestrictionOutput 

type AlertPolicyTimeRestrictionRestrictionOutput struct{ *pulumi.OutputState }

func (AlertPolicyTimeRestrictionRestrictionOutput) ElementType 

func (AlertPolicyTimeRestrictionRestrictionOutput) ElementType() reflect.Type

func (AlertPolicyTimeRestrictionRestrictionOutput) EndHour 

func (o AlertPolicyTimeRestrictionRestrictionOutput) EndHour() pulumi.IntOutput

Ending hour of restriction.

func (AlertPolicyTimeRestrictionRestrictionOutput) EndMin 

func (o AlertPolicyTimeRestrictionRestrictionOutput) EndMin() pulumi.IntOutput

Ending minute of restriction on defined `endHour`

func (AlertPolicyTimeRestrictionRestrictionOutput) StartHour 

func (o AlertPolicyTimeRestrictionRestrictionOutput) StartHour() pulumi.IntOutput

Starting hour of restriction.

func (AlertPolicyTimeRestrictionRestrictionOutput) StartMin 

func (o AlertPolicyTimeRestrictionRestrictionOutput) StartMin() pulumi.IntOutput

Staring minute of restriction on defined `startHour`

func (AlertPolicyTimeRestrictionRestrictionOutput) ToAlertPolicyTimeRestrictionRestrictionOutput 

func (o AlertPolicyTimeRestrictionRestrictionOutput) ToAlertPolicyTimeRestrictionRestrictionOutput() AlertPolicyTimeRestrictionRestrictionOutput

func (AlertPolicyTimeRestrictionRestrictionOutput) ToAlertPolicyTimeRestrictionRestrictionOutputWithContext 

func (o AlertPolicyTimeRestrictionRestrictionOutput) ToAlertPolicyTimeRestrictionRestrictionOutputWithContext(ctx context.Context) AlertPolicyTimeRestrictionRestrictionOutput

type ApiIntegration 

type ApiIntegration struct {
	pulumi.CustomResourceState

	// This parameter is for configuring the write access of integration. If write access is restricted, the integration will not be authorized to write within any domain. Default: `true`.
	AllowWriteAccess pulumi.BoolPtrOutput `pulumi:"allowWriteAccess"`
	// (Computed) API key of the created integration
	ApiKey pulumi.StringOutput `pulumi:"apiKey"`
	// This parameter is for specifying whether the integration will be enabled or not. Default: `true`
	Enabled pulumi.BoolPtrOutput   `pulumi:"enabled"`
	Headers pulumi.StringMapOutput `pulumi:"headers"`
	// If enabled, the integration will ignore recipients sent in request payloads. Default: `false`.
	IgnoreRespondersFromPayload pulumi.BoolPtrOutput `pulumi:"ignoreRespondersFromPayload"`
	// Name of the integration. Name must be unique for each integration.
	Name pulumi.StringOutput `pulumi:"name"`
	// Owner team id of the integration. If changed, this will recreate a new API integration, which will probably have a different API key.
	OwnerTeamId pulumi.StringPtrOutput `pulumi:"ownerTeamId"`
	// User, schedule, teams or escalation names to calculate which users will receive the notifications of the alert.
	Responders ApiIntegrationResponderArrayOutput `pulumi:"responders"`
	// If enabled, notifications that come from alerts will be suppressed. Default: `false`.
	SuppressNotifications pulumi.BoolPtrOutput `pulumi:"suppressNotifications"`
	// Type of the integration (API, Marid, Prometheus, etc). The full list of options can be found [here](https://docs.opsgenie.com/docs/integration-types-to-use-with-api).
	Type pulumi.StringPtrOutput `pulumi:"type"`
	// It is required if type is `Webhook`. This is the url Opsgenie will be sending request to.
	WebhookUrl pulumi.StringPtrOutput `pulumi:"webhookUrl"`
}

Manages an API Integration within Opsgenie.

## Import

API Integrations can be imported using the `integration_id`, e.g.

```sh $ pulumi import opsgenie:index/apiIntegration:ApiIntegration this integration_id` ```

func GetApiIntegration 

func GetApiIntegration(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ApiIntegrationState, opts ...pulumi.ResourceOption) (*ApiIntegration, error)

GetApiIntegration gets an existing ApiIntegration resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewApiIntegration 

func NewApiIntegration(ctx *pulumi.Context,
	name string, args *ApiIntegrationArgs, opts ...pulumi.ResourceOption) (*ApiIntegration, error)

NewApiIntegration registers a new resource with the given unique name, arguments, and options.

func (*ApiIntegration) ElementType 

func (*ApiIntegration) ElementType() reflect.Type

func (*ApiIntegration) ToApiIntegrationOutput 

func (i *ApiIntegration) ToApiIntegrationOutput() ApiIntegrationOutput

func (*ApiIntegration) ToApiIntegrationOutputWithContext 

func (i *ApiIntegration) ToApiIntegrationOutputWithContext(ctx context.Context) ApiIntegrationOutput

type ApiIntegrationArgs 

type ApiIntegrationArgs struct {
	// This parameter is for configuring the write access of integration. If write access is restricted, the integration will not be authorized to write within any domain. Default: `true`.
	AllowWriteAccess pulumi.BoolPtrInput
	// This parameter is for specifying whether the integration will be enabled or not. Default: `true`
	Enabled pulumi.BoolPtrInput
	Headers pulumi.StringMapInput
	// If enabled, the integration will ignore recipients sent in request payloads. Default: `false`.
	IgnoreRespondersFromPayload pulumi.BoolPtrInput
	// Name of the integration. Name must be unique for each integration.
	Name pulumi.StringPtrInput
	// Owner team id of the integration. If changed, this will recreate a new API integration, which will probably have a different API key.
	OwnerTeamId pulumi.StringPtrInput
	// User, schedule, teams or escalation names to calculate which users will receive the notifications of the alert.
	Responders ApiIntegrationResponderArrayInput
	// If enabled, notifications that come from alerts will be suppressed. Default: `false`.
	SuppressNotifications pulumi.BoolPtrInput
	// Type of the integration (API, Marid, Prometheus, etc). The full list of options can be found [here](https://docs.opsgenie.com/docs/integration-types-to-use-with-api).
	Type pulumi.StringPtrInput
	// It is required if type is `Webhook`. This is the url Opsgenie will be sending request to.
	WebhookUrl pulumi.StringPtrInput
}

The set of arguments for constructing a ApiIntegration resource.

func (ApiIntegrationArgs) ElementType 

func (ApiIntegrationArgs) ElementType() reflect.Type

type ApiIntegrationArray added in v0.1.3 

type ApiIntegrationArray []ApiIntegrationInput

func (ApiIntegrationArray) ElementType added in v0.1.3 

func (ApiIntegrationArray) ElementType() reflect.Type

func (ApiIntegrationArray) ToApiIntegrationArrayOutput added in v0.1.3 

func (i ApiIntegrationArray) ToApiIntegrationArrayOutput() ApiIntegrationArrayOutput

func (ApiIntegrationArray) ToApiIntegrationArrayOutputWithContext added in v0.1.3 

func (i ApiIntegrationArray) ToApiIntegrationArrayOutputWithContext(ctx context.Context) ApiIntegrationArrayOutput

type ApiIntegrationArrayInput added in v0.1.3 

type ApiIntegrationArrayInput interface {
	pulumi.Input

	ToApiIntegrationArrayOutput() ApiIntegrationArrayOutput
	ToApiIntegrationArrayOutputWithContext(context.Context) ApiIntegrationArrayOutput
}

ApiIntegrationArrayInput is an input type that accepts ApiIntegrationArray and ApiIntegrationArrayOutput values. You can construct a concrete instance of `ApiIntegrationArrayInput` via: 

ApiIntegrationArray{ ApiIntegrationArgs{...} }

type ApiIntegrationArrayOutput added in v0.1.3 

type ApiIntegrationArrayOutput struct{ *pulumi.OutputState }

func (ApiIntegrationArrayOutput) ElementType added in v0.1.3 

func (ApiIntegrationArrayOutput) ElementType() reflect.Type

func (ApiIntegrationArrayOutput) Index added in v0.1.3 

func (o ApiIntegrationArrayOutput) Index(i pulumi.IntInput) ApiIntegrationOutput

func (ApiIntegrationArrayOutput) ToApiIntegrationArrayOutput added in v0.1.3 

func (o ApiIntegrationArrayOutput) ToApiIntegrationArrayOutput() ApiIntegrationArrayOutput

func (ApiIntegrationArrayOutput) ToApiIntegrationArrayOutputWithContext added in v0.1.3 

func (o ApiIntegrationArrayOutput) ToApiIntegrationArrayOutputWithContext(ctx context.Context) ApiIntegrationArrayOutput

type ApiIntegrationInput 

type ApiIntegrationInput interface {
	pulumi.Input

	ToApiIntegrationOutput() ApiIntegrationOutput
	ToApiIntegrationOutputWithContext(ctx context.Context) ApiIntegrationOutput
}

type ApiIntegrationMap added in v0.1.3 

type ApiIntegrationMap map[string]ApiIntegrationInput

func (ApiIntegrationMap) ElementType added in v0.1.3 

func (ApiIntegrationMap) ElementType() reflect.Type

func (ApiIntegrationMap) ToApiIntegrationMapOutput added in v0.1.3 

func (i ApiIntegrationMap) ToApiIntegrationMapOutput() ApiIntegrationMapOutput

func (ApiIntegrationMap) ToApiIntegrationMapOutputWithContext added in v0.1.3 

func (i ApiIntegrationMap) ToApiIntegrationMapOutputWithContext(ctx context.Context) ApiIntegrationMapOutput

type ApiIntegrationMapInput added in v0.1.3 

type ApiIntegrationMapInput interface {
	pulumi.Input

	ToApiIntegrationMapOutput() ApiIntegrationMapOutput
	ToApiIntegrationMapOutputWithContext(context.Context) ApiIntegrationMapOutput
}

ApiIntegrationMapInput is an input type that accepts ApiIntegrationMap and ApiIntegrationMapOutput values. You can construct a concrete instance of `ApiIntegrationMapInput` via: 

ApiIntegrationMap{ "key": ApiIntegrationArgs{...} }

type ApiIntegrationMapOutput added in v0.1.3 

type ApiIntegrationMapOutput struct{ *pulumi.OutputState }

func (ApiIntegrationMapOutput) ElementType added in v0.1.3 

func (ApiIntegrationMapOutput) ElementType() reflect.Type

func (ApiIntegrationMapOutput) MapIndex added in v0.1.3 

func (o ApiIntegrationMapOutput) MapIndex(k pulumi.StringInput) ApiIntegrationOutput

func (ApiIntegrationMapOutput) ToApiIntegrationMapOutput added in v0.1.3 

func (o ApiIntegrationMapOutput) ToApiIntegrationMapOutput() ApiIntegrationMapOutput

func (ApiIntegrationMapOutput) ToApiIntegrationMapOutputWithContext added in v0.1.3 

func (o ApiIntegrationMapOutput) ToApiIntegrationMapOutputWithContext(ctx context.Context) ApiIntegrationMapOutput

type ApiIntegrationOutput 

type ApiIntegrationOutput struct{ *pulumi.OutputState }

func (ApiIntegrationOutput) AllowWriteAccess added in v1.1.9 

func (o ApiIntegrationOutput) AllowWriteAccess() pulumi.BoolPtrOutput

This parameter is for configuring the write access of integration. If write access is restricted, the integration will not be authorized to write within any domain. Default: `true`.

func (ApiIntegrationOutput) ApiKey added in v1.1.9 

func (o ApiIntegrationOutput) ApiKey() pulumi.StringOutput

(Computed) API key of the created integration

func (ApiIntegrationOutput) ElementType 

func (ApiIntegrationOutput) ElementType() reflect.Type

func (ApiIntegrationOutput) Enabled added in v1.1.9 

func (o ApiIntegrationOutput) Enabled() pulumi.BoolPtrOutput

This parameter is for specifying whether the integration will be enabled or not. Default: `true`

func (ApiIntegrationOutput) Headers added in v1.1.9 

func (o ApiIntegrationOutput) Headers() pulumi.StringMapOutput

func (ApiIntegrationOutput) IgnoreRespondersFromPayload added in v1.1.9 

func (o ApiIntegrationOutput) IgnoreRespondersFromPayload() pulumi.BoolPtrOutput

If enabled, the integration will ignore recipients sent in request payloads. Default: `false`.

func (ApiIntegrationOutput) Name added in v1.1.9 

func (o ApiIntegrationOutput) Name() pulumi.StringOutput

Name of the integration. Name must be unique for each integration.

func (ApiIntegrationOutput) OwnerTeamId added in v1.1.9 

func (o ApiIntegrationOutput) OwnerTeamId() pulumi.StringPtrOutput

Owner team id of the integration. If changed, this will recreate a new API integration, which will probably have a different API key.

func (ApiIntegrationOutput) Responders added in v1.1.9 

func (o ApiIntegrationOutput) Responders() ApiIntegrationResponderArrayOutput

User, schedule, teams or escalation names to calculate which users will receive the notifications of the alert.

func (ApiIntegrationOutput) SuppressNotifications added in v1.1.9 

func (o ApiIntegrationOutput) SuppressNotifications() pulumi.BoolPtrOutput

If enabled, notifications that come from alerts will be suppressed. Default: `false`.

func (ApiIntegrationOutput) ToApiIntegrationOutput 

func (o ApiIntegrationOutput) ToApiIntegrationOutput() ApiIntegrationOutput

func (ApiIntegrationOutput) ToApiIntegrationOutputWithContext 

func (o ApiIntegrationOutput) ToApiIntegrationOutputWithContext(ctx context.Context) ApiIntegrationOutput

func (ApiIntegrationOutput) Type added in v1.1.9 

func (o ApiIntegrationOutput) Type() pulumi.StringPtrOutput

Type of the integration (API, Marid, Prometheus, etc). The full list of options can be found [here](https://docs.opsgenie.com/docs/integration-types-to-use-with-api).

func (ApiIntegrationOutput) WebhookUrl added in v1.1.9 

func (o ApiIntegrationOutput) WebhookUrl() pulumi.StringPtrOutput

It is required if type is `Webhook`. This is the url Opsgenie will be sending request to.

type ApiIntegrationResponder 

type ApiIntegrationResponder struct {
	// The id of the responder.
	Id *string `pulumi:"id"`
	// The responder type.
	Type *string `pulumi:"type"`
}

type ApiIntegrationResponderArgs 

type ApiIntegrationResponderArgs struct {
	// The id of the responder.
	Id pulumi.StringPtrInput `pulumi:"id"`
	// The responder type.
	Type pulumi.StringPtrInput `pulumi:"type"`
}

func (ApiIntegrationResponderArgs) ElementType 

func (ApiIntegrationResponderArgs) ElementType() reflect.Type

func (ApiIntegrationResponderArgs) ToApiIntegrationResponderOutput 

func (i ApiIntegrationResponderArgs) ToApiIntegrationResponderOutput() ApiIntegrationResponderOutput

func (ApiIntegrationResponderArgs) ToApiIntegrationResponderOutputWithContext 

func (i ApiIntegrationResponderArgs) ToApiIntegrationResponderOutputWithContext(ctx context.Context) ApiIntegrationResponderOutput

type ApiIntegrationResponderArray 

type ApiIntegrationResponderArray []ApiIntegrationResponderInput

func (ApiIntegrationResponderArray) ElementType 

func (ApiIntegrationResponderArray) ElementType() reflect.Type

func (ApiIntegrationResponderArray) ToApiIntegrationResponderArrayOutput 

func (i ApiIntegrationResponderArray) ToApiIntegrationResponderArrayOutput() ApiIntegrationResponderArrayOutput

func (ApiIntegrationResponderArray) ToApiIntegrationResponderArrayOutputWithContext 

func (i ApiIntegrationResponderArray) ToApiIntegrationResponderArrayOutputWithContext(ctx context.Context) ApiIntegrationResponderArrayOutput

type ApiIntegrationResponderArrayInput 

type ApiIntegrationResponderArrayInput interface {
	pulumi.Input

	ToApiIntegrationResponderArrayOutput() ApiIntegrationResponderArrayOutput
	ToApiIntegrationResponderArrayOutputWithContext(context.Context) ApiIntegrationResponderArrayOutput
}

ApiIntegrationResponderArrayInput is an input type that accepts ApiIntegrationResponderArray and ApiIntegrationResponderArrayOutput values. You can construct a concrete instance of `ApiIntegrationResponderArrayInput` via: 

ApiIntegrationResponderArray{ ApiIntegrationResponderArgs{...} }

type ApiIntegrationResponderArrayOutput 

type ApiIntegrationResponderArrayOutput struct{ *pulumi.OutputState }

func (ApiIntegrationResponderArrayOutput) ElementType 

func (ApiIntegrationResponderArrayOutput) ElementType() reflect.Type

func (ApiIntegrationResponderArrayOutput) Index 

func (o ApiIntegrationResponderArrayOutput) Index(i pulumi.IntInput) ApiIntegrationResponderOutput

func (ApiIntegrationResponderArrayOutput) ToApiIntegrationResponderArrayOutput 

func (o ApiIntegrationResponderArrayOutput) ToApiIntegrationResponderArrayOutput() ApiIntegrationResponderArrayOutput

func (ApiIntegrationResponderArrayOutput) ToApiIntegrationResponderArrayOutputWithContext 

func (o ApiIntegrationResponderArrayOutput) ToApiIntegrationResponderArrayOutputWithContext(ctx context.Context) ApiIntegrationResponderArrayOutput

type ApiIntegrationResponderInput 

type ApiIntegrationResponderInput interface {
	pulumi.Input

	ToApiIntegrationResponderOutput() ApiIntegrationResponderOutput
	ToApiIntegrationResponderOutputWithContext(context.Context) ApiIntegrationResponderOutput
}

ApiIntegrationResponderInput is an input type that accepts ApiIntegrationResponderArgs and ApiIntegrationResponderOutput values. You can construct a concrete instance of `ApiIntegrationResponderInput` via: 

ApiIntegrationResponderArgs{...}

type ApiIntegrationResponderOutput 

type ApiIntegrationResponderOutput struct{ *pulumi.OutputState }

func (ApiIntegrationResponderOutput) ElementType 

func (ApiIntegrationResponderOutput) ElementType() reflect.Type

func (ApiIntegrationResponderOutput) Id 

func (o ApiIntegrationResponderOutput) Id() pulumi.StringPtrOutput

The id of the responder.

func (ApiIntegrationResponderOutput) ToApiIntegrationResponderOutput 

func (o ApiIntegrationResponderOutput) ToApiIntegrationResponderOutput() ApiIntegrationResponderOutput

func (ApiIntegrationResponderOutput) ToApiIntegrationResponderOutputWithContext 

func (o ApiIntegrationResponderOutput) ToApiIntegrationResponderOutputWithContext(ctx context.Context) ApiIntegrationResponderOutput

func (ApiIntegrationResponderOutput) Type 

func (o ApiIntegrationResponderOutput) Type() pulumi.StringPtrOutput

The responder type.

type ApiIntegrationState 

type ApiIntegrationState struct {
	// This parameter is for configuring the write access of integration. If write access is restricted, the integration will not be authorized to write within any domain. Default: `true`.
	AllowWriteAccess pulumi.BoolPtrInput
	// (Computed) API key of the created integration
	ApiKey pulumi.StringPtrInput
	// This parameter is for specifying whether the integration will be enabled or not. Default: `true`
	Enabled pulumi.BoolPtrInput
	Headers pulumi.StringMapInput
	// If enabled, the integration will ignore recipients sent in request payloads. Default: `false`.
	IgnoreRespondersFromPayload pulumi.BoolPtrInput
	// Name of the integration. Name must be unique for each integration.
	Name pulumi.StringPtrInput
	// Owner team id of the integration. If changed, this will recreate a new API integration, which will probably have a different API key.
	OwnerTeamId pulumi.StringPtrInput
	// User, schedule, teams or escalation names to calculate which users will receive the notifications of the alert.
	Responders ApiIntegrationResponderArrayInput
	// If enabled, notifications that come from alerts will be suppressed. Default: `false`.
	SuppressNotifications pulumi.BoolPtrInput
	// Type of the integration (API, Marid, Prometheus, etc). The full list of options can be found [here](https://docs.opsgenie.com/docs/integration-types-to-use-with-api).
	Type pulumi.StringPtrInput
	// It is required if type is `Webhook`. This is the url Opsgenie will be sending request to.
	WebhookUrl pulumi.StringPtrInput
}

func (ApiIntegrationState) ElementType 

func (ApiIntegrationState) ElementType() reflect.Type

type CustomRole 

type CustomRole struct {
	pulumi.CustomResourceState

	// The rights this role cannot have. For allowed values please refer [User Right Prerequisites](https://docs.opsgenie.com/docs/custom-user-role-api#section-user-right-prerequisites)
	DisallowedRights pulumi.StringArrayOutput `pulumi:"disallowedRights"`
	// The role from which this role has been derived. Allowed Values: "user", "observer", "stakeholder".
	ExtendedRole pulumi.StringPtrOutput `pulumi:"extendedRole"`
	// The rights granted to this role. For allowed values please refer [User Right Prerequisites](https://docs.opsgenie.com/docs/custom-user-role-api#section-user-right-prerequisites)
	GrantedRights pulumi.StringArrayOutput `pulumi:"grantedRights"`
	// Name of the custom role.
	RoleName pulumi.StringOutput `pulumi:"roleName"`
}

Manages custom user roles within Opsgenie.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opsgenie.NewCustomRole(ctx, "test", &opsgenie.CustomRoleArgs{
			RoleName:     pulumi.String("genierole"),
			ExtendedRole: pulumi.String("user"),
			GrantedRights: pulumi.StringArray{
				pulumi.String("alert-delete"),
			},
			DisallowedRights: pulumi.StringArray{
				pulumi.String("profile-edit"),
				pulumi.String("contacts-edit"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetCustomRole 

func GetCustomRole(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *CustomRoleState, opts ...pulumi.ResourceOption) (*CustomRole, error)

GetCustomRole gets an existing CustomRole resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewCustomRole 

func NewCustomRole(ctx *pulumi.Context,
	name string, args *CustomRoleArgs, opts ...pulumi.ResourceOption) (*CustomRole, error)

NewCustomRole registers a new resource with the given unique name, arguments, and options.

func (*CustomRole) ElementType 

func (*CustomRole) ElementType() reflect.Type

func (*CustomRole) ToCustomRoleOutput 

func (i *CustomRole) ToCustomRoleOutput() CustomRoleOutput

func (*CustomRole) ToCustomRoleOutputWithContext 

func (i *CustomRole) ToCustomRoleOutputWithContext(ctx context.Context) CustomRoleOutput

type CustomRoleArgs 

type CustomRoleArgs struct {
	// The rights this role cannot have. For allowed values please refer [User Right Prerequisites](https://docs.opsgenie.com/docs/custom-user-role-api#section-user-right-prerequisites)
	DisallowedRights pulumi.StringArrayInput
	// The role from which this role has been derived. Allowed Values: "user", "observer", "stakeholder".
	ExtendedRole pulumi.StringPtrInput
	// The rights granted to this role. For allowed values please refer [User Right Prerequisites](https://docs.opsgenie.com/docs/custom-user-role-api#section-user-right-prerequisites)
	GrantedRights pulumi.StringArrayInput
	// Name of the custom role.
	RoleName pulumi.StringInput
}

The set of arguments for constructing a CustomRole resource.

func (CustomRoleArgs) ElementType 

func (CustomRoleArgs) ElementType() reflect.Type

type CustomRoleArray added in v0.1.3 

type CustomRoleArray []CustomRoleInput

func (CustomRoleArray) ElementType added in v0.1.3 

func (CustomRoleArray) ElementType() reflect.Type

func (CustomRoleArray) ToCustomRoleArrayOutput added in v0.1.3 

func (i CustomRoleArray) ToCustomRoleArrayOutput() CustomRoleArrayOutput

func (CustomRoleArray) ToCustomRoleArrayOutputWithContext added in v0.1.3 

func (i CustomRoleArray) ToCustomRoleArrayOutputWithContext(ctx context.Context) CustomRoleArrayOutput

type CustomRoleArrayInput added in v0.1.3 

type CustomRoleArrayInput interface {
	pulumi.Input

	ToCustomRoleArrayOutput() CustomRoleArrayOutput
	ToCustomRoleArrayOutputWithContext(context.Context) CustomRoleArrayOutput
}

CustomRoleArrayInput is an input type that accepts CustomRoleArray and CustomRoleArrayOutput values. You can construct a concrete instance of `CustomRoleArrayInput` via: 

CustomRoleArray{ CustomRoleArgs{...} }

type CustomRoleArrayOutput added in v0.1.3 

type CustomRoleArrayOutput struct{ *pulumi.OutputState }

func (CustomRoleArrayOutput) ElementType added in v0.1.3 

func (CustomRoleArrayOutput) ElementType() reflect.Type

func (CustomRoleArrayOutput) Index added in v0.1.3 

func (o CustomRoleArrayOutput) Index(i pulumi.IntInput) CustomRoleOutput

func (CustomRoleArrayOutput) ToCustomRoleArrayOutput added in v0.1.3 

func (o CustomRoleArrayOutput) ToCustomRoleArrayOutput() CustomRoleArrayOutput

func (CustomRoleArrayOutput) ToCustomRoleArrayOutputWithContext added in v0.1.3 

func (o CustomRoleArrayOutput) ToCustomRoleArrayOutputWithContext(ctx context.Context) CustomRoleArrayOutput

type CustomRoleInput 

type CustomRoleInput interface {
	pulumi.Input

	ToCustomRoleOutput() CustomRoleOutput
	ToCustomRoleOutputWithContext(ctx context.Context) CustomRoleOutput
}

type CustomRoleMap added in v0.1.3 

type CustomRoleMap map[string]CustomRoleInput

func (CustomRoleMap) ElementType added in v0.1.3 

func (CustomRoleMap) ElementType() reflect.Type

func (CustomRoleMap) ToCustomRoleMapOutput added in v0.1.3 

func (i CustomRoleMap) ToCustomRoleMapOutput() CustomRoleMapOutput

func (CustomRoleMap) ToCustomRoleMapOutputWithContext added in v0.1.3 

func (i CustomRoleMap) ToCustomRoleMapOutputWithContext(ctx context.Context) CustomRoleMapOutput

type CustomRoleMapInput added in v0.1.3 

type CustomRoleMapInput interface {
	pulumi.Input

	ToCustomRoleMapOutput() CustomRoleMapOutput
	ToCustomRoleMapOutputWithContext(context.Context) CustomRoleMapOutput
}

CustomRoleMapInput is an input type that accepts CustomRoleMap and CustomRoleMapOutput values. You can construct a concrete instance of `CustomRoleMapInput` via: 

CustomRoleMap{ "key": CustomRoleArgs{...} }

type CustomRoleMapOutput added in v0.1.3 

type CustomRoleMapOutput struct{ *pulumi.OutputState }

func (CustomRoleMapOutput) ElementType added in v0.1.3 

func (CustomRoleMapOutput) ElementType() reflect.Type

func (CustomRoleMapOutput) MapIndex added in v0.1.3 

func (o CustomRoleMapOutput) MapIndex(k pulumi.StringInput) CustomRoleOutput

func (CustomRoleMapOutput) ToCustomRoleMapOutput added in v0.1.3 

func (o CustomRoleMapOutput) ToCustomRoleMapOutput() CustomRoleMapOutput

func (CustomRoleMapOutput) ToCustomRoleMapOutputWithContext added in v0.1.3 

func (o CustomRoleMapOutput) ToCustomRoleMapOutputWithContext(ctx context.Context) CustomRoleMapOutput

type CustomRoleOutput 

type CustomRoleOutput struct{ *pulumi.OutputState }

func (CustomRoleOutput) DisallowedRights added in v1.1.9 

func (o CustomRoleOutput) DisallowedRights() pulumi.StringArrayOutput

The rights this role cannot have. For allowed values please refer [User Right Prerequisites](https://docs.opsgenie.com/docs/custom-user-role-api#section-user-right-prerequisites)

func (CustomRoleOutput) ElementType 

func (CustomRoleOutput) ElementType() reflect.Type

func (CustomRoleOutput) ExtendedRole added in v1.1.9 

func (o CustomRoleOutput) ExtendedRole() pulumi.StringPtrOutput

The role from which this role has been derived. Allowed Values: "user", "observer", "stakeholder".

func (CustomRoleOutput) GrantedRights added in v1.1.9 

func (o CustomRoleOutput) GrantedRights() pulumi.StringArrayOutput

The rights granted to this role. For allowed values please refer [User Right Prerequisites](https://docs.opsgenie.com/docs/custom-user-role-api#section-user-right-prerequisites)

func (CustomRoleOutput) RoleName added in v1.1.9 

func (o CustomRoleOutput) RoleName() pulumi.StringOutput

Name of the custom role.

func (CustomRoleOutput) ToCustomRoleOutput 

func (o CustomRoleOutput) ToCustomRoleOutput() CustomRoleOutput

func (CustomRoleOutput) ToCustomRoleOutputWithContext 

func (o CustomRoleOutput) ToCustomRoleOutputWithContext(ctx context.Context) CustomRoleOutput

type CustomRoleState 

type CustomRoleState struct {
	// The rights this role cannot have. For allowed values please refer [User Right Prerequisites](https://docs.opsgenie.com/docs/custom-user-role-api#section-user-right-prerequisites)
	DisallowedRights pulumi.StringArrayInput
	// The role from which this role has been derived. Allowed Values: "user", "observer", "stakeholder".
	ExtendedRole pulumi.StringPtrInput
	// The rights granted to this role. For allowed values please refer [User Right Prerequisites](https://docs.opsgenie.com/docs/custom-user-role-api#section-user-right-prerequisites)
	GrantedRights pulumi.StringArrayInput
	// Name of the custom role.
	RoleName pulumi.StringPtrInput
}

func (CustomRoleState) ElementType 

func (CustomRoleState) ElementType() reflect.Type

type EmailIntegration 

type EmailIntegration struct {
	pulumi.CustomResourceState

	// The username part of the email address. It must be unique for each integration.
	EmailUsername pulumi.StringOutput `pulumi:"emailUsername"`
	// A Member block as documented below.
	Enabled pulumi.BoolPtrOutput `pulumi:"enabled"`
	// If enabled, the integration will ignore recipients sent in request payloads. Default: `false`.
	IgnoreRespondersFromPayload pulumi.BoolPtrOutput `pulumi:"ignoreRespondersFromPayload"`
	// Name of the integration. Name must be unique for each integration.
	Name pulumi.StringOutput `pulumi:"name"`
	// Owner team id of the integration.
	OwnerTeamId pulumi.StringPtrOutput               `pulumi:"ownerTeamId"`
	Responders  EmailIntegrationResponderArrayOutput `pulumi:"responders"`
	// If enabled, notifications that come from alerts will be suppressed. Default: `false`.
	SuppressNotifications pulumi.BoolPtrOutput `pulumi:"suppressNotifications"`
}

Manages an Email Integration within Opsgenie.

## Import

Email Integrations can be imported using the `id`, e.g.

```sh $ pulumi import opsgenie:index/emailIntegration:EmailIntegration test id` ```

func GetEmailIntegration 

func GetEmailIntegration(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *EmailIntegrationState, opts ...pulumi.ResourceOption) (*EmailIntegration, error)

GetEmailIntegration gets an existing EmailIntegration resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewEmailIntegration 

func NewEmailIntegration(ctx *pulumi.Context,
	name string, args *EmailIntegrationArgs, opts ...pulumi.ResourceOption) (*EmailIntegration, error)

NewEmailIntegration registers a new resource with the given unique name, arguments, and options.

func (*EmailIntegration) ElementType 

func (*EmailIntegration) ElementType() reflect.Type

func (*EmailIntegration) ToEmailIntegrationOutput 

func (i *EmailIntegration) ToEmailIntegrationOutput() EmailIntegrationOutput

func (*EmailIntegration) ToEmailIntegrationOutputWithContext 

func (i *EmailIntegration) ToEmailIntegrationOutputWithContext(ctx context.Context) EmailIntegrationOutput

type EmailIntegrationArgs 

type EmailIntegrationArgs struct {
	// The username part of the email address. It must be unique for each integration.
	EmailUsername pulumi.StringInput
	// A Member block as documented below.
	Enabled pulumi.BoolPtrInput
	// If enabled, the integration will ignore recipients sent in request payloads. Default: `false`.
	IgnoreRespondersFromPayload pulumi.BoolPtrInput
	// Name of the integration. Name must be unique for each integration.
	Name pulumi.StringPtrInput
	// Owner team id of the integration.
	OwnerTeamId pulumi.StringPtrInput
	Responders  EmailIntegrationResponderArrayInput
	// If enabled, notifications that come from alerts will be suppressed. Default: `false`.
	SuppressNotifications pulumi.BoolPtrInput
}

The set of arguments for constructing a EmailIntegration resource.

func (EmailIntegrationArgs) ElementType 

func (EmailIntegrationArgs) ElementType() reflect.Type

type EmailIntegrationArray added in v0.1.3 

type EmailIntegrationArray []EmailIntegrationInput

func (EmailIntegrationArray) ElementType added in v0.1.3 

func (EmailIntegrationArray) ElementType() reflect.Type

func (EmailIntegrationArray) ToEmailIntegrationArrayOutput added in v0.1.3 

func (i EmailIntegrationArray) ToEmailIntegrationArrayOutput() EmailIntegrationArrayOutput

func (EmailIntegrationArray) ToEmailIntegrationArrayOutputWithContext added in v0.1.3 

func (i EmailIntegrationArray) ToEmailIntegrationArrayOutputWithContext(ctx context.Context) EmailIntegrationArrayOutput

type EmailIntegrationArrayInput added in v0.1.3 

type EmailIntegrationArrayInput interface {
	pulumi.Input

	ToEmailIntegrationArrayOutput() EmailIntegrationArrayOutput
	ToEmailIntegrationArrayOutputWithContext(context.Context) EmailIntegrationArrayOutput
}

EmailIntegrationArrayInput is an input type that accepts EmailIntegrationArray and EmailIntegrationArrayOutput values. You can construct a concrete instance of `EmailIntegrationArrayInput` via: 

EmailIntegrationArray{ EmailIntegrationArgs{...} }

type EmailIntegrationArrayOutput added in v0.1.3 

type EmailIntegrationArrayOutput struct{ *pulumi.OutputState }

func (EmailIntegrationArrayOutput) ElementType added in v0.1.3 

func (EmailIntegrationArrayOutput) ElementType() reflect.Type

func (EmailIntegrationArrayOutput) Index added in v0.1.3 

func (o EmailIntegrationArrayOutput) Index(i pulumi.IntInput) EmailIntegrationOutput

func (EmailIntegrationArrayOutput) ToEmailIntegrationArrayOutput added in v0.1.3 

func (o EmailIntegrationArrayOutput) ToEmailIntegrationArrayOutput() EmailIntegrationArrayOutput

func (EmailIntegrationArrayOutput) ToEmailIntegrationArrayOutputWithContext added in v0.1.3 

func (o EmailIntegrationArrayOutput) ToEmailIntegrationArrayOutputWithContext(ctx context.Context) EmailIntegrationArrayOutput

type EmailIntegrationInput 

type EmailIntegrationInput interface {
	pulumi.Input

	ToEmailIntegrationOutput() EmailIntegrationOutput
	ToEmailIntegrationOutputWithContext(ctx context.Context) EmailIntegrationOutput
}

type EmailIntegrationMap added in v0.1.3 

type EmailIntegrationMap map[string]EmailIntegrationInput

func (EmailIntegrationMap) ElementType added in v0.1.3 

func (EmailIntegrationMap) ElementType() reflect.Type

func (EmailIntegrationMap) ToEmailIntegrationMapOutput added in v0.1.3 

func (i EmailIntegrationMap) ToEmailIntegrationMapOutput() EmailIntegrationMapOutput

func (EmailIntegrationMap) ToEmailIntegrationMapOutputWithContext added in v0.1.3 

func (i EmailIntegrationMap) ToEmailIntegrationMapOutputWithContext(ctx context.Context) EmailIntegrationMapOutput

type EmailIntegrationMapInput added in v0.1.3 

type EmailIntegrationMapInput interface {
	pulumi.Input

	ToEmailIntegrationMapOutput() EmailIntegrationMapOutput
	ToEmailIntegrationMapOutputWithContext(context.Context) EmailIntegrationMapOutput
}

EmailIntegrationMapInput is an input type that accepts EmailIntegrationMap and EmailIntegrationMapOutput values. You can construct a concrete instance of `EmailIntegrationMapInput` via: 

EmailIntegrationMap{ "key": EmailIntegrationArgs{...} }

type EmailIntegrationMapOutput added in v0.1.3 

type EmailIntegrationMapOutput struct{ *pulumi.OutputState }

func (EmailIntegrationMapOutput) ElementType added in v0.1.3 

func (EmailIntegrationMapOutput) ElementType() reflect.Type

func (EmailIntegrationMapOutput) MapIndex added in v0.1.3 

func (o EmailIntegrationMapOutput) MapIndex(k pulumi.StringInput) EmailIntegrationOutput

func (EmailIntegrationMapOutput) ToEmailIntegrationMapOutput added in v0.1.3 

func (o EmailIntegrationMapOutput) ToEmailIntegrationMapOutput() EmailIntegrationMapOutput

func (EmailIntegrationMapOutput) ToEmailIntegrationMapOutputWithContext added in v0.1.3 

func (o EmailIntegrationMapOutput) ToEmailIntegrationMapOutputWithContext(ctx context.Context) EmailIntegrationMapOutput

type EmailIntegrationOutput 

type EmailIntegrationOutput struct{ *pulumi.OutputState }

func (EmailIntegrationOutput) ElementType 

func (EmailIntegrationOutput) ElementType() reflect.Type

func (EmailIntegrationOutput) EmailUsername added in v1.1.9 

func (o EmailIntegrationOutput) EmailUsername() pulumi.StringOutput

The username part of the email address. It must be unique for each integration.

func (EmailIntegrationOutput) Enabled added in v1.1.9 

func (o EmailIntegrationOutput) Enabled() pulumi.BoolPtrOutput

A Member block as documented below.

func (EmailIntegrationOutput) IgnoreRespondersFromPayload added in v1.1.9 

func (o EmailIntegrationOutput) IgnoreRespondersFromPayload() pulumi.BoolPtrOutput

If enabled, the integration will ignore recipients sent in request payloads. Default: `false`.

func (EmailIntegrationOutput) Name added in v1.1.9 

func (o EmailIntegrationOutput) Name() pulumi.StringOutput

Name of the integration. Name must be unique for each integration.

func (EmailIntegrationOutput) OwnerTeamId added in v1.1.9 

func (o EmailIntegrationOutput) OwnerTeamId() pulumi.StringPtrOutput

Owner team id of the integration.

func (EmailIntegrationOutput) Responders added in v1.1.9 

func (o EmailIntegrationOutput) Responders() EmailIntegrationResponderArrayOutput

func (EmailIntegrationOutput) SuppressNotifications added in v1.1.9 

func (o EmailIntegrationOutput) SuppressNotifications() pulumi.BoolPtrOutput

If enabled, notifications that come from alerts will be suppressed. Default: `false`.

func (EmailIntegrationOutput) ToEmailIntegrationOutput 

func (o EmailIntegrationOutput) ToEmailIntegrationOutput() EmailIntegrationOutput

func (EmailIntegrationOutput) ToEmailIntegrationOutputWithContext 

func (o EmailIntegrationOutput) ToEmailIntegrationOutputWithContext(ctx context.Context) EmailIntegrationOutput

type EmailIntegrationResponder 

type EmailIntegrationResponder struct {
	// The ID of the Opsgenie Email based Integration.
	Id   *string `pulumi:"id"`
	Type *string `pulumi:"type"`
}

type EmailIntegrationResponderArgs 

type EmailIntegrationResponderArgs struct {
	// The ID of the Opsgenie Email based Integration.
	Id   pulumi.StringPtrInput `pulumi:"id"`
	Type pulumi.StringPtrInput `pulumi:"type"`
}

func (EmailIntegrationResponderArgs) ElementType 

func (EmailIntegrationResponderArgs) ElementType() reflect.Type

func (EmailIntegrationResponderArgs) ToEmailIntegrationResponderOutput 

func (i EmailIntegrationResponderArgs) ToEmailIntegrationResponderOutput() EmailIntegrationResponderOutput

func (EmailIntegrationResponderArgs) ToEmailIntegrationResponderOutputWithContext 

func (i EmailIntegrationResponderArgs) ToEmailIntegrationResponderOutputWithContext(ctx context.Context) EmailIntegrationResponderOutput

type EmailIntegrationResponderArray 

type EmailIntegrationResponderArray []EmailIntegrationResponderInput

func (EmailIntegrationResponderArray) ElementType 

func (EmailIntegrationResponderArray) ElementType() reflect.Type

func (EmailIntegrationResponderArray) ToEmailIntegrationResponderArrayOutput 

func (i EmailIntegrationResponderArray) ToEmailIntegrationResponderArrayOutput() EmailIntegrationResponderArrayOutput

func (EmailIntegrationResponderArray) ToEmailIntegrationResponderArrayOutputWithContext 

func (i EmailIntegrationResponderArray) ToEmailIntegrationResponderArrayOutputWithContext(ctx context.Context) EmailIntegrationResponderArrayOutput

type EmailIntegrationResponderArrayInput 

type EmailIntegrationResponderArrayInput interface {
	pulumi.Input

	ToEmailIntegrationResponderArrayOutput() EmailIntegrationResponderArrayOutput
	ToEmailIntegrationResponderArrayOutputWithContext(context.Context) EmailIntegrationResponderArrayOutput
}

EmailIntegrationResponderArrayInput is an input type that accepts EmailIntegrationResponderArray and EmailIntegrationResponderArrayOutput values. You can construct a concrete instance of `EmailIntegrationResponderArrayInput` via: 

EmailIntegrationResponderArray{ EmailIntegrationResponderArgs{...} }

type EmailIntegrationResponderArrayOutput 

type EmailIntegrationResponderArrayOutput struct{ *pulumi.OutputState }

func (EmailIntegrationResponderArrayOutput) ElementType 

func (EmailIntegrationResponderArrayOutput) ElementType() reflect.Type

func (EmailIntegrationResponderArrayOutput) Index 

func (o EmailIntegrationResponderArrayOutput) Index(i pulumi.IntInput) EmailIntegrationResponderOutput

func (EmailIntegrationResponderArrayOutput) ToEmailIntegrationResponderArrayOutput 

func (o EmailIntegrationResponderArrayOutput) ToEmailIntegrationResponderArrayOutput() EmailIntegrationResponderArrayOutput

func (EmailIntegrationResponderArrayOutput) ToEmailIntegrationResponderArrayOutputWithContext 

func (o EmailIntegrationResponderArrayOutput) ToEmailIntegrationResponderArrayOutputWithContext(ctx context.Context) EmailIntegrationResponderArrayOutput

type EmailIntegrationResponderInput 

type EmailIntegrationResponderInput interface {
	pulumi.Input

	ToEmailIntegrationResponderOutput() EmailIntegrationResponderOutput
	ToEmailIntegrationResponderOutputWithContext(context.Context) EmailIntegrationResponderOutput
}

EmailIntegrationResponderInput is an input type that accepts EmailIntegrationResponderArgs and EmailIntegrationResponderOutput values. You can construct a concrete instance of `EmailIntegrationResponderInput` via: 

EmailIntegrationResponderArgs{...}

type EmailIntegrationResponderOutput 

type EmailIntegrationResponderOutput struct{ *pulumi.OutputState }

func (EmailIntegrationResponderOutput) ElementType 

func (EmailIntegrationResponderOutput) ElementType() reflect.Type

func (EmailIntegrationResponderOutput) Id 

func (o EmailIntegrationResponderOutput) Id() pulumi.StringPtrOutput

The ID of the Opsgenie Email based Integration.

func (EmailIntegrationResponderOutput) ToEmailIntegrationResponderOutput 

func (o EmailIntegrationResponderOutput) ToEmailIntegrationResponderOutput() EmailIntegrationResponderOutput

func (EmailIntegrationResponderOutput) ToEmailIntegrationResponderOutputWithContext 

func (o EmailIntegrationResponderOutput) ToEmailIntegrationResponderOutputWithContext(ctx context.Context) EmailIntegrationResponderOutput

func (EmailIntegrationResponderOutput) Type 

func (o EmailIntegrationResponderOutput) Type() pulumi.StringPtrOutput

type EmailIntegrationState 

type EmailIntegrationState struct {
	// The username part of the email address. It must be unique for each integration.
	EmailUsername pulumi.StringPtrInput
	// A Member block as documented below.
	Enabled pulumi.BoolPtrInput
	// If enabled, the integration will ignore recipients sent in request payloads. Default: `false`.
	IgnoreRespondersFromPayload pulumi.BoolPtrInput
	// Name of the integration. Name must be unique for each integration.
	Name pulumi.StringPtrInput
	// Owner team id of the integration.
	OwnerTeamId pulumi.StringPtrInput
	Responders  EmailIntegrationResponderArrayInput
	// If enabled, notifications that come from alerts will be suppressed. Default: `false`.
	SuppressNotifications pulumi.BoolPtrInput
}

func (EmailIntegrationState) ElementType 

func (EmailIntegrationState) ElementType() reflect.Type

type Escalation 

type Escalation struct {
	pulumi.CustomResourceState

	// Description of the escalation.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Name of the escalation.
	Name pulumi.StringOutput `pulumi:"name"`
	// Owner team id of the escalation.
	OwnerTeamId pulumi.StringPtrOutput `pulumi:"ownerTeamId"`
	// Repeat preferences of the escalation including repeat interval, count, reverting acknowledge and seen states back and closing an alert automatically as soon as repeats are completed
	Repeats EscalationRepeatArrayOutput `pulumi:"repeats"`
	// List of the escalation rules. See below for how rules are defined.
	Rules EscalationRuleArrayOutput `pulumi:"rules"`
}

Manages an Escalation within Opsgenie.

## Example Usage

An escalation with a single rule

```go package main

import ( 

"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opsgenie.NewEscalation(ctx, "default", &opsgenie.EscalationArgs{
			Name: pulumi.String("genieescalation"),
			Rules: opsgenie.EscalationRuleArray{
				&opsgenie.EscalationRuleArgs{
					Condition:  pulumi.String("if-not-acked"),
					NotifyType: pulumi.String("default"),
					Delay:      pulumi.Int(1),
					Recipients: opsgenie.EscalationRuleRecipientArray{
						&opsgenie.EscalationRuleRecipientArgs{
							Type: pulumi.String("user"),
							Id:   pulumi.Any(test.Id),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

An escalation with a multiple rules

```go package main

import ( 

"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opsgenie.NewEscalation(ctx, "default", &opsgenie.EscalationArgs{
			Name:        pulumi.String("genieescalation"),
			Description: pulumi.String("test"),
			OwnerTeamId: pulumi.Any(testOpsgenieTeam.Id),
			Rules: opsgenie.EscalationRuleArray{
				&opsgenie.EscalationRuleArgs{
					Condition:  pulumi.String("if-not-acked"),
					NotifyType: pulumi.String("default"),
					Delay:      pulumi.Int(1),
					Recipients: opsgenie.EscalationRuleRecipientArray{
						&opsgenie.EscalationRuleRecipientArgs{
							Type: pulumi.String("user"),
							Id:   pulumi.Any(test.Id),
						},
					},
				},
				&opsgenie.EscalationRuleArgs{
					Condition:  pulumi.String("if-not-acked"),
					NotifyType: pulumi.String("default"),
					Delay:      pulumi.Int(1),
					Recipients: opsgenie.EscalationRuleRecipientArray{
						&opsgenie.EscalationRuleRecipientArgs{
							Type: pulumi.String("team"),
							Id:   pulumi.Any(testOpsgenieTeam.Id),
						},
					},
				},
				&opsgenie.EscalationRuleArgs{
					Condition:  pulumi.String("if-not-acked"),
					NotifyType: pulumi.String("default"),
					Delay:      pulumi.Int(1),
					Recipients: opsgenie.EscalationRuleRecipientArray{
						&opsgenie.EscalationRuleRecipientArgs{
							Type: pulumi.String("schedule"),
							Id:   pulumi.Any(testOpsgenieSchedule.Id),
						},
					},
				},
			},
			Repeats: opsgenie.EscalationRepeatArray{
				&opsgenie.EscalationRepeatArgs{
					WaitInterval:         pulumi.Int(10),
					Count:                pulumi.Int(1),
					ResetRecipientStates: pulumi.Bool(true),
					CloseAlertAfterAll:   pulumi.Bool(false),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Escalations can be imported using the `escalation_id`, e.g.

```sh $ pulumi import opsgenie:index/escalation:Escalation test escalation_id` ```

func GetEscalation 

func GetEscalation(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *EscalationState, opts ...pulumi.ResourceOption) (*Escalation, error)

GetEscalation gets an existing Escalation resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewEscalation 

func NewEscalation(ctx *pulumi.Context,
	name string, args *EscalationArgs, opts ...pulumi.ResourceOption) (*Escalation, error)

NewEscalation registers a new resource with the given unique name, arguments, and options.

func (*Escalation) ElementType 

func (*Escalation) ElementType() reflect.Type

func (*Escalation) ToEscalationOutput 

func (i *Escalation) ToEscalationOutput() EscalationOutput

func (*Escalation) ToEscalationOutputWithContext 

func (i *Escalation) ToEscalationOutputWithContext(ctx context.Context) EscalationOutput

type EscalationArgs 

type EscalationArgs struct {
	// Description of the escalation.
	Description pulumi.StringPtrInput
	// Name of the escalation.
	Name pulumi.StringPtrInput
	// Owner team id of the escalation.
	OwnerTeamId pulumi.StringPtrInput
	// Repeat preferences of the escalation including repeat interval, count, reverting acknowledge and seen states back and closing an alert automatically as soon as repeats are completed
	Repeats EscalationRepeatArrayInput
	// List of the escalation rules. See below for how rules are defined.
	Rules EscalationRuleArrayInput
}

The set of arguments for constructing a Escalation resource.

func (EscalationArgs) ElementType 

func (EscalationArgs) ElementType() reflect.Type

type EscalationArray added in v0.1.3 

type EscalationArray []EscalationInput

func (EscalationArray) ElementType added in v0.1.3 

func (EscalationArray) ElementType() reflect.Type

func (EscalationArray) ToEscalationArrayOutput added in v0.1.3 

func (i EscalationArray) ToEscalationArrayOutput() EscalationArrayOutput

func (EscalationArray) ToEscalationArrayOutputWithContext added in v0.1.3 

func (i EscalationArray) ToEscalationArrayOutputWithContext(ctx context.Context) EscalationArrayOutput

type EscalationArrayInput added in v0.1.3 

type EscalationArrayInput interface {
	pulumi.Input

	ToEscalationArrayOutput() EscalationArrayOutput
	ToEscalationArrayOutputWithContext(context.Context) EscalationArrayOutput
}

EscalationArrayInput is an input type that accepts EscalationArray and EscalationArrayOutput values. You can construct a concrete instance of `EscalationArrayInput` via: 

EscalationArray{ EscalationArgs{...} }

type EscalationArrayOutput added in v0.1.3 

type EscalationArrayOutput struct{ *pulumi.OutputState }

func (EscalationArrayOutput) ElementType added in v0.1.3 

func (EscalationArrayOutput) ElementType() reflect.Type

func (EscalationArrayOutput) Index added in v0.1.3 

func (o EscalationArrayOutput) Index(i pulumi.IntInput) EscalationOutput

func (EscalationArrayOutput) ToEscalationArrayOutput added in v0.1.3 

func (o EscalationArrayOutput) ToEscalationArrayOutput() EscalationArrayOutput

func (EscalationArrayOutput) ToEscalationArrayOutputWithContext added in v0.1.3 

func (o EscalationArrayOutput) ToEscalationArrayOutputWithContext(ctx context.Context) EscalationArrayOutput

type EscalationInput 

type EscalationInput interface {
	pulumi.Input

	ToEscalationOutput() EscalationOutput
	ToEscalationOutputWithContext(ctx context.Context) EscalationOutput
}

type EscalationMap added in v0.1.3 

type EscalationMap map[string]EscalationInput

func (EscalationMap) ElementType added in v0.1.3 

func (EscalationMap) ElementType() reflect.Type

func (EscalationMap) ToEscalationMapOutput added in v0.1.3 

func (i EscalationMap) ToEscalationMapOutput() EscalationMapOutput

func (EscalationMap) ToEscalationMapOutputWithContext added in v0.1.3 

func (i EscalationMap) ToEscalationMapOutputWithContext(ctx context.Context) EscalationMapOutput

type EscalationMapInput added in v0.1.3 

type EscalationMapInput interface {
	pulumi.Input

	ToEscalationMapOutput() EscalationMapOutput
	ToEscalationMapOutputWithContext(context.Context) EscalationMapOutput
}

EscalationMapInput is an input type that accepts EscalationMap and EscalationMapOutput values. You can construct a concrete instance of `EscalationMapInput` via: 

EscalationMap{ "key": EscalationArgs{...} }

type EscalationMapOutput added in v0.1.3 

type EscalationMapOutput struct{ *pulumi.OutputState }

func (EscalationMapOutput) ElementType added in v0.1.3 

func (EscalationMapOutput) ElementType() reflect.Type

func (EscalationMapOutput) MapIndex added in v0.1.3 

func (o EscalationMapOutput) MapIndex(k pulumi.StringInput) EscalationOutput

func (EscalationMapOutput) ToEscalationMapOutput added in v0.1.3 

func (o EscalationMapOutput) ToEscalationMapOutput() EscalationMapOutput

func (EscalationMapOutput) ToEscalationMapOutputWithContext added in v0.1.3 

func (o EscalationMapOutput) ToEscalationMapOutputWithContext(ctx context.Context) EscalationMapOutput

type EscalationOutput 

type EscalationOutput struct{ *pulumi.OutputState }

func (EscalationOutput) Description added in v1.1.9 

func (o EscalationOutput) Description() pulumi.StringPtrOutput

Description of the escalation.

func (EscalationOutput) ElementType 

func (EscalationOutput) ElementType() reflect.Type

func (EscalationOutput) Name added in v1.1.9 

func (o EscalationOutput) Name() pulumi.StringOutput

Name of the escalation.

func (EscalationOutput) OwnerTeamId added in v1.1.9 

func (o EscalationOutput) OwnerTeamId() pulumi.StringPtrOutput

Owner team id of the escalation.

func (EscalationOutput) Repeats added in v1.1.9 

func (o EscalationOutput) Repeats() EscalationRepeatArrayOutput

Repeat preferences of the escalation including repeat interval, count, reverting acknowledge and seen states back and closing an alert automatically as soon as repeats are completed

func (EscalationOutput) Rules added in v1.1.9 

func (o EscalationOutput) Rules() EscalationRuleArrayOutput

List of the escalation rules. See below for how rules are defined.

func (EscalationOutput) ToEscalationOutput 

func (o EscalationOutput) ToEscalationOutput() EscalationOutput

func (EscalationOutput) ToEscalationOutputWithContext 

func (o EscalationOutput) ToEscalationOutputWithContext(ctx context.Context) EscalationOutput

type EscalationRepeat 

type EscalationRepeat struct {
	CloseAlertAfterAll   *bool `pulumi:"closeAlertAfterAll"`
	Count                *int  `pulumi:"count"`
	ResetRecipientStates *bool `pulumi:"resetRecipientStates"`
	WaitInterval         *int  `pulumi:"waitInterval"`
}

type EscalationRepeatArgs 

type EscalationRepeatArgs struct {
	CloseAlertAfterAll   pulumi.BoolPtrInput `pulumi:"closeAlertAfterAll"`
	Count                pulumi.IntPtrInput  `pulumi:"count"`
	ResetRecipientStates pulumi.BoolPtrInput `pulumi:"resetRecipientStates"`
	WaitInterval         pulumi.IntPtrInput  `pulumi:"waitInterval"`
}

func (EscalationRepeatArgs) ElementType 

func (EscalationRepeatArgs) ElementType() reflect.Type

func (EscalationRepeatArgs) ToEscalationRepeatOutput 

func (i EscalationRepeatArgs) ToEscalationRepeatOutput() EscalationRepeatOutput

func (EscalationRepeatArgs) ToEscalationRepeatOutputWithContext 

func (i EscalationRepeatArgs) ToEscalationRepeatOutputWithContext(ctx context.Context) EscalationRepeatOutput

type EscalationRepeatArray 

type EscalationRepeatArray []EscalationRepeatInput

func (EscalationRepeatArray) ElementType 

func (EscalationRepeatArray) ElementType() reflect.Type

func (EscalationRepeatArray) ToEscalationRepeatArrayOutput 

func (i EscalationRepeatArray) ToEscalationRepeatArrayOutput() EscalationRepeatArrayOutput

func (EscalationRepeatArray) ToEscalationRepeatArrayOutputWithContext 

func (i EscalationRepeatArray) ToEscalationRepeatArrayOutputWithContext(ctx context.Context) EscalationRepeatArrayOutput

type EscalationRepeatArrayInput 

type EscalationRepeatArrayInput interface {
	pulumi.Input

	ToEscalationRepeatArrayOutput() EscalationRepeatArrayOutput
	ToEscalationRepeatArrayOutputWithContext(context.Context) EscalationRepeatArrayOutput
}

EscalationRepeatArrayInput is an input type that accepts EscalationRepeatArray and EscalationRepeatArrayOutput values. You can construct a concrete instance of `EscalationRepeatArrayInput` via: 

EscalationRepeatArray{ EscalationRepeatArgs{...} }

type EscalationRepeatArrayOutput 

type EscalationRepeatArrayOutput struct{ *pulumi.OutputState }

func (EscalationRepeatArrayOutput) ElementType 

func (EscalationRepeatArrayOutput) ElementType() reflect.Type

func (EscalationRepeatArrayOutput) Index 

func (o EscalationRepeatArrayOutput) Index(i pulumi.IntInput) EscalationRepeatOutput

func (EscalationRepeatArrayOutput) ToEscalationRepeatArrayOutput 

func (o EscalationRepeatArrayOutput) ToEscalationRepeatArrayOutput() EscalationRepeatArrayOutput

func (EscalationRepeatArrayOutput) ToEscalationRepeatArrayOutputWithContext 

func (o EscalationRepeatArrayOutput) ToEscalationRepeatArrayOutputWithContext(ctx context.Context) EscalationRepeatArrayOutput

type EscalationRepeatInput 

type EscalationRepeatInput interface {
	pulumi.Input

	ToEscalationRepeatOutput() EscalationRepeatOutput
	ToEscalationRepeatOutputWithContext(context.Context) EscalationRepeatOutput
}

EscalationRepeatInput is an input type that accepts EscalationRepeatArgs and EscalationRepeatOutput values. You can construct a concrete instance of `EscalationRepeatInput` via: 

EscalationRepeatArgs{...}

type EscalationRepeatOutput 

type EscalationRepeatOutput struct{ *pulumi.OutputState }

func (EscalationRepeatOutput) CloseAlertAfterAll 

func (o EscalationRepeatOutput) CloseAlertAfterAll() pulumi.BoolPtrOutput

func (EscalationRepeatOutput) Count 

func (o EscalationRepeatOutput) Count() pulumi.IntPtrOutput

func (EscalationRepeatOutput) ElementType 

func (EscalationRepeatOutput) ElementType() reflect.Type

func (EscalationRepeatOutput) ResetRecipientStates 

func (o EscalationRepeatOutput) ResetRecipientStates() pulumi.BoolPtrOutput

func (EscalationRepeatOutput) ToEscalationRepeatOutput 

func (o EscalationRepeatOutput) ToEscalationRepeatOutput() EscalationRepeatOutput

func (EscalationRepeatOutput) ToEscalationRepeatOutputWithContext 

func (o EscalationRepeatOutput) ToEscalationRepeatOutputWithContext(ctx context.Context) EscalationRepeatOutput

func (EscalationRepeatOutput) WaitInterval 

func (o EscalationRepeatOutput) WaitInterval() pulumi.IntPtrOutput

type EscalationRule 

type EscalationRule struct {
	// The condition for notifying the recipient of escalation rule that is based on the alert state. Possible values are: `if-not-acked` and `if-not-closed`. Default: `if-not-acked`
	Condition string `pulumi:"condition"`
	// Time delay of the escalation rule, in minutes.
	Delay int `pulumi:"delay"`
	// Recipient calculation logic for schedules. Possible values are:
	NotifyType string `pulumi:"notifyType"`
	// Object of schedule, team, or users which will be notified in escalation. The possible values for participants are: `user`, `schedule`, `team`. There can only be one recipient per each `rules`.
	Recipients []EscalationRuleRecipient `pulumi:"recipients"`
}

type EscalationRuleArgs 

type EscalationRuleArgs struct {
	// The condition for notifying the recipient of escalation rule that is based on the alert state. Possible values are: `if-not-acked` and `if-not-closed`. Default: `if-not-acked`
	Condition pulumi.StringInput `pulumi:"condition"`
	// Time delay of the escalation rule, in minutes.
	Delay pulumi.IntInput `pulumi:"delay"`
	// Recipient calculation logic for schedules. Possible values are:
	NotifyType pulumi.StringInput `pulumi:"notifyType"`
	// Object of schedule, team, or users which will be notified in escalation. The possible values for participants are: `user`, `schedule`, `team`. There can only be one recipient per each `rules`.
	Recipients EscalationRuleRecipientArrayInput `pulumi:"recipients"`
}

func (EscalationRuleArgs) ElementType 

func (EscalationRuleArgs) ElementType() reflect.Type

func (EscalationRuleArgs) ToEscalationRuleOutput 

func (i EscalationRuleArgs) ToEscalationRuleOutput() EscalationRuleOutput

func (EscalationRuleArgs) ToEscalationRuleOutputWithContext 

func (i EscalationRuleArgs) ToEscalationRuleOutputWithContext(ctx context.Context) EscalationRuleOutput

type EscalationRuleArray 

type EscalationRuleArray []EscalationRuleInput

func (EscalationRuleArray) ElementType 

func (EscalationRuleArray) ElementType() reflect.Type

func (EscalationRuleArray) ToEscalationRuleArrayOutput 

func (i EscalationRuleArray) ToEscalationRuleArrayOutput() EscalationRuleArrayOutput

func (EscalationRuleArray) ToEscalationRuleArrayOutputWithContext 

func (i EscalationRuleArray) ToEscalationRuleArrayOutputWithContext(ctx context.Context) EscalationRuleArrayOutput

type EscalationRuleArrayInput 

type EscalationRuleArrayInput interface {
	pulumi.Input

	ToEscalationRuleArrayOutput() EscalationRuleArrayOutput
	ToEscalationRuleArrayOutputWithContext(context.Context) EscalationRuleArrayOutput
}

EscalationRuleArrayInput is an input type that accepts EscalationRuleArray and EscalationRuleArrayOutput values. You can construct a concrete instance of `EscalationRuleArrayInput` via: 

EscalationRuleArray{ EscalationRuleArgs{...} }

type EscalationRuleArrayOutput 

type EscalationRuleArrayOutput struct{ *pulumi.OutputState }

func (EscalationRuleArrayOutput) ElementType 

func (EscalationRuleArrayOutput) ElementType() reflect.Type

func (EscalationRuleArrayOutput) Index 

func (o EscalationRuleArrayOutput) Index(i pulumi.IntInput) EscalationRuleOutput

func (EscalationRuleArrayOutput) ToEscalationRuleArrayOutput 

func (o EscalationRuleArrayOutput) ToEscalationRuleArrayOutput() EscalationRuleArrayOutput

func (EscalationRuleArrayOutput) ToEscalationRuleArrayOutputWithContext 

func (o EscalationRuleArrayOutput) ToEscalationRuleArrayOutputWithContext(ctx context.Context) EscalationRuleArrayOutput

type EscalationRuleInput 

type EscalationRuleInput interface {
	pulumi.Input

	ToEscalationRuleOutput() EscalationRuleOutput
	ToEscalationRuleOutputWithContext(context.Context) EscalationRuleOutput
}

EscalationRuleInput is an input type that accepts EscalationRuleArgs and EscalationRuleOutput values. You can construct a concrete instance of `EscalationRuleInput` via: 

EscalationRuleArgs{...}

type EscalationRuleOutput 

type EscalationRuleOutput struct{ *pulumi.OutputState }

func (EscalationRuleOutput) Condition 

func (o EscalationRuleOutput) Condition() pulumi.StringOutput

The condition for notifying the recipient of escalation rule that is based on the alert state. Possible values are: `if-not-acked` and `if-not-closed`. Default: `if-not-acked`

func (EscalationRuleOutput) Delay 

func (o EscalationRuleOutput) Delay() pulumi.IntOutput

Time delay of the escalation rule, in minutes.

func (EscalationRuleOutput) ElementType 

func (EscalationRuleOutput) ElementType() reflect.Type

func (EscalationRuleOutput) NotifyType 

func (o EscalationRuleOutput) NotifyType() pulumi.StringOutput

Recipient calculation logic for schedules. Possible values are:

func (EscalationRuleOutput) Recipients 

func (o EscalationRuleOutput) Recipients() EscalationRuleRecipientArrayOutput

Object of schedule, team, or users which will be notified in escalation. The possible values for participants are: `user`, `schedule`, `team`. There can only be one recipient per each `rules`.

func (EscalationRuleOutput) ToEscalationRuleOutput 

func (o EscalationRuleOutput) ToEscalationRuleOutput() EscalationRuleOutput

func (EscalationRuleOutput) ToEscalationRuleOutputWithContext 

func (o EscalationRuleOutput) ToEscalationRuleOutputWithContext(ctx context.Context) EscalationRuleOutput

type EscalationRuleRecipient 

type EscalationRuleRecipient struct {
	// The ID of the Opsgenie Escalation.
	Id   *string `pulumi:"id"`
	Type *string `pulumi:"type"`
}

type EscalationRuleRecipientArgs 

type EscalationRuleRecipientArgs struct {
	// The ID of the Opsgenie Escalation.
	Id   pulumi.StringPtrInput `pulumi:"id"`
	Type pulumi.StringPtrInput `pulumi:"type"`
}

func (EscalationRuleRecipientArgs) ElementType 

func (EscalationRuleRecipientArgs) ElementType() reflect.Type

func (EscalationRuleRecipientArgs) ToEscalationRuleRecipientOutput 

func (i EscalationRuleRecipientArgs) ToEscalationRuleRecipientOutput() EscalationRuleRecipientOutput

func (EscalationRuleRecipientArgs) ToEscalationRuleRecipientOutputWithContext 

func (i EscalationRuleRecipientArgs) ToEscalationRuleRecipientOutputWithContext(ctx context.Context) EscalationRuleRecipientOutput

type EscalationRuleRecipientArray 

type EscalationRuleRecipientArray []EscalationRuleRecipientInput

func (EscalationRuleRecipientArray) ElementType 

func (EscalationRuleRecipientArray) ElementType() reflect.Type

func (EscalationRuleRecipientArray) ToEscalationRuleRecipientArrayOutput 

func (i EscalationRuleRecipientArray) ToEscalationRuleRecipientArrayOutput() EscalationRuleRecipientArrayOutput

func (EscalationRuleRecipientArray) ToEscalationRuleRecipientArrayOutputWithContext 

func (i EscalationRuleRecipientArray) ToEscalationRuleRecipientArrayOutputWithContext(ctx context.Context) EscalationRuleRecipientArrayOutput

type EscalationRuleRecipientArrayInput 

type EscalationRuleRecipientArrayInput interface {
	pulumi.Input

	ToEscalationRuleRecipientArrayOutput() EscalationRuleRecipientArrayOutput
	ToEscalationRuleRecipientArrayOutputWithContext(context.Context) EscalationRuleRecipientArrayOutput
}

EscalationRuleRecipientArrayInput is an input type that accepts EscalationRuleRecipientArray and EscalationRuleRecipientArrayOutput values. You can construct a concrete instance of `EscalationRuleRecipientArrayInput` via: 

EscalationRuleRecipientArray{ EscalationRuleRecipientArgs{...} }

type EscalationRuleRecipientArrayOutput 

type EscalationRuleRecipientArrayOutput struct{ *pulumi.OutputState }

func (EscalationRuleRecipientArrayOutput) ElementType 

func (EscalationRuleRecipientArrayOutput) ElementType() reflect.Type

func (EscalationRuleRecipientArrayOutput) Index 

func (o EscalationRuleRecipientArrayOutput) Index(i pulumi.IntInput) EscalationRuleRecipientOutput

func (EscalationRuleRecipientArrayOutput) ToEscalationRuleRecipientArrayOutput 

func (o EscalationRuleRecipientArrayOutput) ToEscalationRuleRecipientArrayOutput() EscalationRuleRecipientArrayOutput

func (EscalationRuleRecipientArrayOutput) ToEscalationRuleRecipientArrayOutputWithContext 

func (o EscalationRuleRecipientArrayOutput) ToEscalationRuleRecipientArrayOutputWithContext(ctx context.Context) EscalationRuleRecipientArrayOutput

type EscalationRuleRecipientInput 

type EscalationRuleRecipientInput interface {
	pulumi.Input

	ToEscalationRuleRecipientOutput() EscalationRuleRecipientOutput
	ToEscalationRuleRecipientOutputWithContext(context.Context) EscalationRuleRecipientOutput
}

EscalationRuleRecipientInput is an input type that accepts EscalationRuleRecipientArgs and EscalationRuleRecipientOutput values. You can construct a concrete instance of `EscalationRuleRecipientInput` via: 

EscalationRuleRecipientArgs{...}

type EscalationRuleRecipientOutput 

type EscalationRuleRecipientOutput struct{ *pulumi.OutputState }

func (EscalationRuleRecipientOutput) ElementType 

func (EscalationRuleRecipientOutput) ElementType() reflect.Type

func (EscalationRuleRecipientOutput) Id 

func (o EscalationRuleRecipientOutput) Id() pulumi.StringPtrOutput

The ID of the Opsgenie Escalation.

func (EscalationRuleRecipientOutput) ToEscalationRuleRecipientOutput 

func (o EscalationRuleRecipientOutput) ToEscalationRuleRecipientOutput() EscalationRuleRecipientOutput

func (EscalationRuleRecipientOutput) ToEscalationRuleRecipientOutputWithContext 

func (o EscalationRuleRecipientOutput) ToEscalationRuleRecipientOutputWithContext(ctx context.Context) EscalationRuleRecipientOutput

func (EscalationRuleRecipientOutput) Type 

func (o EscalationRuleRecipientOutput) Type() pulumi.StringPtrOutput

type EscalationState 

type EscalationState struct {
	// Description of the escalation.
	Description pulumi.StringPtrInput
	// Name of the escalation.
	Name pulumi.StringPtrInput
	// Owner team id of the escalation.
	OwnerTeamId pulumi.StringPtrInput
	// Repeat preferences of the escalation including repeat interval, count, reverting acknowledge and seen states back and closing an alert automatically as soon as repeats are completed
	Repeats EscalationRepeatArrayInput
	// List of the escalation rules. See below for how rules are defined.
	Rules EscalationRuleArrayInput
}

func (EscalationState) ElementType 

func (EscalationState) ElementType() reflect.Type

type GetEscalationRepeat 

type GetEscalationRepeat struct {
	CloseAlertAfterAll   *bool `pulumi:"closeAlertAfterAll"`
	Count                *int  `pulumi:"count"`
	ResetRecipientStates *bool `pulumi:"resetRecipientStates"`
	WaitInterval         *int  `pulumi:"waitInterval"`
}

type GetEscalationRepeatArgs 

type GetEscalationRepeatArgs struct {
	CloseAlertAfterAll   pulumi.BoolPtrInput `pulumi:"closeAlertAfterAll"`
	Count                pulumi.IntPtrInput  `pulumi:"count"`
	ResetRecipientStates pulumi.BoolPtrInput `pulumi:"resetRecipientStates"`
	WaitInterval         pulumi.IntPtrInput  `pulumi:"waitInterval"`
}

func (GetEscalationRepeatArgs) ElementType 

func (GetEscalationRepeatArgs) ElementType() reflect.Type

func (GetEscalationRepeatArgs) ToGetEscalationRepeatOutput 

func (i GetEscalationRepeatArgs) ToGetEscalationRepeatOutput() GetEscalationRepeatOutput

func (GetEscalationRepeatArgs) ToGetEscalationRepeatOutputWithContext 

func (i GetEscalationRepeatArgs) ToGetEscalationRepeatOutputWithContext(ctx context.Context) GetEscalationRepeatOutput

type GetEscalationRepeatArray 

type GetEscalationRepeatArray []GetEscalationRepeatInput

func (GetEscalationRepeatArray) ElementType 

func (GetEscalationRepeatArray) ElementType() reflect.Type

func (GetEscalationRepeatArray) ToGetEscalationRepeatArrayOutput 

func (i GetEscalationRepeatArray) ToGetEscalationRepeatArrayOutput() GetEscalationRepeatArrayOutput

func (GetEscalationRepeatArray) ToGetEscalationRepeatArrayOutputWithContext 

func (i GetEscalationRepeatArray) ToGetEscalationRepeatArrayOutputWithContext(ctx context.Context) GetEscalationRepeatArrayOutput

type GetEscalationRepeatArrayInput 

type GetEscalationRepeatArrayInput interface {
	pulumi.Input

	ToGetEscalationRepeatArrayOutput() GetEscalationRepeatArrayOutput
	ToGetEscalationRepeatArrayOutputWithContext(context.Context) GetEscalationRepeatArrayOutput
}

GetEscalationRepeatArrayInput is an input type that accepts GetEscalationRepeatArray and GetEscalationRepeatArrayOutput values. You can construct a concrete instance of `GetEscalationRepeatArrayInput` via: 

GetEscalationRepeatArray{ GetEscalationRepeatArgs{...} }

type GetEscalationRepeatArrayOutput 

type GetEscalationRepeatArrayOutput struct{ *pulumi.OutputState }

func (GetEscalationRepeatArrayOutput) ElementType 

func (GetEscalationRepeatArrayOutput) ElementType() reflect.Type

func (GetEscalationRepeatArrayOutput) Index 

func (o GetEscalationRepeatArrayOutput) Index(i pulumi.IntInput) GetEscalationRepeatOutput

func (GetEscalationRepeatArrayOutput) ToGetEscalationRepeatArrayOutput 

func (o GetEscalationRepeatArrayOutput) ToGetEscalationRepeatArrayOutput() GetEscalationRepeatArrayOutput

func (GetEscalationRepeatArrayOutput) ToGetEscalationRepeatArrayOutputWithContext 

func (o GetEscalationRepeatArrayOutput) ToGetEscalationRepeatArrayOutputWithContext(ctx context.Context) GetEscalationRepeatArrayOutput

type GetEscalationRepeatInput 

type GetEscalationRepeatInput interface {
	pulumi.Input

	ToGetEscalationRepeatOutput() GetEscalationRepeatOutput
	ToGetEscalationRepeatOutputWithContext(context.Context) GetEscalationRepeatOutput
}

GetEscalationRepeatInput is an input type that accepts GetEscalationRepeatArgs and GetEscalationRepeatOutput values. You can construct a concrete instance of `GetEscalationRepeatInput` via: 

GetEscalationRepeatArgs{...}

type GetEscalationRepeatOutput 

type GetEscalationRepeatOutput struct{ *pulumi.OutputState }

func (GetEscalationRepeatOutput) CloseAlertAfterAll 

func (o GetEscalationRepeatOutput) CloseAlertAfterAll() pulumi.BoolPtrOutput

func (GetEscalationRepeatOutput) Count 

func (o GetEscalationRepeatOutput) Count() pulumi.IntPtrOutput

func (GetEscalationRepeatOutput) ElementType 

func (GetEscalationRepeatOutput) ElementType() reflect.Type

func (GetEscalationRepeatOutput) ResetRecipientStates 

func (o GetEscalationRepeatOutput) ResetRecipientStates() pulumi.BoolPtrOutput

func (GetEscalationRepeatOutput) ToGetEscalationRepeatOutput 

func (o GetEscalationRepeatOutput) ToGetEscalationRepeatOutput() GetEscalationRepeatOutput

func (GetEscalationRepeatOutput) ToGetEscalationRepeatOutputWithContext 

func (o GetEscalationRepeatOutput) ToGetEscalationRepeatOutputWithContext(ctx context.Context) GetEscalationRepeatOutput

func (GetEscalationRepeatOutput) WaitInterval 

func (o GetEscalationRepeatOutput) WaitInterval() pulumi.IntPtrOutput

type GetEscalationRule 

type GetEscalationRule struct {
	Condition  string                       `pulumi:"condition"`
	Delay      int                          `pulumi:"delay"`
	NotifyType string                       `pulumi:"notifyType"`
	Recipients []GetEscalationRuleRecipient `pulumi:"recipients"`
}

type GetEscalationRuleArgs 

type GetEscalationRuleArgs struct {
	Condition  pulumi.StringInput                   `pulumi:"condition"`
	Delay      pulumi.IntInput                      `pulumi:"delay"`
	NotifyType pulumi.StringInput                   `pulumi:"notifyType"`
	Recipients GetEscalationRuleRecipientArrayInput `pulumi:"recipients"`
}

func (GetEscalationRuleArgs) ElementType 

func (GetEscalationRuleArgs) ElementType() reflect.Type

func (GetEscalationRuleArgs) ToGetEscalationRuleOutput 

func (i GetEscalationRuleArgs) ToGetEscalationRuleOutput() GetEscalationRuleOutput

func (GetEscalationRuleArgs) ToGetEscalationRuleOutputWithContext 

func (i GetEscalationRuleArgs) ToGetEscalationRuleOutputWithContext(ctx context.Context) GetEscalationRuleOutput

type GetEscalationRuleArray 

type GetEscalationRuleArray []GetEscalationRuleInput

func (GetEscalationRuleArray) ElementType 

func (GetEscalationRuleArray) ElementType() reflect.Type

func (GetEscalationRuleArray) ToGetEscalationRuleArrayOutput 

func (i GetEscalationRuleArray) ToGetEscalationRuleArrayOutput() GetEscalationRuleArrayOutput

func (GetEscalationRuleArray) ToGetEscalationRuleArrayOutputWithContext 

func (i GetEscalationRuleArray) ToGetEscalationRuleArrayOutputWithContext(ctx context.Context) GetEscalationRuleArrayOutput

type GetEscalationRuleArrayInput 

type GetEscalationRuleArrayInput interface {
	pulumi.Input

	ToGetEscalationRuleArrayOutput() GetEscalationRuleArrayOutput
	ToGetEscalationRuleArrayOutputWithContext(context.Context) GetEscalationRuleArrayOutput
}

GetEscalationRuleArrayInput is an input type that accepts GetEscalationRuleArray and GetEscalationRuleArrayOutput values. You can construct a concrete instance of `GetEscalationRuleArrayInput` via: 

GetEscalationRuleArray{ GetEscalationRuleArgs{...} }

type GetEscalationRuleArrayOutput 

type GetEscalationRuleArrayOutput struct{ *pulumi.OutputState }

func (GetEscalationRuleArrayOutput) ElementType 

func (GetEscalationRuleArrayOutput) ElementType() reflect.Type

func (GetEscalationRuleArrayOutput) Index 

func (o GetEscalationRuleArrayOutput) Index(i pulumi.IntInput) GetEscalationRuleOutput

func (GetEscalationRuleArrayOutput) ToGetEscalationRuleArrayOutput 

func (o GetEscalationRuleArrayOutput) ToGetEscalationRuleArrayOutput() GetEscalationRuleArrayOutput

func (GetEscalationRuleArrayOutput) ToGetEscalationRuleArrayOutputWithContext 

func (o GetEscalationRuleArrayOutput) ToGetEscalationRuleArrayOutputWithContext(ctx context.Context) GetEscalationRuleArrayOutput

type GetEscalationRuleInput 

type GetEscalationRuleInput interface {
	pulumi.Input

	ToGetEscalationRuleOutput() GetEscalationRuleOutput
	ToGetEscalationRuleOutputWithContext(context.Context) GetEscalationRuleOutput
}

GetEscalationRuleInput is an input type that accepts GetEscalationRuleArgs and GetEscalationRuleOutput values. You can construct a concrete instance of `GetEscalationRuleInput` via: 

GetEscalationRuleArgs{...}

type GetEscalationRuleOutput 

type GetEscalationRuleOutput struct{ *pulumi.OutputState }

func (GetEscalationRuleOutput) Condition 

func (o GetEscalationRuleOutput) Condition() pulumi.StringOutput

func (GetEscalationRuleOutput) Delay 

func (o GetEscalationRuleOutput) Delay() pulumi.IntOutput

func (GetEscalationRuleOutput) ElementType 

func (GetEscalationRuleOutput) ElementType() reflect.Type

func (GetEscalationRuleOutput) NotifyType 

func (o GetEscalationRuleOutput) NotifyType() pulumi.StringOutput

func (GetEscalationRuleOutput) Recipients 

func (o GetEscalationRuleOutput) Recipients() GetEscalationRuleRecipientArrayOutput

func (GetEscalationRuleOutput) ToGetEscalationRuleOutput 

func (o GetEscalationRuleOutput) ToGetEscalationRuleOutput() GetEscalationRuleOutput

func (GetEscalationRuleOutput) ToGetEscalationRuleOutputWithContext 

func (o GetEscalationRuleOutput) ToGetEscalationRuleOutputWithContext(ctx context.Context) GetEscalationRuleOutput

type GetEscalationRuleRecipient 

type GetEscalationRuleRecipient struct {
	// The ID of the Opsgenie Escalation.
	Id   *string `pulumi:"id"`
	Type *string `pulumi:"type"`
}

type GetEscalationRuleRecipientArgs 

type GetEscalationRuleRecipientArgs struct {
	// The ID of the Opsgenie Escalation.
	Id   pulumi.StringPtrInput `pulumi:"id"`
	Type pulumi.StringPtrInput `pulumi:"type"`
}

func (GetEscalationRuleRecipientArgs) ElementType 

func (GetEscalationRuleRecipientArgs) ElementType() reflect.Type

func (GetEscalationRuleRecipientArgs) ToGetEscalationRuleRecipientOutput 

func (i GetEscalationRuleRecipientArgs) ToGetEscalationRuleRecipientOutput() GetEscalationRuleRecipientOutput

func (GetEscalationRuleRecipientArgs) ToGetEscalationRuleRecipientOutputWithContext 

func (i GetEscalationRuleRecipientArgs) ToGetEscalationRuleRecipientOutputWithContext(ctx context.Context) GetEscalationRuleRecipientOutput

type GetEscalationRuleRecipientArray 

type GetEscalationRuleRecipientArray []GetEscalationRuleRecipientInput

func (GetEscalationRuleRecipientArray) ElementType 

func (GetEscalationRuleRecipientArray) ElementType() reflect.Type

func (GetEscalationRuleRecipientArray) ToGetEscalationRuleRecipientArrayOutput 

func (i GetEscalationRuleRecipientArray) ToGetEscalationRuleRecipientArrayOutput() GetEscalationRuleRecipientArrayOutput

func (GetEscalationRuleRecipientArray) ToGetEscalationRuleRecipientArrayOutputWithContext 

func (i GetEscalationRuleRecipientArray) ToGetEscalationRuleRecipientArrayOutputWithContext(ctx context.Context) GetEscalationRuleRecipientArrayOutput

type GetEscalationRuleRecipientArrayInput 

type GetEscalationRuleRecipientArrayInput interface {
	pulumi.Input

	ToGetEscalationRuleRecipientArrayOutput() GetEscalationRuleRecipientArrayOutput
	ToGetEscalationRuleRecipientArrayOutputWithContext(context.Context) GetEscalationRuleRecipientArrayOutput
}

GetEscalationRuleRecipientArrayInput is an input type that accepts GetEscalationRuleRecipientArray and GetEscalationRuleRecipientArrayOutput values. You can construct a concrete instance of `GetEscalationRuleRecipientArrayInput` via: 

GetEscalationRuleRecipientArray{ GetEscalationRuleRecipientArgs{...} }

type GetEscalationRuleRecipientArrayOutput 

type GetEscalationRuleRecipientArrayOutput struct{ *pulumi.OutputState }

func (GetEscalationRuleRecipientArrayOutput) ElementType 

func (GetEscalationRuleRecipientArrayOutput) ElementType() reflect.Type

func (GetEscalationRuleRecipientArrayOutput) Index 

func (o GetEscalationRuleRecipientArrayOutput) Index(i pulumi.IntInput) GetEscalationRuleRecipientOutput

func (GetEscalationRuleRecipientArrayOutput) ToGetEscalationRuleRecipientArrayOutput 

func (o GetEscalationRuleRecipientArrayOutput) ToGetEscalationRuleRecipientArrayOutput() GetEscalationRuleRecipientArrayOutput

func (GetEscalationRuleRecipientArrayOutput) ToGetEscalationRuleRecipientArrayOutputWithContext 

func (o GetEscalationRuleRecipientArrayOutput) ToGetEscalationRuleRecipientArrayOutputWithContext(ctx context.Context) GetEscalationRuleRecipientArrayOutput

type GetEscalationRuleRecipientInput 

type GetEscalationRuleRecipientInput interface {
	pulumi.Input

	ToGetEscalationRuleRecipientOutput() GetEscalationRuleRecipientOutput
	ToGetEscalationRuleRecipientOutputWithContext(context.Context) GetEscalationRuleRecipientOutput
}

GetEscalationRuleRecipientInput is an input type that accepts GetEscalationRuleRecipientArgs and GetEscalationRuleRecipientOutput values. You can construct a concrete instance of `GetEscalationRuleRecipientInput` via: 

GetEscalationRuleRecipientArgs{...}

type GetEscalationRuleRecipientOutput 

type GetEscalationRuleRecipientOutput struct{ *pulumi.OutputState }

func (GetEscalationRuleRecipientOutput) ElementType 

func (GetEscalationRuleRecipientOutput) ElementType() reflect.Type

func (GetEscalationRuleRecipientOutput) Id 

func (o GetEscalationRuleRecipientOutput) Id() pulumi.StringPtrOutput

The ID of the Opsgenie Escalation.

func (GetEscalationRuleRecipientOutput) ToGetEscalationRuleRecipientOutput 

func (o GetEscalationRuleRecipientOutput) ToGetEscalationRuleRecipientOutput() GetEscalationRuleRecipientOutput

func (GetEscalationRuleRecipientOutput) ToGetEscalationRuleRecipientOutputWithContext 

func (o GetEscalationRuleRecipientOutput) ToGetEscalationRuleRecipientOutputWithContext(ctx context.Context) GetEscalationRuleRecipientOutput

func (GetEscalationRuleRecipientOutput) Type 

func (o GetEscalationRuleRecipientOutput) Type() pulumi.StringPtrOutput

type GetTeamMember 

type GetTeamMember struct {
	// The ID of the Opsgenie Team.
	Id       *string `pulumi:"id"`
	Role     *string `pulumi:"role"`
	Username *string `pulumi:"username"`
}

type GetTeamMemberArgs 

type GetTeamMemberArgs struct {
	// The ID of the Opsgenie Team.
	Id       pulumi.StringPtrInput `pulumi:"id"`
	Role     pulumi.StringPtrInput `pulumi:"role"`
	Username pulumi.StringPtrInput `pulumi:"username"`
}

func (GetTeamMemberArgs) ElementType 

func (GetTeamMemberArgs) ElementType() reflect.Type

func (GetTeamMemberArgs) ToGetTeamMemberOutput 

func (i GetTeamMemberArgs) ToGetTeamMemberOutput() GetTeamMemberOutput

func (GetTeamMemberArgs) ToGetTeamMemberOutputWithContext 

func (i GetTeamMemberArgs) ToGetTeamMemberOutputWithContext(ctx context.Context) GetTeamMemberOutput

type GetTeamMemberArray 

type GetTeamMemberArray []GetTeamMemberInput

func (GetTeamMemberArray) ElementType 

func (GetTeamMemberArray) ElementType() reflect.Type

func (GetTeamMemberArray) ToGetTeamMemberArrayOutput 

func (i GetTeamMemberArray) ToGetTeamMemberArrayOutput() GetTeamMemberArrayOutput

func (GetTeamMemberArray) ToGetTeamMemberArrayOutputWithContext 

func (i GetTeamMemberArray) ToGetTeamMemberArrayOutputWithContext(ctx context.Context) GetTeamMemberArrayOutput

type GetTeamMemberArrayInput 

type GetTeamMemberArrayInput interface {
	pulumi.Input

	ToGetTeamMemberArrayOutput() GetTeamMemberArrayOutput
	ToGetTeamMemberArrayOutputWithContext(context.Context) GetTeamMemberArrayOutput
}

GetTeamMemberArrayInput is an input type that accepts GetTeamMemberArray and GetTeamMemberArrayOutput values. You can construct a concrete instance of `GetTeamMemberArrayInput` via: 

GetTeamMemberArray{ GetTeamMemberArgs{...} }

type GetTeamMemberArrayOutput 

type GetTeamMemberArrayOutput struct{ *pulumi.OutputState }

func (GetTeamMemberArrayOutput) ElementType 

func (GetTeamMemberArrayOutput) ElementType() reflect.Type

func (GetTeamMemberArrayOutput) Index 

func (o GetTeamMemberArrayOutput) Index(i pulumi.IntInput) GetTeamMemberOutput

func (GetTeamMemberArrayOutput) ToGetTeamMemberArrayOutput 

func (o GetTeamMemberArrayOutput) ToGetTeamMemberArrayOutput() GetTeamMemberArrayOutput

func (GetTeamMemberArrayOutput) ToGetTeamMemberArrayOutputWithContext 

func (o GetTeamMemberArrayOutput) ToGetTeamMemberArrayOutputWithContext(ctx context.Context) GetTeamMemberArrayOutput

type GetTeamMemberInput 

type GetTeamMemberInput interface {
	pulumi.Input

	ToGetTeamMemberOutput() GetTeamMemberOutput
	ToGetTeamMemberOutputWithContext(context.Context) GetTeamMemberOutput
}

GetTeamMemberInput is an input type that accepts GetTeamMemberArgs and GetTeamMemberOutput values. You can construct a concrete instance of `GetTeamMemberInput` via: 

GetTeamMemberArgs{...}

type GetTeamMemberOutput 

type GetTeamMemberOutput struct{ *pulumi.OutputState }

func (GetTeamMemberOutput) ElementType 

func (GetTeamMemberOutput) ElementType() reflect.Type

func (GetTeamMemberOutput) Id 

func (o GetTeamMemberOutput) Id() pulumi.StringPtrOutput

The ID of the Opsgenie Team.

func (GetTeamMemberOutput) Role 

func (o GetTeamMemberOutput) Role() pulumi.StringPtrOutput

func (GetTeamMemberOutput) ToGetTeamMemberOutput 

func (o GetTeamMemberOutput) ToGetTeamMemberOutput() GetTeamMemberOutput

func (GetTeamMemberOutput) ToGetTeamMemberOutputWithContext 

func (o GetTeamMemberOutput) ToGetTeamMemberOutputWithContext(ctx context.Context) GetTeamMemberOutput

func (GetTeamMemberOutput) Username added in v1.3.1 

func (o GetTeamMemberOutput) Username() pulumi.StringPtrOutput

type Heartbeat 

type Heartbeat struct {
	pulumi.CustomResourceState

	// Specifies the alert message for heartbeat expiration alert. If this is not provided, default alert message is "HeartbeatName is expired".
	AlertMessage pulumi.StringPtrOutput `pulumi:"alertMessage"`
	// Specifies the alert priority for heartbeat expiration alert. If this is not provided, default priority is P3.
	AlertPriority pulumi.StringPtrOutput `pulumi:"alertPriority"`
	// Specifies the alert tags for heartbeat expiration alert.
	AlertTags pulumi.StringArrayOutput `pulumi:"alertTags"`
	// An optional description of the heartbeat
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Enable/disable heartbeat monitoring.
	Enabled pulumi.BoolOutput `pulumi:"enabled"`
	// Specifies how often a heartbeat message should be expected.
	Interval pulumi.IntOutput `pulumi:"interval"`
	// Interval specified as minutes, hours or days.
	IntervalUnit pulumi.StringOutput `pulumi:"intervalUnit"`
	// Name of the heartbeat
	Name pulumi.StringOutput `pulumi:"name"`
	// Owner team of the heartbeat.
	OwnerTeamId pulumi.StringPtrOutput `pulumi:"ownerTeamId"`
}

Manages heartbeat within Opsgenie.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opsgenie.NewHeartbeat(ctx, "test", &opsgenie.HeartbeatArgs{
			Name:          pulumi.String("genieheartbeat-test"),
			Description:   pulumi.String("test opsgenie heartbeat terraform"),
			IntervalUnit:  pulumi.String("minutes"),
			Interval:      pulumi.Int(10),
			Enabled:       pulumi.Bool(false),
			AlertMessage:  pulumi.String("Test"),
			AlertPriority: pulumi.String("P3"),
			AlertTags: pulumi.StringArray{
				pulumi.String("test"),
				pulumi.String("fahri"),
			},
			OwnerTeamId: pulumi.Any(testOpsgenieTeam.Id),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Heartbeat Integrations can be imported using the `name`, e.g.

```sh $ pulumi import opsgenie:index/heartbeat:Heartbeat test name` ```

func GetHeartbeat 

func GetHeartbeat(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *HeartbeatState, opts ...pulumi.ResourceOption) (*Heartbeat, error)

GetHeartbeat gets an existing Heartbeat resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewHeartbeat 

func NewHeartbeat(ctx *pulumi.Context,
	name string, args *HeartbeatArgs, opts ...pulumi.ResourceOption) (*Heartbeat, error)

NewHeartbeat registers a new resource with the given unique name, arguments, and options.

func (*Heartbeat) ElementType 

func (*Heartbeat) ElementType() reflect.Type

func (*Heartbeat) ToHeartbeatOutput 

func (i *Heartbeat) ToHeartbeatOutput() HeartbeatOutput

func (*Heartbeat) ToHeartbeatOutputWithContext 

func (i *Heartbeat) ToHeartbeatOutputWithContext(ctx context.Context) HeartbeatOutput

type HeartbeatArgs 

type HeartbeatArgs struct {
	// Specifies the alert message for heartbeat expiration alert. If this is not provided, default alert message is "HeartbeatName is expired".
	AlertMessage pulumi.StringPtrInput
	// Specifies the alert priority for heartbeat expiration alert. If this is not provided, default priority is P3.
	AlertPriority pulumi.StringPtrInput
	// Specifies the alert tags for heartbeat expiration alert.
	AlertTags pulumi.StringArrayInput
	// An optional description of the heartbeat
	Description pulumi.StringPtrInput
	// Enable/disable heartbeat monitoring.
	Enabled pulumi.BoolInput
	// Specifies how often a heartbeat message should be expected.
	Interval pulumi.IntInput
	// Interval specified as minutes, hours or days.
	IntervalUnit pulumi.StringInput
	// Name of the heartbeat
	Name pulumi.StringPtrInput
	// Owner team of the heartbeat.
	OwnerTeamId pulumi.StringPtrInput
}

The set of arguments for constructing a Heartbeat resource.

func (HeartbeatArgs) ElementType 

func (HeartbeatArgs) ElementType() reflect.Type

type HeartbeatArray added in v0.1.3 

type HeartbeatArray []HeartbeatInput

func (HeartbeatArray) ElementType added in v0.1.3 

func (HeartbeatArray) ElementType() reflect.Type

func (HeartbeatArray) ToHeartbeatArrayOutput added in v0.1.3 

func (i HeartbeatArray) ToHeartbeatArrayOutput() HeartbeatArrayOutput

func (HeartbeatArray) ToHeartbeatArrayOutputWithContext added in v0.1.3 

func (i HeartbeatArray) ToHeartbeatArrayOutputWithContext(ctx context.Context) HeartbeatArrayOutput

type HeartbeatArrayInput added in v0.1.3 

type HeartbeatArrayInput interface {
	pulumi.Input

	ToHeartbeatArrayOutput() HeartbeatArrayOutput
	ToHeartbeatArrayOutputWithContext(context.Context) HeartbeatArrayOutput
}

HeartbeatArrayInput is an input type that accepts HeartbeatArray and HeartbeatArrayOutput values. You can construct a concrete instance of `HeartbeatArrayInput` via: 

HeartbeatArray{ HeartbeatArgs{...} }

type HeartbeatArrayOutput added in v0.1.3 

type HeartbeatArrayOutput struct{ *pulumi.OutputState }

func (HeartbeatArrayOutput) ElementType added in v0.1.3 

func (HeartbeatArrayOutput) ElementType() reflect.Type

func (HeartbeatArrayOutput) Index added in v0.1.3 

func (o HeartbeatArrayOutput) Index(i pulumi.IntInput) HeartbeatOutput

func (HeartbeatArrayOutput) ToHeartbeatArrayOutput added in v0.1.3 

func (o HeartbeatArrayOutput) ToHeartbeatArrayOutput() HeartbeatArrayOutput

func (HeartbeatArrayOutput) ToHeartbeatArrayOutputWithContext added in v0.1.3 

func (o HeartbeatArrayOutput) ToHeartbeatArrayOutputWithContext(ctx context.Context) HeartbeatArrayOutput

type HeartbeatInput 

type HeartbeatInput interface {
	pulumi.Input

	ToHeartbeatOutput() HeartbeatOutput
	ToHeartbeatOutputWithContext(ctx context.Context) HeartbeatOutput
}

type HeartbeatMap added in v0.1.3 

type HeartbeatMap map[string]HeartbeatInput

func (HeartbeatMap) ElementType added in v0.1.3 

func (HeartbeatMap) ElementType() reflect.Type

func (HeartbeatMap) ToHeartbeatMapOutput added in v0.1.3 

func (i HeartbeatMap) ToHeartbeatMapOutput() HeartbeatMapOutput

func (HeartbeatMap) ToHeartbeatMapOutputWithContext added in v0.1.3 

func (i HeartbeatMap) ToHeartbeatMapOutputWithContext(ctx context.Context) HeartbeatMapOutput

type HeartbeatMapInput added in v0.1.3 

type HeartbeatMapInput interface {
	pulumi.Input

	ToHeartbeatMapOutput() HeartbeatMapOutput
	ToHeartbeatMapOutputWithContext(context.Context) HeartbeatMapOutput
}

HeartbeatMapInput is an input type that accepts HeartbeatMap and HeartbeatMapOutput values. You can construct a concrete instance of `HeartbeatMapInput` via: 

HeartbeatMap{ "key": HeartbeatArgs{...} }

type HeartbeatMapOutput added in v0.1.3 

type HeartbeatMapOutput struct{ *pulumi.OutputState }

func (HeartbeatMapOutput) ElementType added in v0.1.3 

func (HeartbeatMapOutput) ElementType() reflect.Type

func (HeartbeatMapOutput) MapIndex added in v0.1.3 

func (o HeartbeatMapOutput) MapIndex(k pulumi.StringInput) HeartbeatOutput

func (HeartbeatMapOutput) ToHeartbeatMapOutput added in v0.1.3 

func (o HeartbeatMapOutput) ToHeartbeatMapOutput() HeartbeatMapOutput

func (HeartbeatMapOutput) ToHeartbeatMapOutputWithContext added in v0.1.3 

func (o HeartbeatMapOutput) ToHeartbeatMapOutputWithContext(ctx context.Context) HeartbeatMapOutput

type HeartbeatOutput 

type HeartbeatOutput struct{ *pulumi.OutputState }

func (HeartbeatOutput) AlertMessage added in v1.1.9 

func (o HeartbeatOutput) AlertMessage() pulumi.StringPtrOutput

Specifies the alert message for heartbeat expiration alert. If this is not provided, default alert message is "HeartbeatName is expired".

func (HeartbeatOutput) AlertPriority added in v1.1.9 

func (o HeartbeatOutput) AlertPriority() pulumi.StringPtrOutput

Specifies the alert priority for heartbeat expiration alert. If this is not provided, default priority is P3.

func (HeartbeatOutput) AlertTags added in v1.1.9 

func (o HeartbeatOutput) AlertTags() pulumi.StringArrayOutput

Specifies the alert tags for heartbeat expiration alert.

func (HeartbeatOutput) Description added in v1.1.9 

func (o HeartbeatOutput) Description() pulumi.StringPtrOutput

An optional description of the heartbeat

func (HeartbeatOutput) ElementType 

func (HeartbeatOutput) ElementType() reflect.Type

func (HeartbeatOutput) Enabled added in v1.1.9 

func (o HeartbeatOutput) Enabled() pulumi.BoolOutput

Enable/disable heartbeat monitoring.

func (HeartbeatOutput) Interval added in v1.1.9 

func (o HeartbeatOutput) Interval() pulumi.IntOutput

Specifies how often a heartbeat message should be expected.

func (HeartbeatOutput) IntervalUnit added in v1.1.9 

func (o HeartbeatOutput) IntervalUnit() pulumi.StringOutput

Interval specified as minutes, hours or days.

func (HeartbeatOutput) Name added in v1.1.9 

func (o HeartbeatOutput) Name() pulumi.StringOutput

Name of the heartbeat

func (HeartbeatOutput) OwnerTeamId added in v1.1.9 

func (o HeartbeatOutput) OwnerTeamId() pulumi.StringPtrOutput

Owner team of the heartbeat.

func (HeartbeatOutput) ToHeartbeatOutput 

func (o HeartbeatOutput) ToHeartbeatOutput() HeartbeatOutput

func (HeartbeatOutput) ToHeartbeatOutputWithContext 

func (o HeartbeatOutput) ToHeartbeatOutputWithContext(ctx context.Context) HeartbeatOutput

type HeartbeatState 

type HeartbeatState struct {
	// Specifies the alert message for heartbeat expiration alert. If this is not provided, default alert message is "HeartbeatName is expired".
	AlertMessage pulumi.StringPtrInput
	// Specifies the alert priority for heartbeat expiration alert. If this is not provided, default priority is P3.
	AlertPriority pulumi.StringPtrInput
	// Specifies the alert tags for heartbeat expiration alert.
	AlertTags pulumi.StringArrayInput
	// An optional description of the heartbeat
	Description pulumi.StringPtrInput
	// Enable/disable heartbeat monitoring.
	Enabled pulumi.BoolPtrInput
	// Specifies how often a heartbeat message should be expected.
	Interval pulumi.IntPtrInput
	// Interval specified as minutes, hours or days.
	IntervalUnit pulumi.StringPtrInput
	// Name of the heartbeat
	Name pulumi.StringPtrInput
	// Owner team of the heartbeat.
	OwnerTeamId pulumi.StringPtrInput
}

func (HeartbeatState) ElementType 

func (HeartbeatState) ElementType() reflect.Type

type IncidentTemplate 

type IncidentTemplate struct {
	pulumi.CustomResourceState

	// Description field of the incident template. This field must not be longer than 10000 characters.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Map of key-value pairs to use as custom properties of the incident template. This field must not be longer than 8000 characters.
	Details          pulumi.StringMapOutput   `pulumi:"details"`
	ImpactedServices pulumi.StringArrayOutput `pulumi:"impactedServices"`
	// Message of the related incident template. This field must not be longer than 130 characters.
	Message pulumi.StringOutput `pulumi:"message"`
	// Name of the incident template.
	Name pulumi.StringOutput `pulumi:"name"`
	// Priority level of the incident. Possible values are `P1`, `P2`, `P3`, `P4` and `P5`.
	Priority              pulumi.StringOutput                            `pulumi:"priority"`
	StakeholderProperties IncidentTemplateStakeholderPropertyArrayOutput `pulumi:"stakeholderProperties"`
	// Tags of the incident template.
	Tags pulumi.StringArrayOutput `pulumi:"tags"`
}

Manages an Incident Template within Opsgenie.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		test, err := opsgenie.NewTeam(ctx, "test", &opsgenie.TeamArgs{
			Name:        pulumi.String("genietest-team"),
			Description: pulumi.String("This team deals with all the things"),
		})
		if err != nil {
			return err
		}
		testService, err := opsgenie.NewService(ctx, "test", &opsgenie.ServiceArgs{
			Name:   pulumi.String("genietest-service"),
			TeamId: test.ID(),
		})
		if err != nil {
			return err
		}
		_, err = opsgenie.NewIncidentTemplate(ctx, "test", &opsgenie.IncidentTemplateArgs{
			Name:     pulumi.String("genietest-incident-template"),
			Message:  pulumi.String("Incident Message"),
			Priority: pulumi.String("P2"),
			StakeholderProperties: opsgenie.IncidentTemplateStakeholderPropertyArray{
				&opsgenie.IncidentTemplateStakeholderPropertyArgs{
					Enable:      pulumi.Bool(true),
					Message:     pulumi.String("Stakeholder Message"),
					Description: pulumi.String("Stakeholder Description"),
				},
			},
			Tags: pulumi.StringArray{
				pulumi.String("tag1"),
				pulumi.String("tag2"),
			},
			Description: pulumi.String("Incident Description"),
			Details: pulumi.StringMap{
				"key1": pulumi.String("value1"),
				"key2": pulumi.String("value2"),
			},
			ImpactedServices: pulumi.StringArray{
				testService.ID(),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Service can be imported using the `template_id`, e.g.

```sh $ pulumi import opsgenie:index/incidentTemplate:IncidentTemplate test template_id` ```

func GetIncidentTemplate 

func GetIncidentTemplate(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *IncidentTemplateState, opts ...pulumi.ResourceOption) (*IncidentTemplate, error)

GetIncidentTemplate gets an existing IncidentTemplate resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewIncidentTemplate 

func NewIncidentTemplate(ctx *pulumi.Context,
	name string, args *IncidentTemplateArgs, opts ...pulumi.ResourceOption) (*IncidentTemplate, error)

NewIncidentTemplate registers a new resource with the given unique name, arguments, and options.

func (*IncidentTemplate) ElementType 

func (*IncidentTemplate) ElementType() reflect.Type

func (*IncidentTemplate) ToIncidentTemplateOutput 

func (i *IncidentTemplate) ToIncidentTemplateOutput() IncidentTemplateOutput

func (*IncidentTemplate) ToIncidentTemplateOutputWithContext 

func (i *IncidentTemplate) ToIncidentTemplateOutputWithContext(ctx context.Context) IncidentTemplateOutput

type IncidentTemplateArgs 

type IncidentTemplateArgs struct {
	// Description field of the incident template. This field must not be longer than 10000 characters.
	Description pulumi.StringPtrInput
	// Map of key-value pairs to use as custom properties of the incident template. This field must not be longer than 8000 characters.
	Details          pulumi.StringMapInput
	ImpactedServices pulumi.StringArrayInput
	// Message of the related incident template. This field must not be longer than 130 characters.
	Message pulumi.StringInput
	// Name of the incident template.
	Name pulumi.StringPtrInput
	// Priority level of the incident. Possible values are `P1`, `P2`, `P3`, `P4` and `P5`.
	Priority              pulumi.StringInput
	StakeholderProperties IncidentTemplateStakeholderPropertyArrayInput
	// Tags of the incident template.
	Tags pulumi.StringArrayInput
}

The set of arguments for constructing a IncidentTemplate resource.

func (IncidentTemplateArgs) ElementType 

func (IncidentTemplateArgs) ElementType() reflect.Type

type IncidentTemplateArray added in v0.1.3 

type IncidentTemplateArray []IncidentTemplateInput

func (IncidentTemplateArray) ElementType added in v0.1.3 

func (IncidentTemplateArray) ElementType() reflect.Type

func (IncidentTemplateArray) ToIncidentTemplateArrayOutput added in v0.1.3 

func (i IncidentTemplateArray) ToIncidentTemplateArrayOutput() IncidentTemplateArrayOutput

func (IncidentTemplateArray) ToIncidentTemplateArrayOutputWithContext added in v0.1.3 

func (i IncidentTemplateArray) ToIncidentTemplateArrayOutputWithContext(ctx context.Context) IncidentTemplateArrayOutput

type IncidentTemplateArrayInput added in v0.1.3 

type IncidentTemplateArrayInput interface {
	pulumi.Input

	ToIncidentTemplateArrayOutput() IncidentTemplateArrayOutput
	ToIncidentTemplateArrayOutputWithContext(context.Context) IncidentTemplateArrayOutput
}

IncidentTemplateArrayInput is an input type that accepts IncidentTemplateArray and IncidentTemplateArrayOutput values. You can construct a concrete instance of `IncidentTemplateArrayInput` via: 

IncidentTemplateArray{ IncidentTemplateArgs{...} }

type IncidentTemplateArrayOutput added in v0.1.3 

type IncidentTemplateArrayOutput struct{ *pulumi.OutputState }

func (IncidentTemplateArrayOutput) ElementType added in v0.1.3 

func (IncidentTemplateArrayOutput) ElementType() reflect.Type

func (IncidentTemplateArrayOutput) Index added in v0.1.3 

func (o IncidentTemplateArrayOutput) Index(i pulumi.IntInput) IncidentTemplateOutput

func (IncidentTemplateArrayOutput) ToIncidentTemplateArrayOutput added in v0.1.3 

func (o IncidentTemplateArrayOutput) ToIncidentTemplateArrayOutput() IncidentTemplateArrayOutput

func (IncidentTemplateArrayOutput) ToIncidentTemplateArrayOutputWithContext added in v0.1.3 

func (o IncidentTemplateArrayOutput) ToIncidentTemplateArrayOutputWithContext(ctx context.Context) IncidentTemplateArrayOutput

type IncidentTemplateInput 

type IncidentTemplateInput interface {
	pulumi.Input

	ToIncidentTemplateOutput() IncidentTemplateOutput
	ToIncidentTemplateOutputWithContext(ctx context.Context) IncidentTemplateOutput
}

type IncidentTemplateMap added in v0.1.3 

type IncidentTemplateMap map[string]IncidentTemplateInput

func (IncidentTemplateMap) ElementType added in v0.1.3 

func (IncidentTemplateMap) ElementType() reflect.Type

func (IncidentTemplateMap) ToIncidentTemplateMapOutput added in v0.1.3 

func (i IncidentTemplateMap) ToIncidentTemplateMapOutput() IncidentTemplateMapOutput

func (IncidentTemplateMap) ToIncidentTemplateMapOutputWithContext added in v0.1.3 

func (i IncidentTemplateMap) ToIncidentTemplateMapOutputWithContext(ctx context.Context) IncidentTemplateMapOutput

type IncidentTemplateMapInput added in v0.1.3 

type IncidentTemplateMapInput interface {
	pulumi.Input

	ToIncidentTemplateMapOutput() IncidentTemplateMapOutput
	ToIncidentTemplateMapOutputWithContext(context.Context) IncidentTemplateMapOutput
}

IncidentTemplateMapInput is an input type that accepts IncidentTemplateMap and IncidentTemplateMapOutput values. You can construct a concrete instance of `IncidentTemplateMapInput` via: 

IncidentTemplateMap{ "key": IncidentTemplateArgs{...} }

type IncidentTemplateMapOutput added in v0.1.3 

type IncidentTemplateMapOutput struct{ *pulumi.OutputState }

func (IncidentTemplateMapOutput) ElementType added in v0.1.3 

func (IncidentTemplateMapOutput) ElementType() reflect.Type

func (IncidentTemplateMapOutput) MapIndex added in v0.1.3 

func (o IncidentTemplateMapOutput) MapIndex(k pulumi.StringInput) IncidentTemplateOutput

func (IncidentTemplateMapOutput) ToIncidentTemplateMapOutput added in v0.1.3 

func (o IncidentTemplateMapOutput) ToIncidentTemplateMapOutput() IncidentTemplateMapOutput

func (IncidentTemplateMapOutput) ToIncidentTemplateMapOutputWithContext added in v0.1.3 

func (o IncidentTemplateMapOutput) ToIncidentTemplateMapOutputWithContext(ctx context.Context) IncidentTemplateMapOutput

type IncidentTemplateOutput 

type IncidentTemplateOutput struct{ *pulumi.OutputState }

func (IncidentTemplateOutput) Description added in v1.1.9 

func (o IncidentTemplateOutput) Description() pulumi.StringPtrOutput

Description field of the incident template. This field must not be longer than 10000 characters.

func (IncidentTemplateOutput) Details added in v1.1.9 

func (o IncidentTemplateOutput) Details() pulumi.StringMapOutput

Map of key-value pairs to use as custom properties of the incident template. This field must not be longer than 8000 characters.

func (IncidentTemplateOutput) ElementType 

func (IncidentTemplateOutput) ElementType() reflect.Type

func (IncidentTemplateOutput) ImpactedServices added in v1.1.9 

func (o IncidentTemplateOutput) ImpactedServices() pulumi.StringArrayOutput

func (IncidentTemplateOutput) Message added in v1.1.9 

func (o IncidentTemplateOutput) Message() pulumi.StringOutput

Message of the related incident template. This field must not be longer than 130 characters.

func (IncidentTemplateOutput) Name added in v1.1.9 

func (o IncidentTemplateOutput) Name() pulumi.StringOutput

Name of the incident template.

func (IncidentTemplateOutput) Priority added in v1.1.9 

func (o IncidentTemplateOutput) Priority() pulumi.StringOutput

Priority level of the incident. Possible values are `P1`, `P2`, `P3`, `P4` and `P5`.

func (IncidentTemplateOutput) StakeholderProperties added in v1.1.9 

func (o IncidentTemplateOutput) StakeholderProperties() IncidentTemplateStakeholderPropertyArrayOutput

func (IncidentTemplateOutput) Tags added in v1.1.9 

func (o IncidentTemplateOutput) Tags() pulumi.StringArrayOutput

Tags of the incident template.

func (IncidentTemplateOutput) ToIncidentTemplateOutput 

func (o IncidentTemplateOutput) ToIncidentTemplateOutput() IncidentTemplateOutput

func (IncidentTemplateOutput) ToIncidentTemplateOutputWithContext 

func (o IncidentTemplateOutput) ToIncidentTemplateOutputWithContext(ctx context.Context) IncidentTemplateOutput

type IncidentTemplateStakeholderProperty 

type IncidentTemplateStakeholderProperty struct {
	// Description field of the incident template. This field must not be longer than 10000 characters.
	Description *string `pulumi:"description"`
	Enable      *bool   `pulumi:"enable"`
	// Message of the related incident template. This field must not be longer than 130 characters.
	Message string `pulumi:"message"`
}

type IncidentTemplateStakeholderPropertyArgs 

type IncidentTemplateStakeholderPropertyArgs struct {
	// Description field of the incident template. This field must not be longer than 10000 characters.
	Description pulumi.StringPtrInput `pulumi:"description"`
	Enable      pulumi.BoolPtrInput   `pulumi:"enable"`
	// Message of the related incident template. This field must not be longer than 130 characters.
	Message pulumi.StringInput `pulumi:"message"`
}

func (IncidentTemplateStakeholderPropertyArgs) ElementType 

func (IncidentTemplateStakeholderPropertyArgs) ElementType() reflect.Type

func (IncidentTemplateStakeholderPropertyArgs) ToIncidentTemplateStakeholderPropertyOutput 

func (i IncidentTemplateStakeholderPropertyArgs) ToIncidentTemplateStakeholderPropertyOutput() IncidentTemplateStakeholderPropertyOutput

func (IncidentTemplateStakeholderPropertyArgs) ToIncidentTemplateStakeholderPropertyOutputWithContext 

func (i IncidentTemplateStakeholderPropertyArgs) ToIncidentTemplateStakeholderPropertyOutputWithContext(ctx context.Context) IncidentTemplateStakeholderPropertyOutput

type IncidentTemplateStakeholderPropertyArray 

type IncidentTemplateStakeholderPropertyArray []IncidentTemplateStakeholderPropertyInput

func (IncidentTemplateStakeholderPropertyArray) ElementType 

func (IncidentTemplateStakeholderPropertyArray) ElementType() reflect.Type

func (IncidentTemplateStakeholderPropertyArray) ToIncidentTemplateStakeholderPropertyArrayOutput 

func (i IncidentTemplateStakeholderPropertyArray) ToIncidentTemplateStakeholderPropertyArrayOutput() IncidentTemplateStakeholderPropertyArrayOutput

func (IncidentTemplateStakeholderPropertyArray) ToIncidentTemplateStakeholderPropertyArrayOutputWithContext 

func (i IncidentTemplateStakeholderPropertyArray) ToIncidentTemplateStakeholderPropertyArrayOutputWithContext(ctx context.Context) IncidentTemplateStakeholderPropertyArrayOutput

type IncidentTemplateStakeholderPropertyArrayInput 

type IncidentTemplateStakeholderPropertyArrayInput interface {
	pulumi.Input

	ToIncidentTemplateStakeholderPropertyArrayOutput() IncidentTemplateStakeholderPropertyArrayOutput
	ToIncidentTemplateStakeholderPropertyArrayOutputWithContext(context.Context) IncidentTemplateStakeholderPropertyArrayOutput
}

IncidentTemplateStakeholderPropertyArrayInput is an input type that accepts IncidentTemplateStakeholderPropertyArray and IncidentTemplateStakeholderPropertyArrayOutput values. You can construct a concrete instance of `IncidentTemplateStakeholderPropertyArrayInput` via: 

IncidentTemplateStakeholderPropertyArray{ IncidentTemplateStakeholderPropertyArgs{...} }

type IncidentTemplateStakeholderPropertyArrayOutput 

type IncidentTemplateStakeholderPropertyArrayOutput struct{ *pulumi.OutputState }

func (IncidentTemplateStakeholderPropertyArrayOutput) ElementType 

func (IncidentTemplateStakeholderPropertyArrayOutput) ElementType() reflect.Type

func (IncidentTemplateStakeholderPropertyArrayOutput) Index 

func (o IncidentTemplateStakeholderPropertyArrayOutput) Index(i pulumi.IntInput) IncidentTemplateStakeholderPropertyOutput

func (IncidentTemplateStakeholderPropertyArrayOutput) ToIncidentTemplateStakeholderPropertyArrayOutput 

func (o IncidentTemplateStakeholderPropertyArrayOutput) ToIncidentTemplateStakeholderPropertyArrayOutput() IncidentTemplateStakeholderPropertyArrayOutput

func (IncidentTemplateStakeholderPropertyArrayOutput) ToIncidentTemplateStakeholderPropertyArrayOutputWithContext 

func (o IncidentTemplateStakeholderPropertyArrayOutput) ToIncidentTemplateStakeholderPropertyArrayOutputWithContext(ctx context.Context) IncidentTemplateStakeholderPropertyArrayOutput

type IncidentTemplateStakeholderPropertyInput 

type IncidentTemplateStakeholderPropertyInput interface {
	pulumi.Input

	ToIncidentTemplateStakeholderPropertyOutput() IncidentTemplateStakeholderPropertyOutput
	ToIncidentTemplateStakeholderPropertyOutputWithContext(context.Context) IncidentTemplateStakeholderPropertyOutput
}

IncidentTemplateStakeholderPropertyInput is an input type that accepts IncidentTemplateStakeholderPropertyArgs and IncidentTemplateStakeholderPropertyOutput values. You can construct a concrete instance of `IncidentTemplateStakeholderPropertyInput` via: 

IncidentTemplateStakeholderPropertyArgs{...}

type IncidentTemplateStakeholderPropertyOutput 

type IncidentTemplateStakeholderPropertyOutput struct{ *pulumi.OutputState }

func (IncidentTemplateStakeholderPropertyOutput) Description 

func (o IncidentTemplateStakeholderPropertyOutput) Description() pulumi.StringPtrOutput

Description field of the incident template. This field must not be longer than 10000 characters.

func (IncidentTemplateStakeholderPropertyOutput) ElementType 

func (IncidentTemplateStakeholderPropertyOutput) ElementType() reflect.Type

func (IncidentTemplateStakeholderPropertyOutput) Enable 

func (o IncidentTemplateStakeholderPropertyOutput) Enable() pulumi.BoolPtrOutput

func (IncidentTemplateStakeholderPropertyOutput) Message 

func (o IncidentTemplateStakeholderPropertyOutput) Message() pulumi.StringOutput

Message of the related incident template. This field must not be longer than 130 characters.

func (IncidentTemplateStakeholderPropertyOutput) ToIncidentTemplateStakeholderPropertyOutput 

func (o IncidentTemplateStakeholderPropertyOutput) ToIncidentTemplateStakeholderPropertyOutput() IncidentTemplateStakeholderPropertyOutput

func (IncidentTemplateStakeholderPropertyOutput) ToIncidentTemplateStakeholderPropertyOutputWithContext 

func (o IncidentTemplateStakeholderPropertyOutput) ToIncidentTemplateStakeholderPropertyOutputWithContext(ctx context.Context) IncidentTemplateStakeholderPropertyOutput

type IncidentTemplateState 

type IncidentTemplateState struct {
	// Description field of the incident template. This field must not be longer than 10000 characters.
	Description pulumi.StringPtrInput
	// Map of key-value pairs to use as custom properties of the incident template. This field must not be longer than 8000 characters.
	Details          pulumi.StringMapInput
	ImpactedServices pulumi.StringArrayInput
	// Message of the related incident template. This field must not be longer than 130 characters.
	Message pulumi.StringPtrInput
	// Name of the incident template.
	Name pulumi.StringPtrInput
	// Priority level of the incident. Possible values are `P1`, `P2`, `P3`, `P4` and `P5`.
	Priority              pulumi.StringPtrInput
	StakeholderProperties IncidentTemplateStakeholderPropertyArrayInput
	// Tags of the incident template.
	Tags pulumi.StringArrayInput
}

func (IncidentTemplateState) ElementType 

func (IncidentTemplateState) ElementType() reflect.Type

type IntegrationAction 

type IntegrationAction struct {
	pulumi.CustomResourceState

	Acknowledges IntegrationActionAcknowledgeArrayOutput `pulumi:"acknowledges"`
	AddNotes     IntegrationActionAddNoteArrayOutput     `pulumi:"addNotes"`
	Closes       IntegrationActionCloseArrayOutput       `pulumi:"closes"`
	Creates      IntegrationActionCreateArrayOutput      `pulumi:"creates"`
	Ignores      IntegrationActionIgnoreArrayOutput      `pulumi:"ignores"`
	// ID of the parent integration resource to bind to.
	IntegrationId pulumi.StringOutput `pulumi:"integrationId"`
}

Manages advanced actions for Integrations within Opsgenie. This applies for the following resources: * `ApiIntegration` * `EmailIntegration`

The actions that are supported are: * `create` * `close` * `acknowledge` * `addNote` * `ignore`

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
"github.com/pulumi/pulumi-std/sdk/go/std"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		invokeChomp, err := std.Chomp(ctx, &std.ChompArgs{
			Input: "This\nis a multiline\ndescription.\n",
		}, nil)
		if err != nil {
			return err
		}
		_, err = opsgenie.NewIntegrationAction(ctx, "test_action", &opsgenie.IntegrationActionArgs{
			IntegrationId: pulumi.Any(testOpsgenieApiIntegration.Id),
			Creates: opsgenie.IntegrationActionCreateArray{
				&opsgenie.IntegrationActionCreateArgs{
					Name: pulumi.String("create action"),
					Tags: pulumi.StringArray{
						pulumi.String("CRITICAL"),
						pulumi.String("SEV-0"),
					},
					User:        pulumi.String("Example-service"),
					Note:        pulumi.String("{{note}}"),
					Alias:       pulumi.String("{{alias}}"),
					Source:      pulumi.String("{{source}}"),
					Message:     pulumi.String("{{message}}"),
					Description: pulumi.String("{{description}}"),
					Entity:      pulumi.String("{{entity}}"),
					AlertActions: pulumi.StringArray{
						pulumi.String("Runbook ID#342"),
					},
					Filters: opsgenie.IntegrationActionCreateFilterArray{
						&opsgenie.IntegrationActionCreateFilterArgs{
							Type: pulumi.String("match-all-conditions"),
							Conditions: opsgenie.IntegrationActionCreateFilterConditionArray{
								&opsgenie.IntegrationActionCreateFilterConditionArgs{
									Field:         pulumi.String("priority"),
									Operation:     pulumi.String("equals"),
									ExpectedValue: pulumi.String("P1"),
								},
							},
						},
					},
					Responders: opsgenie.IntegrationActionCreateResponderArray{
						&opsgenie.IntegrationActionCreateResponderArgs{
							Id:   pulumi.Any(test.Id),
							Type: pulumi.String("team"),
						},
					},
				},
				&opsgenie.IntegrationActionCreateArgs{
					Name:        pulumi.String("create action with multiline description"),
					Message:     pulumi.String("{{message}}"),
					Description: invokeChomp.Result,
					Filters: opsgenie.IntegrationActionCreateFilterArray{
						&opsgenie.IntegrationActionCreateFilterArgs{
							Type: pulumi.String("match-all-conditions"),
							Conditions: opsgenie.IntegrationActionCreateFilterConditionArray{
								&opsgenie.IntegrationActionCreateFilterConditionArgs{
									Field:         pulumi.String("priority"),
									Operation:     pulumi.String("equals"),
									ExpectedValue: pulumi.String("P1"),
								},
							},
						},
					},
				},
				&opsgenie.IntegrationActionCreateArgs{
					Name: pulumi.String("Create medium priority alerts"),
					Tags: pulumi.StringArray{
						pulumi.String("SEVERE"),
						pulumi.String("SEV-1"),
					},
					Priority: pulumi.String("P3"),
					Filters: opsgenie.IntegrationActionCreateFilterArray{
						&opsgenie.IntegrationActionCreateFilterArgs{
							Type: pulumi.String("match-all-conditions"),
							Conditions: opsgenie.IntegrationActionCreateFilterConditionArray{
								&opsgenie.IntegrationActionCreateFilterConditionArgs{
									Field:         pulumi.String("priority"),
									Operation:     pulumi.String("equals"),
									ExpectedValue: pulumi.String("P2"),
								},
							},
						},
					},
				},
				&opsgenie.IntegrationActionCreateArgs{
					Name:           pulumi.String("Create alert with priority from message"),
					CustomPriority: pulumi.String("{{message.substringAfter(\"[custom]\")}}"),
					Filters: opsgenie.IntegrationActionCreateFilterArray{
						&opsgenie.IntegrationActionCreateFilterArgs{
							Type: pulumi.String("match-all-conditions"),
							Conditions: opsgenie.IntegrationActionCreateFilterConditionArray{
								&opsgenie.IntegrationActionCreateFilterConditionArgs{
									Field:         pulumi.String("tags"),
									Operation:     pulumi.String("contains"),
									ExpectedValue: pulumi.String("P5"),
								},
								&opsgenie.IntegrationActionCreateFilterConditionArgs{
									Field:         pulumi.String("message"),
									Operation:     pulumi.String("starts-with"),
									ExpectedValue: pulumi.String("[custom]"),
								},
							},
						},
					},
				},
			},
			Closes: opsgenie.IntegrationActionCloseArray{
				&opsgenie.IntegrationActionCloseArgs{
					Name: pulumi.String("Low priority alerts"),
					Filters: opsgenie.IntegrationActionCloseFilterArray{
						&opsgenie.IntegrationActionCloseFilterArgs{
							Type: pulumi.String("match-any-condition"),
							Conditions: opsgenie.IntegrationActionCloseFilterConditionArray{
								&opsgenie.IntegrationActionCloseFilterConditionArgs{
									Field:         pulumi.String("priority"),
									Operation:     pulumi.String("equals"),
									ExpectedValue: pulumi.String("P5"),
								},
								&opsgenie.IntegrationActionCloseFilterConditionArgs{
									Field:         pulumi.String("message"),
									Operation:     pulumi.String("contains"),
									ExpectedValue: pulumi.String("DEBUG"),
								},
							},
						},
					},
				},
			},
			Acknowledges: opsgenie.IntegrationActionAcknowledgeArray{
				&opsgenie.IntegrationActionAcknowledgeArgs{
					Name: pulumi.String("Auto-ack test alerts"),
					Filters: opsgenie.IntegrationActionAcknowledgeFilterArray{
						&opsgenie.IntegrationActionAcknowledgeFilterArgs{
							Type: pulumi.String("match-all-conditions"),
							Conditions: opsgenie.IntegrationActionAcknowledgeFilterConditionArray{
								&opsgenie.IntegrationActionAcknowledgeFilterConditionArgs{
									Field:         pulumi.String("message"),
									Not:           pulumi.Bool(true),
									Operation:     pulumi.String("contains"),
									ExpectedValue: pulumi.String("TEST"),
								},
								&opsgenie.IntegrationActionAcknowledgeFilterConditionArgs{
									Field:         pulumi.String("priority"),
									Operation:     pulumi.String("equals"),
									ExpectedValue: pulumi.String("P5"),
								},
							},
						},
					},
				},
			},
			AddNotes: opsgenie.IntegrationActionAddNoteArray{
				&opsgenie.IntegrationActionAddNoteArgs{
					Name: pulumi.String("Add note to all alerts"),
					Note: pulumi.String("Created from test integration"),
					Filters: opsgenie.IntegrationActionAddNoteFilterArray{
						&opsgenie.IntegrationActionAddNoteFilterArgs{
							Type: pulumi.String("match-all"),
						},
					},
				},
			},
			Ignores: opsgenie.IntegrationActionIgnoreArray{
				&opsgenie.IntegrationActionIgnoreArgs{
					Name: pulumi.String("Ignore alerts with ignore tag"),
					Filters: opsgenie.IntegrationActionIgnoreFilterArray{
						&opsgenie.IntegrationActionIgnoreFilterArgs{
							Type: pulumi.String("match-all-conditions"),
							Conditions: opsgenie.IntegrationActionIgnoreFilterConditionArray{
								&opsgenie.IntegrationActionIgnoreFilterConditionArgs{
									Field:         pulumi.String("tags"),
									Operation:     pulumi.String("contains"),
									ExpectedValue: pulumi.String("ignore"),
								},
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetIntegrationAction 

func GetIntegrationAction(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *IntegrationActionState, opts ...pulumi.ResourceOption) (*IntegrationAction, error)

GetIntegrationAction gets an existing IntegrationAction resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewIntegrationAction 

func NewIntegrationAction(ctx *pulumi.Context,
	name string, args *IntegrationActionArgs, opts ...pulumi.ResourceOption) (*IntegrationAction, error)

NewIntegrationAction registers a new resource with the given unique name, arguments, and options.

func (*IntegrationAction) ElementType 

func (*IntegrationAction) ElementType() reflect.Type

func (*IntegrationAction) ToIntegrationActionOutput 

func (i *IntegrationAction) ToIntegrationActionOutput() IntegrationActionOutput

func (*IntegrationAction) ToIntegrationActionOutputWithContext 

func (i *IntegrationAction) ToIntegrationActionOutputWithContext(ctx context.Context) IntegrationActionOutput

type IntegrationActionAcknowledge 

type IntegrationActionAcknowledge struct {
	// An identifier that is used for alert deduplication. Default: `{{alias}}`.
	Alias *string `pulumi:"alias"`
	// Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:
	// * For SNS integration: `actions`, `alias`, `entity`, `Message`, `recipients`, `responders`, `Subject`, `tags`, `teams`, `eventType`, `Timestamp`, `TopicArn`.
	// * For API integration: `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `recipients`, `teams`, `priority`, `eventType`.
	// * For Email integration: `fromAddress`, `fromName`, `conversationSubject`, `subject`
	Filters []IntegrationActionAcknowledgeFilter `pulumi:"filters"`
	// Name of the integration action.
	Name string `pulumi:"name"`
	// Additional alert action note.
	Note *string `pulumi:"note"`
	// Integer value that defines in which order the action will be performed. Default: `1`.
	Order *int    `pulumi:"order"`
	Type  *string `pulumi:"type"`
	// Owner of the execution for integration action.
	User *string `pulumi:"user"`
}

type IntegrationActionAcknowledgeArgs 

type IntegrationActionAcknowledgeArgs struct {
	// An identifier that is used for alert deduplication. Default: `{{alias}}`.
	Alias pulumi.StringPtrInput `pulumi:"alias"`
	// Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:
	// * For SNS integration: `actions`, `alias`, `entity`, `Message`, `recipients`, `responders`, `Subject`, `tags`, `teams`, `eventType`, `Timestamp`, `TopicArn`.
	// * For API integration: `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `recipients`, `teams`, `priority`, `eventType`.
	// * For Email integration: `fromAddress`, `fromName`, `conversationSubject`, `subject`
	Filters IntegrationActionAcknowledgeFilterArrayInput `pulumi:"filters"`
	// Name of the integration action.
	Name pulumi.StringInput `pulumi:"name"`
	// Additional alert action note.
	Note pulumi.StringPtrInput `pulumi:"note"`
	// Integer value that defines in which order the action will be performed. Default: `1`.
	Order pulumi.IntPtrInput    `pulumi:"order"`
	Type  pulumi.StringPtrInput `pulumi:"type"`
	// Owner of the execution for integration action.
	User pulumi.StringPtrInput `pulumi:"user"`
}

func (IntegrationActionAcknowledgeArgs) ElementType 

func (IntegrationActionAcknowledgeArgs) ElementType() reflect.Type

func (IntegrationActionAcknowledgeArgs) ToIntegrationActionAcknowledgeOutput 

func (i IntegrationActionAcknowledgeArgs) ToIntegrationActionAcknowledgeOutput() IntegrationActionAcknowledgeOutput

func (IntegrationActionAcknowledgeArgs) ToIntegrationActionAcknowledgeOutputWithContext 

func (i IntegrationActionAcknowledgeArgs) ToIntegrationActionAcknowledgeOutputWithContext(ctx context.Context) IntegrationActionAcknowledgeOutput

type IntegrationActionAcknowledgeArray 

type IntegrationActionAcknowledgeArray []IntegrationActionAcknowledgeInput

func (IntegrationActionAcknowledgeArray) ElementType 

func (IntegrationActionAcknowledgeArray) ElementType() reflect.Type

func (IntegrationActionAcknowledgeArray) ToIntegrationActionAcknowledgeArrayOutput 

func (i IntegrationActionAcknowledgeArray) ToIntegrationActionAcknowledgeArrayOutput() IntegrationActionAcknowledgeArrayOutput

func (IntegrationActionAcknowledgeArray) ToIntegrationActionAcknowledgeArrayOutputWithContext 

func (i IntegrationActionAcknowledgeArray) ToIntegrationActionAcknowledgeArrayOutputWithContext(ctx context.Context) IntegrationActionAcknowledgeArrayOutput

type IntegrationActionAcknowledgeArrayInput 

type IntegrationActionAcknowledgeArrayInput interface {
	pulumi.Input

	ToIntegrationActionAcknowledgeArrayOutput() IntegrationActionAcknowledgeArrayOutput
	ToIntegrationActionAcknowledgeArrayOutputWithContext(context.Context) IntegrationActionAcknowledgeArrayOutput
}

IntegrationActionAcknowledgeArrayInput is an input type that accepts IntegrationActionAcknowledgeArray and IntegrationActionAcknowledgeArrayOutput values. You can construct a concrete instance of `IntegrationActionAcknowledgeArrayInput` via: 

IntegrationActionAcknowledgeArray{ IntegrationActionAcknowledgeArgs{...} }

type IntegrationActionAcknowledgeArrayOutput 

type IntegrationActionAcknowledgeArrayOutput struct{ *pulumi.OutputState }

func (IntegrationActionAcknowledgeArrayOutput) ElementType 

func (IntegrationActionAcknowledgeArrayOutput) ElementType() reflect.Type

func (IntegrationActionAcknowledgeArrayOutput) Index 

func (o IntegrationActionAcknowledgeArrayOutput) Index(i pulumi.IntInput) IntegrationActionAcknowledgeOutput

func (IntegrationActionAcknowledgeArrayOutput) ToIntegrationActionAcknowledgeArrayOutput 

func (o IntegrationActionAcknowledgeArrayOutput) ToIntegrationActionAcknowledgeArrayOutput() IntegrationActionAcknowledgeArrayOutput

func (IntegrationActionAcknowledgeArrayOutput) ToIntegrationActionAcknowledgeArrayOutputWithContext 

func (o IntegrationActionAcknowledgeArrayOutput) ToIntegrationActionAcknowledgeArrayOutputWithContext(ctx context.Context) IntegrationActionAcknowledgeArrayOutput

type IntegrationActionAcknowledgeFilter 

type IntegrationActionAcknowledgeFilter struct {
	Conditions []IntegrationActionAcknowledgeFilterCondition `pulumi:"conditions"`
	Type       string                                        `pulumi:"type"`
}

type IntegrationActionAcknowledgeFilterArgs 

type IntegrationActionAcknowledgeFilterArgs struct {
	Conditions IntegrationActionAcknowledgeFilterConditionArrayInput `pulumi:"conditions"`
	Type       pulumi.StringInput                                    `pulumi:"type"`
}

func (IntegrationActionAcknowledgeFilterArgs) ElementType 

func (IntegrationActionAcknowledgeFilterArgs) ElementType() reflect.Type

func (IntegrationActionAcknowledgeFilterArgs) ToIntegrationActionAcknowledgeFilterOutput 

func (i IntegrationActionAcknowledgeFilterArgs) ToIntegrationActionAcknowledgeFilterOutput() IntegrationActionAcknowledgeFilterOutput

func (IntegrationActionAcknowledgeFilterArgs) ToIntegrationActionAcknowledgeFilterOutputWithContext 

func (i IntegrationActionAcknowledgeFilterArgs) ToIntegrationActionAcknowledgeFilterOutputWithContext(ctx context.Context) IntegrationActionAcknowledgeFilterOutput

type IntegrationActionAcknowledgeFilterArray 

type IntegrationActionAcknowledgeFilterArray []IntegrationActionAcknowledgeFilterInput

func (IntegrationActionAcknowledgeFilterArray) ElementType 

func (IntegrationActionAcknowledgeFilterArray) ElementType() reflect.Type

func (IntegrationActionAcknowledgeFilterArray) ToIntegrationActionAcknowledgeFilterArrayOutput 

func (i IntegrationActionAcknowledgeFilterArray) ToIntegrationActionAcknowledgeFilterArrayOutput() IntegrationActionAcknowledgeFilterArrayOutput

func (IntegrationActionAcknowledgeFilterArray) ToIntegrationActionAcknowledgeFilterArrayOutputWithContext 

func (i IntegrationActionAcknowledgeFilterArray) ToIntegrationActionAcknowledgeFilterArrayOutputWithContext(ctx context.Context) IntegrationActionAcknowledgeFilterArrayOutput

type IntegrationActionAcknowledgeFilterArrayInput 

type IntegrationActionAcknowledgeFilterArrayInput interface {
	pulumi.Input

	ToIntegrationActionAcknowledgeFilterArrayOutput() IntegrationActionAcknowledgeFilterArrayOutput
	ToIntegrationActionAcknowledgeFilterArrayOutputWithContext(context.Context) IntegrationActionAcknowledgeFilterArrayOutput
}

IntegrationActionAcknowledgeFilterArrayInput is an input type that accepts IntegrationActionAcknowledgeFilterArray and IntegrationActionAcknowledgeFilterArrayOutput values. You can construct a concrete instance of `IntegrationActionAcknowledgeFilterArrayInput` via: 

IntegrationActionAcknowledgeFilterArray{ IntegrationActionAcknowledgeFilterArgs{...} }

type IntegrationActionAcknowledgeFilterArrayOutput 

type IntegrationActionAcknowledgeFilterArrayOutput struct{ *pulumi.OutputState }

func (IntegrationActionAcknowledgeFilterArrayOutput) ElementType 

func (IntegrationActionAcknowledgeFilterArrayOutput) ElementType() reflect.Type

func (IntegrationActionAcknowledgeFilterArrayOutput) Index 

func (o IntegrationActionAcknowledgeFilterArrayOutput) Index(i pulumi.IntInput) IntegrationActionAcknowledgeFilterOutput

func (IntegrationActionAcknowledgeFilterArrayOutput) ToIntegrationActionAcknowledgeFilterArrayOutput 

func (o IntegrationActionAcknowledgeFilterArrayOutput) ToIntegrationActionAcknowledgeFilterArrayOutput() IntegrationActionAcknowledgeFilterArrayOutput

func (IntegrationActionAcknowledgeFilterArrayOutput) ToIntegrationActionAcknowledgeFilterArrayOutputWithContext 

func (o IntegrationActionAcknowledgeFilterArrayOutput) ToIntegrationActionAcknowledgeFilterArrayOutputWithContext(ctx context.Context) IntegrationActionAcknowledgeFilterArrayOutput

type IntegrationActionAcknowledgeFilterCondition 

type IntegrationActionAcknowledgeFilterCondition struct {
	ExpectedValue *string `pulumi:"expectedValue"`
	Field         string  `pulumi:"field"`
	Key           *string `pulumi:"key"`
	Not           *bool   `pulumi:"not"`
	Operation     string  `pulumi:"operation"`
	// Integer value that defines in which order the action will be performed. Default: `1`.
	Order *int `pulumi:"order"`
}

type IntegrationActionAcknowledgeFilterConditionArgs 

type IntegrationActionAcknowledgeFilterConditionArgs struct {
	ExpectedValue pulumi.StringPtrInput `pulumi:"expectedValue"`
	Field         pulumi.StringInput    `pulumi:"field"`
	Key           pulumi.StringPtrInput `pulumi:"key"`
	Not           pulumi.BoolPtrInput   `pulumi:"not"`
	Operation     pulumi.StringInput    `pulumi:"operation"`
	// Integer value that defines in which order the action will be performed. Default: `1`.
	Order pulumi.IntPtrInput `pulumi:"order"`
}

func (IntegrationActionAcknowledgeFilterConditionArgs) ElementType 

func (IntegrationActionAcknowledgeFilterConditionArgs) ElementType() reflect.Type

func (IntegrationActionAcknowledgeFilterConditionArgs) ToIntegrationActionAcknowledgeFilterConditionOutput 

func (i IntegrationActionAcknowledgeFilterConditionArgs) ToIntegrationActionAcknowledgeFilterConditionOutput() IntegrationActionAcknowledgeFilterConditionOutput

func (IntegrationActionAcknowledgeFilterConditionArgs) ToIntegrationActionAcknowledgeFilterConditionOutputWithContext 

func (i IntegrationActionAcknowledgeFilterConditionArgs) ToIntegrationActionAcknowledgeFilterConditionOutputWithContext(ctx context.Context) IntegrationActionAcknowledgeFilterConditionOutput

type IntegrationActionAcknowledgeFilterConditionArray 

type IntegrationActionAcknowledgeFilterConditionArray []IntegrationActionAcknowledgeFilterConditionInput

func (IntegrationActionAcknowledgeFilterConditionArray) ElementType 

func (IntegrationActionAcknowledgeFilterConditionArray) ElementType() reflect.Type

func (IntegrationActionAcknowledgeFilterConditionArray) ToIntegrationActionAcknowledgeFilterConditionArrayOutput 

func (i IntegrationActionAcknowledgeFilterConditionArray) ToIntegrationActionAcknowledgeFilterConditionArrayOutput() IntegrationActionAcknowledgeFilterConditionArrayOutput

func (IntegrationActionAcknowledgeFilterConditionArray) ToIntegrationActionAcknowledgeFilterConditionArrayOutputWithContext 

func (i IntegrationActionAcknowledgeFilterConditionArray) ToIntegrationActionAcknowledgeFilterConditionArrayOutputWithContext(ctx context.Context) IntegrationActionAcknowledgeFilterConditionArrayOutput

type IntegrationActionAcknowledgeFilterConditionArrayInput 

type IntegrationActionAcknowledgeFilterConditionArrayInput interface {
	pulumi.Input

	ToIntegrationActionAcknowledgeFilterConditionArrayOutput() IntegrationActionAcknowledgeFilterConditionArrayOutput
	ToIntegrationActionAcknowledgeFilterConditionArrayOutputWithContext(context.Context) IntegrationActionAcknowledgeFilterConditionArrayOutput
}

IntegrationActionAcknowledgeFilterConditionArrayInput is an input type that accepts IntegrationActionAcknowledgeFilterConditionArray and IntegrationActionAcknowledgeFilterConditionArrayOutput values. You can construct a concrete instance of `IntegrationActionAcknowledgeFilterConditionArrayInput` via: 

IntegrationActionAcknowledgeFilterConditionArray{ IntegrationActionAcknowledgeFilterConditionArgs{...} }

type IntegrationActionAcknowledgeFilterConditionArrayOutput 

type IntegrationActionAcknowledgeFilterConditionArrayOutput struct{ *pulumi.OutputState }

func (IntegrationActionAcknowledgeFilterConditionArrayOutput) ElementType 

func (IntegrationActionAcknowledgeFilterConditionArrayOutput) ElementType() reflect.Type

func (IntegrationActionAcknowledgeFilterConditionArrayOutput) Index 

func (o IntegrationActionAcknowledgeFilterConditionArrayOutput) Index(i pulumi.IntInput) IntegrationActionAcknowledgeFilterConditionOutput

func (IntegrationActionAcknowledgeFilterConditionArrayOutput) ToIntegrationActionAcknowledgeFilterConditionArrayOutput 

func (o IntegrationActionAcknowledgeFilterConditionArrayOutput) ToIntegrationActionAcknowledgeFilterConditionArrayOutput() IntegrationActionAcknowledgeFilterConditionArrayOutput

func (IntegrationActionAcknowledgeFilterConditionArrayOutput) ToIntegrationActionAcknowledgeFilterConditionArrayOutputWithContext 

func (o IntegrationActionAcknowledgeFilterConditionArrayOutput) ToIntegrationActionAcknowledgeFilterConditionArrayOutputWithContext(ctx context.Context) IntegrationActionAcknowledgeFilterConditionArrayOutput

type IntegrationActionAcknowledgeFilterConditionInput 

type IntegrationActionAcknowledgeFilterConditionInput interface {
	pulumi.Input

	ToIntegrationActionAcknowledgeFilterConditionOutput() IntegrationActionAcknowledgeFilterConditionOutput
	ToIntegrationActionAcknowledgeFilterConditionOutputWithContext(context.Context) IntegrationActionAcknowledgeFilterConditionOutput
}

IntegrationActionAcknowledgeFilterConditionInput is an input type that accepts IntegrationActionAcknowledgeFilterConditionArgs and IntegrationActionAcknowledgeFilterConditionOutput values. You can construct a concrete instance of `IntegrationActionAcknowledgeFilterConditionInput` via: 

IntegrationActionAcknowledgeFilterConditionArgs{...}

type IntegrationActionAcknowledgeFilterConditionOutput 

type IntegrationActionAcknowledgeFilterConditionOutput struct{ *pulumi.OutputState }

func (IntegrationActionAcknowledgeFilterConditionOutput) ElementType 

func (IntegrationActionAcknowledgeFilterConditionOutput) ElementType() reflect.Type

func (IntegrationActionAcknowledgeFilterConditionOutput) ExpectedValue 

func (o IntegrationActionAcknowledgeFilterConditionOutput) ExpectedValue() pulumi.StringPtrOutput

func (IntegrationActionAcknowledgeFilterConditionOutput) Field 

func (o IntegrationActionAcknowledgeFilterConditionOutput) Field() pulumi.StringOutput

func (IntegrationActionAcknowledgeFilterConditionOutput) Key 

func (o IntegrationActionAcknowledgeFilterConditionOutput) Key() pulumi.StringPtrOutput

func (IntegrationActionAcknowledgeFilterConditionOutput) Not 

func (o IntegrationActionAcknowledgeFilterConditionOutput) Not() pulumi.BoolPtrOutput

func (IntegrationActionAcknowledgeFilterConditionOutput) Operation 

func (o IntegrationActionAcknowledgeFilterConditionOutput) Operation() pulumi.StringOutput

func (IntegrationActionAcknowledgeFilterConditionOutput) Order 

func (o IntegrationActionAcknowledgeFilterConditionOutput) Order() pulumi.IntPtrOutput

Integer value that defines in which order the action will be performed. Default: `1`.

func (IntegrationActionAcknowledgeFilterConditionOutput) ToIntegrationActionAcknowledgeFilterConditionOutput 

func (o IntegrationActionAcknowledgeFilterConditionOutput) ToIntegrationActionAcknowledgeFilterConditionOutput() IntegrationActionAcknowledgeFilterConditionOutput

func (IntegrationActionAcknowledgeFilterConditionOutput) ToIntegrationActionAcknowledgeFilterConditionOutputWithContext 

func (o IntegrationActionAcknowledgeFilterConditionOutput) ToIntegrationActionAcknowledgeFilterConditionOutputWithContext(ctx context.Context) IntegrationActionAcknowledgeFilterConditionOutput

type IntegrationActionAcknowledgeFilterInput 

type IntegrationActionAcknowledgeFilterInput interface {
	pulumi.Input

	ToIntegrationActionAcknowledgeFilterOutput() IntegrationActionAcknowledgeFilterOutput
	ToIntegrationActionAcknowledgeFilterOutputWithContext(context.Context) IntegrationActionAcknowledgeFilterOutput
}

IntegrationActionAcknowledgeFilterInput is an input type that accepts IntegrationActionAcknowledgeFilterArgs and IntegrationActionAcknowledgeFilterOutput values. You can construct a concrete instance of `IntegrationActionAcknowledgeFilterInput` via: 

IntegrationActionAcknowledgeFilterArgs{...}

type IntegrationActionAcknowledgeFilterOutput 

type IntegrationActionAcknowledgeFilterOutput struct{ *pulumi.OutputState }

func (IntegrationActionAcknowledgeFilterOutput) Conditions 

func (o IntegrationActionAcknowledgeFilterOutput) Conditions() IntegrationActionAcknowledgeFilterConditionArrayOutput

func (IntegrationActionAcknowledgeFilterOutput) ElementType 

func (IntegrationActionAcknowledgeFilterOutput) ElementType() reflect.Type

func (IntegrationActionAcknowledgeFilterOutput) ToIntegrationActionAcknowledgeFilterOutput 

func (o IntegrationActionAcknowledgeFilterOutput) ToIntegrationActionAcknowledgeFilterOutput() IntegrationActionAcknowledgeFilterOutput

func (IntegrationActionAcknowledgeFilterOutput) ToIntegrationActionAcknowledgeFilterOutputWithContext 

func (o IntegrationActionAcknowledgeFilterOutput) ToIntegrationActionAcknowledgeFilterOutputWithContext(ctx context.Context) IntegrationActionAcknowledgeFilterOutput

func (IntegrationActionAcknowledgeFilterOutput) Type 

func (o IntegrationActionAcknowledgeFilterOutput) Type() pulumi.StringOutput

type IntegrationActionAcknowledgeInput 

type IntegrationActionAcknowledgeInput interface {
	pulumi.Input

	ToIntegrationActionAcknowledgeOutput() IntegrationActionAcknowledgeOutput
	ToIntegrationActionAcknowledgeOutputWithContext(context.Context) IntegrationActionAcknowledgeOutput
}

IntegrationActionAcknowledgeInput is an input type that accepts IntegrationActionAcknowledgeArgs and IntegrationActionAcknowledgeOutput values. You can construct a concrete instance of `IntegrationActionAcknowledgeInput` via: 

IntegrationActionAcknowledgeArgs{...}

type IntegrationActionAcknowledgeOutput 

type IntegrationActionAcknowledgeOutput struct{ *pulumi.OutputState }

func (IntegrationActionAcknowledgeOutput) Alias 

func (o IntegrationActionAcknowledgeOutput) Alias() pulumi.StringPtrOutput

An identifier that is used for alert deduplication. Default: `{{alias}}`.

func (IntegrationActionAcknowledgeOutput) ElementType 

func (IntegrationActionAcknowledgeOutput) ElementType() reflect.Type

func (IntegrationActionAcknowledgeOutput) Filters 

func (o IntegrationActionAcknowledgeOutput) Filters() IntegrationActionAcknowledgeFilterArrayOutput

Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are: * For SNS integration: `actions`, `alias`, `entity`, `Message`, `recipients`, `responders`, `Subject`, `tags`, `teams`, `eventType`, `Timestamp`, `TopicArn`. * For API integration: `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `recipients`, `teams`, `priority`, `eventType`. * For Email integration: `fromAddress`, `fromName`, `conversationSubject`, `subject`

func (IntegrationActionAcknowledgeOutput) Name 

func (o IntegrationActionAcknowledgeOutput) Name() pulumi.StringOutput

Name of the integration action.

func (IntegrationActionAcknowledgeOutput) Note 

func (o IntegrationActionAcknowledgeOutput) Note() pulumi.StringPtrOutput

Additional alert action note.

func (IntegrationActionAcknowledgeOutput) Order 

func (o IntegrationActionAcknowledgeOutput) Order() pulumi.IntPtrOutput

Integer value that defines in which order the action will be performed. Default: `1`.

func (IntegrationActionAcknowledgeOutput) ToIntegrationActionAcknowledgeOutput 

func (o IntegrationActionAcknowledgeOutput) ToIntegrationActionAcknowledgeOutput() IntegrationActionAcknowledgeOutput

func (IntegrationActionAcknowledgeOutput) ToIntegrationActionAcknowledgeOutputWithContext 

func (o IntegrationActionAcknowledgeOutput) ToIntegrationActionAcknowledgeOutputWithContext(ctx context.Context) IntegrationActionAcknowledgeOutput

func (IntegrationActionAcknowledgeOutput) Type 

func (o IntegrationActionAcknowledgeOutput) Type() pulumi.StringPtrOutput

func (IntegrationActionAcknowledgeOutput) User 

func (o IntegrationActionAcknowledgeOutput) User() pulumi.StringPtrOutput

Owner of the execution for integration action.

type IntegrationActionAddNote 

type IntegrationActionAddNote struct {
	// An identifier that is used for alert deduplication. Default: `{{alias}}`.
	Alias *string `pulumi:"alias"`
	// Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:
	// * For SNS integration: `actions`, `alias`, `entity`, `Message`, `recipients`, `responders`, `Subject`, `tags`, `teams`, `eventType`, `Timestamp`, `TopicArn`.
	// * For API integration: `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `recipients`, `teams`, `priority`, `eventType`.
	// * For Email integration: `fromAddress`, `fromName`, `conversationSubject`, `subject`
	Filters []IntegrationActionAddNoteFilter `pulumi:"filters"`
	// Name of the integration action.
	Name string `pulumi:"name"`
	// Additional alert action note.
	Note *string `pulumi:"note"`
	// Integer value that defines in which order the action will be performed. Default: `1`.
	Order *int    `pulumi:"order"`
	Type  *string `pulumi:"type"`
	// Owner of the execution for integration action.
	User *string `pulumi:"user"`
}

type IntegrationActionAddNoteArgs 

type IntegrationActionAddNoteArgs struct {
	// An identifier that is used for alert deduplication. Default: `{{alias}}`.
	Alias pulumi.StringPtrInput `pulumi:"alias"`
	// Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:
	// * For SNS integration: `actions`, `alias`, `entity`, `Message`, `recipients`, `responders`, `Subject`, `tags`, `teams`, `eventType`, `Timestamp`, `TopicArn`.
	// * For API integration: `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `recipients`, `teams`, `priority`, `eventType`.
	// * For Email integration: `fromAddress`, `fromName`, `conversationSubject`, `subject`
	Filters IntegrationActionAddNoteFilterArrayInput `pulumi:"filters"`
	// Name of the integration action.
	Name pulumi.StringInput `pulumi:"name"`
	// Additional alert action note.
	Note pulumi.StringPtrInput `pulumi:"note"`
	// Integer value that defines in which order the action will be performed. Default: `1`.
	Order pulumi.IntPtrInput    `pulumi:"order"`
	Type  pulumi.StringPtrInput `pulumi:"type"`
	// Owner of the execution for integration action.
	User pulumi.StringPtrInput `pulumi:"user"`
}

func (IntegrationActionAddNoteArgs) ElementType 

func (IntegrationActionAddNoteArgs) ElementType() reflect.Type

func (IntegrationActionAddNoteArgs) ToIntegrationActionAddNoteOutput 

func (i IntegrationActionAddNoteArgs) ToIntegrationActionAddNoteOutput() IntegrationActionAddNoteOutput

func (IntegrationActionAddNoteArgs) ToIntegrationActionAddNoteOutputWithContext 

func (i IntegrationActionAddNoteArgs) ToIntegrationActionAddNoteOutputWithContext(ctx context.Context) IntegrationActionAddNoteOutput

type IntegrationActionAddNoteArray 

type IntegrationActionAddNoteArray []IntegrationActionAddNoteInput

func (IntegrationActionAddNoteArray) ElementType 

func (IntegrationActionAddNoteArray) ElementType() reflect.Type

func (IntegrationActionAddNoteArray) ToIntegrationActionAddNoteArrayOutput 

func (i IntegrationActionAddNoteArray) ToIntegrationActionAddNoteArrayOutput() IntegrationActionAddNoteArrayOutput

func (IntegrationActionAddNoteArray) ToIntegrationActionAddNoteArrayOutputWithContext 

func (i IntegrationActionAddNoteArray) ToIntegrationActionAddNoteArrayOutputWithContext(ctx context.Context) IntegrationActionAddNoteArrayOutput

type IntegrationActionAddNoteArrayInput 

type IntegrationActionAddNoteArrayInput interface {
	pulumi.Input

	ToIntegrationActionAddNoteArrayOutput() IntegrationActionAddNoteArrayOutput
	ToIntegrationActionAddNoteArrayOutputWithContext(context.Context) IntegrationActionAddNoteArrayOutput
}

IntegrationActionAddNoteArrayInput is an input type that accepts IntegrationActionAddNoteArray and IntegrationActionAddNoteArrayOutput values. You can construct a concrete instance of `IntegrationActionAddNoteArrayInput` via: 

IntegrationActionAddNoteArray{ IntegrationActionAddNoteArgs{...} }

type IntegrationActionAddNoteArrayOutput 

type IntegrationActionAddNoteArrayOutput struct{ *pulumi.OutputState }

func (IntegrationActionAddNoteArrayOutput) ElementType 

func (IntegrationActionAddNoteArrayOutput) ElementType() reflect.Type

func (IntegrationActionAddNoteArrayOutput) Index 

func (o IntegrationActionAddNoteArrayOutput) Index(i pulumi.IntInput) IntegrationActionAddNoteOutput

func (IntegrationActionAddNoteArrayOutput) ToIntegrationActionAddNoteArrayOutput 

func (o IntegrationActionAddNoteArrayOutput) ToIntegrationActionAddNoteArrayOutput() IntegrationActionAddNoteArrayOutput

func (IntegrationActionAddNoteArrayOutput) ToIntegrationActionAddNoteArrayOutputWithContext 

func (o IntegrationActionAddNoteArrayOutput) ToIntegrationActionAddNoteArrayOutputWithContext(ctx context.Context) IntegrationActionAddNoteArrayOutput

type IntegrationActionAddNoteFilter 

type IntegrationActionAddNoteFilter struct {
	Conditions []IntegrationActionAddNoteFilterCondition `pulumi:"conditions"`
	Type       string                                    `pulumi:"type"`
}

type IntegrationActionAddNoteFilterArgs 

type IntegrationActionAddNoteFilterArgs struct {
	Conditions IntegrationActionAddNoteFilterConditionArrayInput `pulumi:"conditions"`
	Type       pulumi.StringInput                                `pulumi:"type"`
}

func (IntegrationActionAddNoteFilterArgs) ElementType 

func (IntegrationActionAddNoteFilterArgs) ElementType() reflect.Type

func (IntegrationActionAddNoteFilterArgs) ToIntegrationActionAddNoteFilterOutput 

func (i IntegrationActionAddNoteFilterArgs) ToIntegrationActionAddNoteFilterOutput() IntegrationActionAddNoteFilterOutput

func (IntegrationActionAddNoteFilterArgs) ToIntegrationActionAddNoteFilterOutputWithContext 

func (i IntegrationActionAddNoteFilterArgs) ToIntegrationActionAddNoteFilterOutputWithContext(ctx context.Context) IntegrationActionAddNoteFilterOutput

type IntegrationActionAddNoteFilterArray 

type IntegrationActionAddNoteFilterArray []IntegrationActionAddNoteFilterInput

func (IntegrationActionAddNoteFilterArray) ElementType 

func (IntegrationActionAddNoteFilterArray) ElementType() reflect.Type

func (IntegrationActionAddNoteFilterArray) ToIntegrationActionAddNoteFilterArrayOutput 

func (i IntegrationActionAddNoteFilterArray) ToIntegrationActionAddNoteFilterArrayOutput() IntegrationActionAddNoteFilterArrayOutput

func (IntegrationActionAddNoteFilterArray) ToIntegrationActionAddNoteFilterArrayOutputWithContext 

func (i IntegrationActionAddNoteFilterArray) ToIntegrationActionAddNoteFilterArrayOutputWithContext(ctx context.Context) IntegrationActionAddNoteFilterArrayOutput

type IntegrationActionAddNoteFilterArrayInput 

type IntegrationActionAddNoteFilterArrayInput interface {
	pulumi.Input

	ToIntegrationActionAddNoteFilterArrayOutput() IntegrationActionAddNoteFilterArrayOutput
	ToIntegrationActionAddNoteFilterArrayOutputWithContext(context.Context) IntegrationActionAddNoteFilterArrayOutput
}

IntegrationActionAddNoteFilterArrayInput is an input type that accepts IntegrationActionAddNoteFilterArray and IntegrationActionAddNoteFilterArrayOutput values. You can construct a concrete instance of `IntegrationActionAddNoteFilterArrayInput` via: 

IntegrationActionAddNoteFilterArray{ IntegrationActionAddNoteFilterArgs{...} }

type IntegrationActionAddNoteFilterArrayOutput 

type IntegrationActionAddNoteFilterArrayOutput struct{ *pulumi.OutputState }

func (IntegrationActionAddNoteFilterArrayOutput) ElementType 

func (IntegrationActionAddNoteFilterArrayOutput) ElementType() reflect.Type

func (IntegrationActionAddNoteFilterArrayOutput) Index 

func (o IntegrationActionAddNoteFilterArrayOutput) Index(i pulumi.IntInput) IntegrationActionAddNoteFilterOutput

func (IntegrationActionAddNoteFilterArrayOutput) ToIntegrationActionAddNoteFilterArrayOutput 

func (o IntegrationActionAddNoteFilterArrayOutput) ToIntegrationActionAddNoteFilterArrayOutput() IntegrationActionAddNoteFilterArrayOutput

func (IntegrationActionAddNoteFilterArrayOutput) ToIntegrationActionAddNoteFilterArrayOutputWithContext 

func (o IntegrationActionAddNoteFilterArrayOutput) ToIntegrationActionAddNoteFilterArrayOutputWithContext(ctx context.Context) IntegrationActionAddNoteFilterArrayOutput

type IntegrationActionAddNoteFilterCondition 

type IntegrationActionAddNoteFilterCondition struct {
	ExpectedValue *string `pulumi:"expectedValue"`
	Field         string  `pulumi:"field"`
	Key           *string `pulumi:"key"`
	Not           *bool   `pulumi:"not"`
	Operation     string  `pulumi:"operation"`
	// Integer value that defines in which order the action will be performed. Default: `1`.
	Order *int `pulumi:"order"`
}

type IntegrationActionAddNoteFilterConditionArgs 

type IntegrationActionAddNoteFilterConditionArgs struct {
	ExpectedValue pulumi.StringPtrInput `pulumi:"expectedValue"`
	Field         pulumi.StringInput    `pulumi:"field"`
	Key           pulumi.StringPtrInput `pulumi:"key"`
	Not           pulumi.BoolPtrInput   `pulumi:"not"`
	Operation     pulumi.StringInput    `pulumi:"operation"`
	// Integer value that defines in which order the action will be performed. Default: `1`.
	Order pulumi.IntPtrInput `pulumi:"order"`
}

func (IntegrationActionAddNoteFilterConditionArgs) ElementType 

func (IntegrationActionAddNoteFilterConditionArgs) ElementType() reflect.Type

func (IntegrationActionAddNoteFilterConditionArgs) ToIntegrationActionAddNoteFilterConditionOutput 

func (i IntegrationActionAddNoteFilterConditionArgs) ToIntegrationActionAddNoteFilterConditionOutput() IntegrationActionAddNoteFilterConditionOutput

func (IntegrationActionAddNoteFilterConditionArgs) ToIntegrationActionAddNoteFilterConditionOutputWithContext 

func (i IntegrationActionAddNoteFilterConditionArgs) ToIntegrationActionAddNoteFilterConditionOutputWithContext(ctx context.Context) IntegrationActionAddNoteFilterConditionOutput

type IntegrationActionAddNoteFilterConditionArray 

type IntegrationActionAddNoteFilterConditionArray []IntegrationActionAddNoteFilterConditionInput

func (IntegrationActionAddNoteFilterConditionArray) ElementType 

func (IntegrationActionAddNoteFilterConditionArray) ElementType() reflect.Type

func (IntegrationActionAddNoteFilterConditionArray) ToIntegrationActionAddNoteFilterConditionArrayOutput 

func (i IntegrationActionAddNoteFilterConditionArray) ToIntegrationActionAddNoteFilterConditionArrayOutput() IntegrationActionAddNoteFilterConditionArrayOutput

func (IntegrationActionAddNoteFilterConditionArray) ToIntegrationActionAddNoteFilterConditionArrayOutputWithContext 

func (i IntegrationActionAddNoteFilterConditionArray) ToIntegrationActionAddNoteFilterConditionArrayOutputWithContext(ctx context.Context) IntegrationActionAddNoteFilterConditionArrayOutput

type IntegrationActionAddNoteFilterConditionArrayInput 

type IntegrationActionAddNoteFilterConditionArrayInput interface {
	pulumi.Input

	ToIntegrationActionAddNoteFilterConditionArrayOutput() IntegrationActionAddNoteFilterConditionArrayOutput
	ToIntegrationActionAddNoteFilterConditionArrayOutputWithContext(context.Context) IntegrationActionAddNoteFilterConditionArrayOutput
}

IntegrationActionAddNoteFilterConditionArrayInput is an input type that accepts IntegrationActionAddNoteFilterConditionArray and IntegrationActionAddNoteFilterConditionArrayOutput values. You can construct a concrete instance of `IntegrationActionAddNoteFilterConditionArrayInput` via: 

IntegrationActionAddNoteFilterConditionArray{ IntegrationActionAddNoteFilterConditionArgs{...} }

type IntegrationActionAddNoteFilterConditionArrayOutput 

type IntegrationActionAddNoteFilterConditionArrayOutput struct{ *pulumi.OutputState }

func (IntegrationActionAddNoteFilterConditionArrayOutput) ElementType 

func (IntegrationActionAddNoteFilterConditionArrayOutput) ElementType() reflect.Type

func (IntegrationActionAddNoteFilterConditionArrayOutput) Index 

func (o IntegrationActionAddNoteFilterConditionArrayOutput) Index(i pulumi.IntInput) IntegrationActionAddNoteFilterConditionOutput

func (IntegrationActionAddNoteFilterConditionArrayOutput) ToIntegrationActionAddNoteFilterConditionArrayOutput 

func (o IntegrationActionAddNoteFilterConditionArrayOutput) ToIntegrationActionAddNoteFilterConditionArrayOutput() IntegrationActionAddNoteFilterConditionArrayOutput

func (IntegrationActionAddNoteFilterConditionArrayOutput) ToIntegrationActionAddNoteFilterConditionArrayOutputWithContext 

func (o IntegrationActionAddNoteFilterConditionArrayOutput) ToIntegrationActionAddNoteFilterConditionArrayOutputWithContext(ctx context.Context) IntegrationActionAddNoteFilterConditionArrayOutput

type IntegrationActionAddNoteFilterConditionInput 

type IntegrationActionAddNoteFilterConditionInput interface {
	pulumi.Input

	ToIntegrationActionAddNoteFilterConditionOutput() IntegrationActionAddNoteFilterConditionOutput
	ToIntegrationActionAddNoteFilterConditionOutputWithContext(context.Context) IntegrationActionAddNoteFilterConditionOutput
}

IntegrationActionAddNoteFilterConditionInput is an input type that accepts IntegrationActionAddNoteFilterConditionArgs and IntegrationActionAddNoteFilterConditionOutput values. You can construct a concrete instance of `IntegrationActionAddNoteFilterConditionInput` via: 

IntegrationActionAddNoteFilterConditionArgs{...}

type IntegrationActionAddNoteFilterConditionOutput 

type IntegrationActionAddNoteFilterConditionOutput struct{ *pulumi.OutputState }

func (IntegrationActionAddNoteFilterConditionOutput) ElementType 

func (IntegrationActionAddNoteFilterConditionOutput) ElementType() reflect.Type

func (IntegrationActionAddNoteFilterConditionOutput) ExpectedValue 

func (o IntegrationActionAddNoteFilterConditionOutput) ExpectedValue() pulumi.StringPtrOutput

func (IntegrationActionAddNoteFilterConditionOutput) Field 

func (o IntegrationActionAddNoteFilterConditionOutput) Field() pulumi.StringOutput

func (IntegrationActionAddNoteFilterConditionOutput) Key 

func (o IntegrationActionAddNoteFilterConditionOutput) Key() pulumi.StringPtrOutput

func (IntegrationActionAddNoteFilterConditionOutput) Not 

func (o IntegrationActionAddNoteFilterConditionOutput) Not() pulumi.BoolPtrOutput

func (IntegrationActionAddNoteFilterConditionOutput) Operation 

func (o IntegrationActionAddNoteFilterConditionOutput) Operation() pulumi.StringOutput

func (IntegrationActionAddNoteFilterConditionOutput) Order 

func (o IntegrationActionAddNoteFilterConditionOutput) Order() pulumi.IntPtrOutput

Integer value that defines in which order the action will be performed. Default: `1`.

func (IntegrationActionAddNoteFilterConditionOutput) ToIntegrationActionAddNoteFilterConditionOutput 

func (o IntegrationActionAddNoteFilterConditionOutput) ToIntegrationActionAddNoteFilterConditionOutput() IntegrationActionAddNoteFilterConditionOutput

func (IntegrationActionAddNoteFilterConditionOutput) ToIntegrationActionAddNoteFilterConditionOutputWithContext 

func (o IntegrationActionAddNoteFilterConditionOutput) ToIntegrationActionAddNoteFilterConditionOutputWithContext(ctx context.Context) IntegrationActionAddNoteFilterConditionOutput

type IntegrationActionAddNoteFilterInput 

type IntegrationActionAddNoteFilterInput interface {
	pulumi.Input

	ToIntegrationActionAddNoteFilterOutput() IntegrationActionAddNoteFilterOutput
	ToIntegrationActionAddNoteFilterOutputWithContext(context.Context) IntegrationActionAddNoteFilterOutput
}

IntegrationActionAddNoteFilterInput is an input type that accepts IntegrationActionAddNoteFilterArgs and IntegrationActionAddNoteFilterOutput values. You can construct a concrete instance of `IntegrationActionAddNoteFilterInput` via: 

IntegrationActionAddNoteFilterArgs{...}

type IntegrationActionAddNoteFilterOutput 

type IntegrationActionAddNoteFilterOutput struct{ *pulumi.OutputState }

func (IntegrationActionAddNoteFilterOutput) Conditions 

func (o IntegrationActionAddNoteFilterOutput) Conditions() IntegrationActionAddNoteFilterConditionArrayOutput

func (IntegrationActionAddNoteFilterOutput) ElementType 

func (IntegrationActionAddNoteFilterOutput) ElementType() reflect.Type

func (IntegrationActionAddNoteFilterOutput) ToIntegrationActionAddNoteFilterOutput 

func (o IntegrationActionAddNoteFilterOutput) ToIntegrationActionAddNoteFilterOutput() IntegrationActionAddNoteFilterOutput

func (IntegrationActionAddNoteFilterOutput) ToIntegrationActionAddNoteFilterOutputWithContext 

func (o IntegrationActionAddNoteFilterOutput) ToIntegrationActionAddNoteFilterOutputWithContext(ctx context.Context) IntegrationActionAddNoteFilterOutput

func (IntegrationActionAddNoteFilterOutput) Type 

func (o IntegrationActionAddNoteFilterOutput) Type() pulumi.StringOutput

type IntegrationActionAddNoteInput 

type IntegrationActionAddNoteInput interface {
	pulumi.Input

	ToIntegrationActionAddNoteOutput() IntegrationActionAddNoteOutput
	ToIntegrationActionAddNoteOutputWithContext(context.Context) IntegrationActionAddNoteOutput
}

IntegrationActionAddNoteInput is an input type that accepts IntegrationActionAddNoteArgs and IntegrationActionAddNoteOutput values. You can construct a concrete instance of `IntegrationActionAddNoteInput` via: 

IntegrationActionAddNoteArgs{...}

type IntegrationActionAddNoteOutput 

type IntegrationActionAddNoteOutput struct{ *pulumi.OutputState }

func (IntegrationActionAddNoteOutput) Alias 

func (o IntegrationActionAddNoteOutput) Alias() pulumi.StringPtrOutput

An identifier that is used for alert deduplication. Default: `{{alias}}`.

func (IntegrationActionAddNoteOutput) ElementType 

func (IntegrationActionAddNoteOutput) ElementType() reflect.Type

func (IntegrationActionAddNoteOutput) Filters 

func (o IntegrationActionAddNoteOutput) Filters() IntegrationActionAddNoteFilterArrayOutput

Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are: * For SNS integration: `actions`, `alias`, `entity`, `Message`, `recipients`, `responders`, `Subject`, `tags`, `teams`, `eventType`, `Timestamp`, `TopicArn`. * For API integration: `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `recipients`, `teams`, `priority`, `eventType`. * For Email integration: `fromAddress`, `fromName`, `conversationSubject`, `subject`

func (IntegrationActionAddNoteOutput) Name 

func (o IntegrationActionAddNoteOutput) Name() pulumi.StringOutput

Name of the integration action.

func (IntegrationActionAddNoteOutput) Note 

func (o IntegrationActionAddNoteOutput) Note() pulumi.StringPtrOutput

Additional alert action note.

func (IntegrationActionAddNoteOutput) Order 

func (o IntegrationActionAddNoteOutput) Order() pulumi.IntPtrOutput

Integer value that defines in which order the action will be performed. Default: `1`.

func (IntegrationActionAddNoteOutput) ToIntegrationActionAddNoteOutput 

func (o IntegrationActionAddNoteOutput) ToIntegrationActionAddNoteOutput() IntegrationActionAddNoteOutput

func (IntegrationActionAddNoteOutput) ToIntegrationActionAddNoteOutputWithContext 

func (o IntegrationActionAddNoteOutput) ToIntegrationActionAddNoteOutputWithContext(ctx context.Context) IntegrationActionAddNoteOutput

func (IntegrationActionAddNoteOutput) Type 

func (o IntegrationActionAddNoteOutput) Type() pulumi.StringPtrOutput

func (IntegrationActionAddNoteOutput) User 

func (o IntegrationActionAddNoteOutput) User() pulumi.StringPtrOutput

Owner of the execution for integration action.

type IntegrationActionArgs 

type IntegrationActionArgs struct {
	Acknowledges IntegrationActionAcknowledgeArrayInput
	AddNotes     IntegrationActionAddNoteArrayInput
	Closes       IntegrationActionCloseArrayInput
	Creates      IntegrationActionCreateArrayInput
	Ignores      IntegrationActionIgnoreArrayInput
	// ID of the parent integration resource to bind to.
	IntegrationId pulumi.StringInput
}

The set of arguments for constructing a IntegrationAction resource.

func (IntegrationActionArgs) ElementType 

func (IntegrationActionArgs) ElementType() reflect.Type

type IntegrationActionArray added in v0.1.3 

type IntegrationActionArray []IntegrationActionInput

func (IntegrationActionArray) ElementType added in v0.1.3 

func (IntegrationActionArray) ElementType() reflect.Type

func (IntegrationActionArray) ToIntegrationActionArrayOutput added in v0.1.3 

func (i IntegrationActionArray) ToIntegrationActionArrayOutput() IntegrationActionArrayOutput

func (IntegrationActionArray) ToIntegrationActionArrayOutputWithContext added in v0.1.3 

func (i IntegrationActionArray) ToIntegrationActionArrayOutputWithContext(ctx context.Context) IntegrationActionArrayOutput

type IntegrationActionArrayInput added in v0.1.3 

type IntegrationActionArrayInput interface {
	pulumi.Input

	ToIntegrationActionArrayOutput() IntegrationActionArrayOutput
	ToIntegrationActionArrayOutputWithContext(context.Context) IntegrationActionArrayOutput
}

IntegrationActionArrayInput is an input type that accepts IntegrationActionArray and IntegrationActionArrayOutput values. You can construct a concrete instance of `IntegrationActionArrayInput` via: 

IntegrationActionArray{ IntegrationActionArgs{...} }

type IntegrationActionArrayOutput added in v0.1.3 

type IntegrationActionArrayOutput struct{ *pulumi.OutputState }

func (IntegrationActionArrayOutput) ElementType added in v0.1.3 

func (IntegrationActionArrayOutput) ElementType() reflect.Type

func (IntegrationActionArrayOutput) Index added in v0.1.3 

func (o IntegrationActionArrayOutput) Index(i pulumi.IntInput) IntegrationActionOutput

func (IntegrationActionArrayOutput) ToIntegrationActionArrayOutput added in v0.1.3 

func (o IntegrationActionArrayOutput) ToIntegrationActionArrayOutput() IntegrationActionArrayOutput

func (IntegrationActionArrayOutput) ToIntegrationActionArrayOutputWithContext added in v0.1.3 

func (o IntegrationActionArrayOutput) ToIntegrationActionArrayOutputWithContext(ctx context.Context) IntegrationActionArrayOutput

type IntegrationActionClose 

type IntegrationActionClose struct {
	// An identifier that is used for alert deduplication. Default: `{{alias}}`.
	Alias *string `pulumi:"alias"`
	// Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:
	// * For SNS integration: `actions`, `alias`, `entity`, `Message`, `recipients`, `responders`, `Subject`, `tags`, `teams`, `eventType`, `Timestamp`, `TopicArn`.
	// * For API integration: `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `recipients`, `teams`, `priority`, `eventType`.
	// * For Email integration: `fromAddress`, `fromName`, `conversationSubject`, `subject`
	Filters []IntegrationActionCloseFilter `pulumi:"filters"`
	// Name of the integration action.
	Name string `pulumi:"name"`
	// Additional alert action note.
	Note *string `pulumi:"note"`
	// Integer value that defines in which order the action will be performed. Default: `1`.
	Order *int    `pulumi:"order"`
	Type  *string `pulumi:"type"`
	// Owner of the execution for integration action.
	User *string `pulumi:"user"`
}

type IntegrationActionCloseArgs 

type IntegrationActionCloseArgs struct {
	// An identifier that is used for alert deduplication. Default: `{{alias}}`.
	Alias pulumi.StringPtrInput `pulumi:"alias"`
	// Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:
	// * For SNS integration: `actions`, `alias`, `entity`, `Message`, `recipients`, `responders`, `Subject`, `tags`, `teams`, `eventType`, `Timestamp`, `TopicArn`.
	// * For API integration: `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `recipients`, `teams`, `priority`, `eventType`.
	// * For Email integration: `fromAddress`, `fromName`, `conversationSubject`, `subject`
	Filters IntegrationActionCloseFilterArrayInput `pulumi:"filters"`
	// Name of the integration action.
	Name pulumi.StringInput `pulumi:"name"`
	// Additional alert action note.
	Note pulumi.StringPtrInput `pulumi:"note"`
	// Integer value that defines in which order the action will be performed. Default: `1`.
	Order pulumi.IntPtrInput    `pulumi:"order"`
	Type  pulumi.StringPtrInput `pulumi:"type"`
	// Owner of the execution for integration action.
	User pulumi.StringPtrInput `pulumi:"user"`
}

func (IntegrationActionCloseArgs) ElementType 

func (IntegrationActionCloseArgs) ElementType() reflect.Type

func (IntegrationActionCloseArgs) ToIntegrationActionCloseOutput 

func (i IntegrationActionCloseArgs) ToIntegrationActionCloseOutput() IntegrationActionCloseOutput

func (IntegrationActionCloseArgs) ToIntegrationActionCloseOutputWithContext 

func (i IntegrationActionCloseArgs) ToIntegrationActionCloseOutputWithContext(ctx context.Context) IntegrationActionCloseOutput

type IntegrationActionCloseArray 

type IntegrationActionCloseArray []IntegrationActionCloseInput

func (IntegrationActionCloseArray) ElementType 

func (IntegrationActionCloseArray) ElementType() reflect.Type

func (IntegrationActionCloseArray) ToIntegrationActionCloseArrayOutput 

func (i IntegrationActionCloseArray) ToIntegrationActionCloseArrayOutput() IntegrationActionCloseArrayOutput

func (IntegrationActionCloseArray) ToIntegrationActionCloseArrayOutputWithContext 

func (i IntegrationActionCloseArray) ToIntegrationActionCloseArrayOutputWithContext(ctx context.Context) IntegrationActionCloseArrayOutput

type IntegrationActionCloseArrayInput 

type IntegrationActionCloseArrayInput interface {
	pulumi.Input

	ToIntegrationActionCloseArrayOutput() IntegrationActionCloseArrayOutput
	ToIntegrationActionCloseArrayOutputWithContext(context.Context) IntegrationActionCloseArrayOutput
}

IntegrationActionCloseArrayInput is an input type that accepts IntegrationActionCloseArray and IntegrationActionCloseArrayOutput values. You can construct a concrete instance of `IntegrationActionCloseArrayInput` via: 

IntegrationActionCloseArray{ IntegrationActionCloseArgs{...} }

type IntegrationActionCloseArrayOutput 

type IntegrationActionCloseArrayOutput struct{ *pulumi.OutputState }

func (IntegrationActionCloseArrayOutput) ElementType 

func (IntegrationActionCloseArrayOutput) ElementType() reflect.Type

func (IntegrationActionCloseArrayOutput) Index 

func (o IntegrationActionCloseArrayOutput) Index(i pulumi.IntInput) IntegrationActionCloseOutput

func (IntegrationActionCloseArrayOutput) ToIntegrationActionCloseArrayOutput 

func (o IntegrationActionCloseArrayOutput) ToIntegrationActionCloseArrayOutput() IntegrationActionCloseArrayOutput

func (IntegrationActionCloseArrayOutput) ToIntegrationActionCloseArrayOutputWithContext 

func (o IntegrationActionCloseArrayOutput) ToIntegrationActionCloseArrayOutputWithContext(ctx context.Context) IntegrationActionCloseArrayOutput

type IntegrationActionCloseFilter 

type IntegrationActionCloseFilter struct {
	Conditions []IntegrationActionCloseFilterCondition `pulumi:"conditions"`
	Type       string                                  `pulumi:"type"`
}

type IntegrationActionCloseFilterArgs 

type IntegrationActionCloseFilterArgs struct {
	Conditions IntegrationActionCloseFilterConditionArrayInput `pulumi:"conditions"`
	Type       pulumi.StringInput                              `pulumi:"type"`
}

func (IntegrationActionCloseFilterArgs) ElementType 

func (IntegrationActionCloseFilterArgs) ElementType() reflect.Type

func (IntegrationActionCloseFilterArgs) ToIntegrationActionCloseFilterOutput 

func (i IntegrationActionCloseFilterArgs) ToIntegrationActionCloseFilterOutput() IntegrationActionCloseFilterOutput

func (IntegrationActionCloseFilterArgs) ToIntegrationActionCloseFilterOutputWithContext 

func (i IntegrationActionCloseFilterArgs) ToIntegrationActionCloseFilterOutputWithContext(ctx context.Context) IntegrationActionCloseFilterOutput

type IntegrationActionCloseFilterArray 

type IntegrationActionCloseFilterArray []IntegrationActionCloseFilterInput

func (IntegrationActionCloseFilterArray) ElementType 

func (IntegrationActionCloseFilterArray) ElementType() reflect.Type

func (IntegrationActionCloseFilterArray) ToIntegrationActionCloseFilterArrayOutput 

func (i IntegrationActionCloseFilterArray) ToIntegrationActionCloseFilterArrayOutput() IntegrationActionCloseFilterArrayOutput

func (IntegrationActionCloseFilterArray) ToIntegrationActionCloseFilterArrayOutputWithContext 

func (i IntegrationActionCloseFilterArray) ToIntegrationActionCloseFilterArrayOutputWithContext(ctx context.Context) IntegrationActionCloseFilterArrayOutput

type IntegrationActionCloseFilterArrayInput 

type IntegrationActionCloseFilterArrayInput interface {
	pulumi.Input

	ToIntegrationActionCloseFilterArrayOutput() IntegrationActionCloseFilterArrayOutput
	ToIntegrationActionCloseFilterArrayOutputWithContext(context.Context) IntegrationActionCloseFilterArrayOutput
}

IntegrationActionCloseFilterArrayInput is an input type that accepts IntegrationActionCloseFilterArray and IntegrationActionCloseFilterArrayOutput values. You can construct a concrete instance of `IntegrationActionCloseFilterArrayInput` via: 

IntegrationActionCloseFilterArray{ IntegrationActionCloseFilterArgs{...} }

type IntegrationActionCloseFilterArrayOutput 

type IntegrationActionCloseFilterArrayOutput struct{ *pulumi.OutputState }

func (IntegrationActionCloseFilterArrayOutput) ElementType 

func (IntegrationActionCloseFilterArrayOutput) ElementType() reflect.Type

func (IntegrationActionCloseFilterArrayOutput) Index 

func (o IntegrationActionCloseFilterArrayOutput) Index(i pulumi.IntInput) IntegrationActionCloseFilterOutput

func (IntegrationActionCloseFilterArrayOutput) ToIntegrationActionCloseFilterArrayOutput 

func (o IntegrationActionCloseFilterArrayOutput) ToIntegrationActionCloseFilterArrayOutput() IntegrationActionCloseFilterArrayOutput

func (IntegrationActionCloseFilterArrayOutput) ToIntegrationActionCloseFilterArrayOutputWithContext 

func (o IntegrationActionCloseFilterArrayOutput) ToIntegrationActionCloseFilterArrayOutputWithContext(ctx context.Context) IntegrationActionCloseFilterArrayOutput

type IntegrationActionCloseFilterCondition 

type IntegrationActionCloseFilterCondition struct {
	ExpectedValue *string `pulumi:"expectedValue"`
	Field         string  `pulumi:"field"`
	Key           *string `pulumi:"key"`
	Not           *bool   `pulumi:"not"`
	Operation     string  `pulumi:"operation"`
	// Integer value that defines in which order the action will be performed. Default: `1`.
	Order *int `pulumi:"order"`
}

type IntegrationActionCloseFilterConditionArgs 

type IntegrationActionCloseFilterConditionArgs struct {
	ExpectedValue pulumi.StringPtrInput `pulumi:"expectedValue"`
	Field         pulumi.StringInput    `pulumi:"field"`
	Key           pulumi.StringPtrInput `pulumi:"key"`
	Not           pulumi.BoolPtrInput   `pulumi:"not"`
	Operation     pulumi.StringInput    `pulumi:"operation"`
	// Integer value that defines in which order the action will be performed. Default: `1`.
	Order pulumi.IntPtrInput `pulumi:"order"`
}

func (IntegrationActionCloseFilterConditionArgs) ElementType 

func (IntegrationActionCloseFilterConditionArgs) ElementType() reflect.Type

func (IntegrationActionCloseFilterConditionArgs) ToIntegrationActionCloseFilterConditionOutput 

func (i IntegrationActionCloseFilterConditionArgs) ToIntegrationActionCloseFilterConditionOutput() IntegrationActionCloseFilterConditionOutput

func (IntegrationActionCloseFilterConditionArgs) ToIntegrationActionCloseFilterConditionOutputWithContext 

func (i IntegrationActionCloseFilterConditionArgs) ToIntegrationActionCloseFilterConditionOutputWithContext(ctx context.Context) IntegrationActionCloseFilterConditionOutput

type IntegrationActionCloseFilterConditionArray 

type IntegrationActionCloseFilterConditionArray []IntegrationActionCloseFilterConditionInput

func (IntegrationActionCloseFilterConditionArray) ElementType 

func (IntegrationActionCloseFilterConditionArray) ElementType() reflect.Type

func (IntegrationActionCloseFilterConditionArray) ToIntegrationActionCloseFilterConditionArrayOutput 

func (i IntegrationActionCloseFilterConditionArray) ToIntegrationActionCloseFilterConditionArrayOutput() IntegrationActionCloseFilterConditionArrayOutput

func (IntegrationActionCloseFilterConditionArray) ToIntegrationActionCloseFilterConditionArrayOutputWithContext 

func (i IntegrationActionCloseFilterConditionArray) ToIntegrationActionCloseFilterConditionArrayOutputWithContext(ctx context.Context) IntegrationActionCloseFilterConditionArrayOutput

type IntegrationActionCloseFilterConditionArrayInput 

type IntegrationActionCloseFilterConditionArrayInput interface {
	pulumi.Input

	ToIntegrationActionCloseFilterConditionArrayOutput() IntegrationActionCloseFilterConditionArrayOutput
	ToIntegrationActionCloseFilterConditionArrayOutputWithContext(context.Context) IntegrationActionCloseFilterConditionArrayOutput
}

IntegrationActionCloseFilterConditionArrayInput is an input type that accepts IntegrationActionCloseFilterConditionArray and IntegrationActionCloseFilterConditionArrayOutput values. You can construct a concrete instance of `IntegrationActionCloseFilterConditionArrayInput` via: 

IntegrationActionCloseFilterConditionArray{ IntegrationActionCloseFilterConditionArgs{...} }

type IntegrationActionCloseFilterConditionArrayOutput 

type IntegrationActionCloseFilterConditionArrayOutput struct{ *pulumi.OutputState }

func (IntegrationActionCloseFilterConditionArrayOutput) ElementType 

func (IntegrationActionCloseFilterConditionArrayOutput) ElementType() reflect.Type

func (IntegrationActionCloseFilterConditionArrayOutput) Index 

func (o IntegrationActionCloseFilterConditionArrayOutput) Index(i pulumi.IntInput) IntegrationActionCloseFilterConditionOutput

func (IntegrationActionCloseFilterConditionArrayOutput) ToIntegrationActionCloseFilterConditionArrayOutput 

func (o IntegrationActionCloseFilterConditionArrayOutput) ToIntegrationActionCloseFilterConditionArrayOutput() IntegrationActionCloseFilterConditionArrayOutput

func (IntegrationActionCloseFilterConditionArrayOutput) ToIntegrationActionCloseFilterConditionArrayOutputWithContext 

func (o IntegrationActionCloseFilterConditionArrayOutput) ToIntegrationActionCloseFilterConditionArrayOutputWithContext(ctx context.Context) IntegrationActionCloseFilterConditionArrayOutput

type IntegrationActionCloseFilterConditionInput 

type IntegrationActionCloseFilterConditionInput interface {
	pulumi.Input

	ToIntegrationActionCloseFilterConditionOutput() IntegrationActionCloseFilterConditionOutput
	ToIntegrationActionCloseFilterConditionOutputWithContext(context.Context) IntegrationActionCloseFilterConditionOutput
}

IntegrationActionCloseFilterConditionInput is an input type that accepts IntegrationActionCloseFilterConditionArgs and IntegrationActionCloseFilterConditionOutput values. You can construct a concrete instance of `IntegrationActionCloseFilterConditionInput` via: 

IntegrationActionCloseFilterConditionArgs{...}

type IntegrationActionCloseFilterConditionOutput 

type IntegrationActionCloseFilterConditionOutput struct{ *pulumi.OutputState }

func (IntegrationActionCloseFilterConditionOutput) ElementType 

func (IntegrationActionCloseFilterConditionOutput) ElementType() reflect.Type

func (IntegrationActionCloseFilterConditionOutput) ExpectedValue 

func (o IntegrationActionCloseFilterConditionOutput) ExpectedValue() pulumi.StringPtrOutput

func (IntegrationActionCloseFilterConditionOutput) Field 

func (o IntegrationActionCloseFilterConditionOutput) Field() pulumi.StringOutput

func (IntegrationActionCloseFilterConditionOutput) Key 

func (o IntegrationActionCloseFilterConditionOutput) Key() pulumi.StringPtrOutput

func (IntegrationActionCloseFilterConditionOutput) Not 

func (o IntegrationActionCloseFilterConditionOutput) Not() pulumi.BoolPtrOutput

func (IntegrationActionCloseFilterConditionOutput) Operation 

func (o IntegrationActionCloseFilterConditionOutput) Operation() pulumi.StringOutput

func (IntegrationActionCloseFilterConditionOutput) Order 

func (o IntegrationActionCloseFilterConditionOutput) Order() pulumi.IntPtrOutput

Integer value that defines in which order the action will be performed. Default: `1`.

func (IntegrationActionCloseFilterConditionOutput) ToIntegrationActionCloseFilterConditionOutput 

func (o IntegrationActionCloseFilterConditionOutput) ToIntegrationActionCloseFilterConditionOutput() IntegrationActionCloseFilterConditionOutput

func (IntegrationActionCloseFilterConditionOutput) ToIntegrationActionCloseFilterConditionOutputWithContext 

func (o IntegrationActionCloseFilterConditionOutput) ToIntegrationActionCloseFilterConditionOutputWithContext(ctx context.Context) IntegrationActionCloseFilterConditionOutput

type IntegrationActionCloseFilterInput 

type IntegrationActionCloseFilterInput interface {
	pulumi.Input

	ToIntegrationActionCloseFilterOutput() IntegrationActionCloseFilterOutput
	ToIntegrationActionCloseFilterOutputWithContext(context.Context) IntegrationActionCloseFilterOutput
}

IntegrationActionCloseFilterInput is an input type that accepts IntegrationActionCloseFilterArgs and IntegrationActionCloseFilterOutput values. You can construct a concrete instance of `IntegrationActionCloseFilterInput` via: 

IntegrationActionCloseFilterArgs{...}

type IntegrationActionCloseFilterOutput 

type IntegrationActionCloseFilterOutput struct{ *pulumi.OutputState }

func (IntegrationActionCloseFilterOutput) Conditions 

func (o IntegrationActionCloseFilterOutput) Conditions() IntegrationActionCloseFilterConditionArrayOutput

func (IntegrationActionCloseFilterOutput) ElementType 

func (IntegrationActionCloseFilterOutput) ElementType() reflect.Type

func (IntegrationActionCloseFilterOutput) ToIntegrationActionCloseFilterOutput 

func (o IntegrationActionCloseFilterOutput) ToIntegrationActionCloseFilterOutput() IntegrationActionCloseFilterOutput

func (IntegrationActionCloseFilterOutput) ToIntegrationActionCloseFilterOutputWithContext 

func (o IntegrationActionCloseFilterOutput) ToIntegrationActionCloseFilterOutputWithContext(ctx context.Context) IntegrationActionCloseFilterOutput

func (IntegrationActionCloseFilterOutput) Type 

func (o IntegrationActionCloseFilterOutput) Type() pulumi.StringOutput

type IntegrationActionCloseInput 

type IntegrationActionCloseInput interface {
	pulumi.Input

	ToIntegrationActionCloseOutput() IntegrationActionCloseOutput
	ToIntegrationActionCloseOutputWithContext(context.Context) IntegrationActionCloseOutput
}

IntegrationActionCloseInput is an input type that accepts IntegrationActionCloseArgs and IntegrationActionCloseOutput values. You can construct a concrete instance of `IntegrationActionCloseInput` via: 

IntegrationActionCloseArgs{...}

type IntegrationActionCloseOutput 

type IntegrationActionCloseOutput struct{ *pulumi.OutputState }

func (IntegrationActionCloseOutput) Alias 

func (o IntegrationActionCloseOutput) Alias() pulumi.StringPtrOutput

An identifier that is used for alert deduplication. Default: `{{alias}}`.

func (IntegrationActionCloseOutput) ElementType 

func (IntegrationActionCloseOutput) ElementType() reflect.Type

func (IntegrationActionCloseOutput) Filters 

func (o IntegrationActionCloseOutput) Filters() IntegrationActionCloseFilterArrayOutput

Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are: * For SNS integration: `actions`, `alias`, `entity`, `Message`, `recipients`, `responders`, `Subject`, `tags`, `teams`, `eventType`, `Timestamp`, `TopicArn`. * For API integration: `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `recipients`, `teams`, `priority`, `eventType`. * For Email integration: `fromAddress`, `fromName`, `conversationSubject`, `subject`

func (IntegrationActionCloseOutput) Name 

func (o IntegrationActionCloseOutput) Name() pulumi.StringOutput

Name of the integration action.

func (IntegrationActionCloseOutput) Note 

func (o IntegrationActionCloseOutput) Note() pulumi.StringPtrOutput

Additional alert action note.

func (IntegrationActionCloseOutput) Order 

func (o IntegrationActionCloseOutput) Order() pulumi.IntPtrOutput

Integer value that defines in which order the action will be performed. Default: `1`.

func (IntegrationActionCloseOutput) ToIntegrationActionCloseOutput 

func (o IntegrationActionCloseOutput) ToIntegrationActionCloseOutput() IntegrationActionCloseOutput

func (IntegrationActionCloseOutput) ToIntegrationActionCloseOutputWithContext 

func (o IntegrationActionCloseOutput) ToIntegrationActionCloseOutputWithContext(ctx context.Context) IntegrationActionCloseOutput

func (IntegrationActionCloseOutput) Type 

func (o IntegrationActionCloseOutput) Type() pulumi.StringPtrOutput

func (IntegrationActionCloseOutput) User 

func (o IntegrationActionCloseOutput) User() pulumi.StringPtrOutput

Owner of the execution for integration action.

type IntegrationActionCreate 

type IntegrationActionCreate struct {
	AlertActions []string `pulumi:"alertActions"`
	// An identifier that is used for alert deduplication. Default: `{{alias}}`.
	Alias             *string           `pulumi:"alias"`
	AppendAttachments *bool             `pulumi:"appendAttachments"`
	CustomPriority    *string           `pulumi:"customPriority"`
	Description       *string           `pulumi:"description"`
	Entity            *string           `pulumi:"entity"`
	ExtraProperties   map[string]string `pulumi:"extraProperties"`
	// Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:
	// * For SNS integration: `actions`, `alias`, `entity`, `Message`, `recipients`, `responders`, `Subject`, `tags`, `teams`, `eventType`, `Timestamp`, `TopicArn`.
	// * For API integration: `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `recipients`, `teams`, `priority`, `eventType`.
	// * For Email integration: `fromAddress`, `fromName`, `conversationSubject`, `subject`
	Filters                          []IntegrationActionCreateFilter `pulumi:"filters"`
	IgnoreAlertActionsFromPayload    *bool                           `pulumi:"ignoreAlertActionsFromPayload"`
	IgnoreExtraPropertiesFromPayload *bool                           `pulumi:"ignoreExtraPropertiesFromPayload"`
	IgnoreRespondersFromPayload      *bool                           `pulumi:"ignoreRespondersFromPayload"`
	IgnoreTagsFromPayload            *bool                           `pulumi:"ignoreTagsFromPayload"`
	IgnoreTeamsFromPayload           *bool                           `pulumi:"ignoreTeamsFromPayload"`
	Message                          *string                         `pulumi:"message"`
	// Name of the integration action.
	Name string `pulumi:"name"`
	// Additional alert action note.
	Note *string `pulumi:"note"`
	// Integer value that defines in which order the action will be performed. Default: `1`.
	Order      *int                               `pulumi:"order"`
	Priority   *string                            `pulumi:"priority"`
	Responders []IntegrationActionCreateResponder `pulumi:"responders"`
	Source     *string                            `pulumi:"source"`
	Tags       []string                           `pulumi:"tags"`
	Type       *string                            `pulumi:"type"`
	// Owner of the execution for integration action.
	User *string `pulumi:"user"`
}

type IntegrationActionCreateArgs 

type IntegrationActionCreateArgs struct {
	AlertActions pulumi.StringArrayInput `pulumi:"alertActions"`
	// An identifier that is used for alert deduplication. Default: `{{alias}}`.
	Alias             pulumi.StringPtrInput `pulumi:"alias"`
	AppendAttachments pulumi.BoolPtrInput   `pulumi:"appendAttachments"`
	CustomPriority    pulumi.StringPtrInput `pulumi:"customPriority"`
	Description       pulumi.StringPtrInput `pulumi:"description"`
	Entity            pulumi.StringPtrInput `pulumi:"entity"`
	ExtraProperties   pulumi.StringMapInput `pulumi:"extraProperties"`
	// Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:
	// * For SNS integration: `actions`, `alias`, `entity`, `Message`, `recipients`, `responders`, `Subject`, `tags`, `teams`, `eventType`, `Timestamp`, `TopicArn`.
	// * For API integration: `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `recipients`, `teams`, `priority`, `eventType`.
	// * For Email integration: `fromAddress`, `fromName`, `conversationSubject`, `subject`
	Filters                          IntegrationActionCreateFilterArrayInput `pulumi:"filters"`
	IgnoreAlertActionsFromPayload    pulumi.BoolPtrInput                     `pulumi:"ignoreAlertActionsFromPayload"`
	IgnoreExtraPropertiesFromPayload pulumi.BoolPtrInput                     `pulumi:"ignoreExtraPropertiesFromPayload"`
	IgnoreRespondersFromPayload      pulumi.BoolPtrInput                     `pulumi:"ignoreRespondersFromPayload"`
	IgnoreTagsFromPayload            pulumi.BoolPtrInput                     `pulumi:"ignoreTagsFromPayload"`
	IgnoreTeamsFromPayload           pulumi.BoolPtrInput                     `pulumi:"ignoreTeamsFromPayload"`
	Message                          pulumi.StringPtrInput                   `pulumi:"message"`
	// Name of the integration action.
	Name pulumi.StringInput `pulumi:"name"`
	// Additional alert action note.
	Note pulumi.StringPtrInput `pulumi:"note"`
	// Integer value that defines in which order the action will be performed. Default: `1`.
	Order      pulumi.IntPtrInput                         `pulumi:"order"`
	Priority   pulumi.StringPtrInput                      `pulumi:"priority"`
	Responders IntegrationActionCreateResponderArrayInput `pulumi:"responders"`
	Source     pulumi.StringPtrInput                      `pulumi:"source"`
	Tags       pulumi.StringArrayInput                    `pulumi:"tags"`
	Type       pulumi.StringPtrInput                      `pulumi:"type"`
	// Owner of the execution for integration action.
	User pulumi.StringPtrInput `pulumi:"user"`
}

func (IntegrationActionCreateArgs) ElementType 

func (IntegrationActionCreateArgs) ElementType() reflect.Type

func (IntegrationActionCreateArgs) ToIntegrationActionCreateOutput 

func (i IntegrationActionCreateArgs) ToIntegrationActionCreateOutput() IntegrationActionCreateOutput

func (IntegrationActionCreateArgs) ToIntegrationActionCreateOutputWithContext 

func (i IntegrationActionCreateArgs) ToIntegrationActionCreateOutputWithContext(ctx context.Context) IntegrationActionCreateOutput

type IntegrationActionCreateArray 

type IntegrationActionCreateArray []IntegrationActionCreateInput

func (IntegrationActionCreateArray) ElementType 

func (IntegrationActionCreateArray) ElementType() reflect.Type

func (IntegrationActionCreateArray) ToIntegrationActionCreateArrayOutput 

func (i IntegrationActionCreateArray) ToIntegrationActionCreateArrayOutput() IntegrationActionCreateArrayOutput

func (IntegrationActionCreateArray) ToIntegrationActionCreateArrayOutputWithContext 

func (i IntegrationActionCreateArray) ToIntegrationActionCreateArrayOutputWithContext(ctx context.Context) IntegrationActionCreateArrayOutput

type IntegrationActionCreateArrayInput 

type IntegrationActionCreateArrayInput interface {
	pulumi.Input

	ToIntegrationActionCreateArrayOutput() IntegrationActionCreateArrayOutput
	ToIntegrationActionCreateArrayOutputWithContext(context.Context) IntegrationActionCreateArrayOutput
}

IntegrationActionCreateArrayInput is an input type that accepts IntegrationActionCreateArray and IntegrationActionCreateArrayOutput values. You can construct a concrete instance of `IntegrationActionCreateArrayInput` via: 

IntegrationActionCreateArray{ IntegrationActionCreateArgs{...} }

type IntegrationActionCreateArrayOutput 

type IntegrationActionCreateArrayOutput struct{ *pulumi.OutputState }

func (IntegrationActionCreateArrayOutput) ElementType 

func (IntegrationActionCreateArrayOutput) ElementType() reflect.Type

func (IntegrationActionCreateArrayOutput) Index 

func (o IntegrationActionCreateArrayOutput) Index(i pulumi.IntInput) IntegrationActionCreateOutput

func (IntegrationActionCreateArrayOutput) ToIntegrationActionCreateArrayOutput 

func (o IntegrationActionCreateArrayOutput) ToIntegrationActionCreateArrayOutput() IntegrationActionCreateArrayOutput

func (IntegrationActionCreateArrayOutput) ToIntegrationActionCreateArrayOutputWithContext 

func (o IntegrationActionCreateArrayOutput) ToIntegrationActionCreateArrayOutputWithContext(ctx context.Context) IntegrationActionCreateArrayOutput

type IntegrationActionCreateFilter 

type IntegrationActionCreateFilter struct {
	Conditions []IntegrationActionCreateFilterCondition `pulumi:"conditions"`
	Type       string                                   `pulumi:"type"`
}

type IntegrationActionCreateFilterArgs 

type IntegrationActionCreateFilterArgs struct {
	Conditions IntegrationActionCreateFilterConditionArrayInput `pulumi:"conditions"`
	Type       pulumi.StringInput                               `pulumi:"type"`
}

func (IntegrationActionCreateFilterArgs) ElementType 

func (IntegrationActionCreateFilterArgs) ElementType() reflect.Type

func (IntegrationActionCreateFilterArgs) ToIntegrationActionCreateFilterOutput 

func (i IntegrationActionCreateFilterArgs) ToIntegrationActionCreateFilterOutput() IntegrationActionCreateFilterOutput

func (IntegrationActionCreateFilterArgs) ToIntegrationActionCreateFilterOutputWithContext 

func (i IntegrationActionCreateFilterArgs) ToIntegrationActionCreateFilterOutputWithContext(ctx context.Context) IntegrationActionCreateFilterOutput

type IntegrationActionCreateFilterArray 

type IntegrationActionCreateFilterArray []IntegrationActionCreateFilterInput

func (IntegrationActionCreateFilterArray) ElementType 

func (IntegrationActionCreateFilterArray) ElementType() reflect.Type

func (IntegrationActionCreateFilterArray) ToIntegrationActionCreateFilterArrayOutput 

func (i IntegrationActionCreateFilterArray) ToIntegrationActionCreateFilterArrayOutput() IntegrationActionCreateFilterArrayOutput

func (IntegrationActionCreateFilterArray) ToIntegrationActionCreateFilterArrayOutputWithContext 

func (i IntegrationActionCreateFilterArray) ToIntegrationActionCreateFilterArrayOutputWithContext(ctx context.Context) IntegrationActionCreateFilterArrayOutput

type IntegrationActionCreateFilterArrayInput 

type IntegrationActionCreateFilterArrayInput interface {
	pulumi.Input

	ToIntegrationActionCreateFilterArrayOutput() IntegrationActionCreateFilterArrayOutput
	ToIntegrationActionCreateFilterArrayOutputWithContext(context.Context) IntegrationActionCreateFilterArrayOutput
}

IntegrationActionCreateFilterArrayInput is an input type that accepts IntegrationActionCreateFilterArray and IntegrationActionCreateFilterArrayOutput values. You can construct a concrete instance of `IntegrationActionCreateFilterArrayInput` via: 

IntegrationActionCreateFilterArray{ IntegrationActionCreateFilterArgs{...} }

type IntegrationActionCreateFilterArrayOutput 

type IntegrationActionCreateFilterArrayOutput struct{ *pulumi.OutputState }

func (IntegrationActionCreateFilterArrayOutput) ElementType 

func (IntegrationActionCreateFilterArrayOutput) ElementType() reflect.Type

func (IntegrationActionCreateFilterArrayOutput) Index 

func (o IntegrationActionCreateFilterArrayOutput) Index(i pulumi.IntInput) IntegrationActionCreateFilterOutput

func (IntegrationActionCreateFilterArrayOutput) ToIntegrationActionCreateFilterArrayOutput 

func (o IntegrationActionCreateFilterArrayOutput) ToIntegrationActionCreateFilterArrayOutput() IntegrationActionCreateFilterArrayOutput

func (IntegrationActionCreateFilterArrayOutput) ToIntegrationActionCreateFilterArrayOutputWithContext 

func (o IntegrationActionCreateFilterArrayOutput) ToIntegrationActionCreateFilterArrayOutputWithContext(ctx context.Context) IntegrationActionCreateFilterArrayOutput

type IntegrationActionCreateFilterCondition 

type IntegrationActionCreateFilterCondition struct {
	ExpectedValue *string `pulumi:"expectedValue"`
	Field         string  `pulumi:"field"`
	Key           *string `pulumi:"key"`
	Not           *bool   `pulumi:"not"`
	Operation     string  `pulumi:"operation"`
	// Integer value that defines in which order the action will be performed. Default: `1`.
	Order *int `pulumi:"order"`
}

type IntegrationActionCreateFilterConditionArgs 

type IntegrationActionCreateFilterConditionArgs struct {
	ExpectedValue pulumi.StringPtrInput `pulumi:"expectedValue"`
	Field         pulumi.StringInput    `pulumi:"field"`
	Key           pulumi.StringPtrInput `pulumi:"key"`
	Not           pulumi.BoolPtrInput   `pulumi:"not"`
	Operation     pulumi.StringInput    `pulumi:"operation"`
	// Integer value that defines in which order the action will be performed. Default: `1`.
	Order pulumi.IntPtrInput `pulumi:"order"`
}

func (IntegrationActionCreateFilterConditionArgs) ElementType 

func (IntegrationActionCreateFilterConditionArgs) ElementType() reflect.Type

func (IntegrationActionCreateFilterConditionArgs) ToIntegrationActionCreateFilterConditionOutput 

func (i IntegrationActionCreateFilterConditionArgs) ToIntegrationActionCreateFilterConditionOutput() IntegrationActionCreateFilterConditionOutput

func (IntegrationActionCreateFilterConditionArgs) ToIntegrationActionCreateFilterConditionOutputWithContext 

func (i IntegrationActionCreateFilterConditionArgs) ToIntegrationActionCreateFilterConditionOutputWithContext(ctx context.Context) IntegrationActionCreateFilterConditionOutput

type IntegrationActionCreateFilterConditionArray 

type IntegrationActionCreateFilterConditionArray []IntegrationActionCreateFilterConditionInput

func (IntegrationActionCreateFilterConditionArray) ElementType 

func (IntegrationActionCreateFilterConditionArray) ElementType() reflect.Type

func (IntegrationActionCreateFilterConditionArray) ToIntegrationActionCreateFilterConditionArrayOutput 

func (i IntegrationActionCreateFilterConditionArray) ToIntegrationActionCreateFilterConditionArrayOutput() IntegrationActionCreateFilterConditionArrayOutput

func (IntegrationActionCreateFilterConditionArray) ToIntegrationActionCreateFilterConditionArrayOutputWithContext 

func (i IntegrationActionCreateFilterConditionArray) ToIntegrationActionCreateFilterConditionArrayOutputWithContext(ctx context.Context) IntegrationActionCreateFilterConditionArrayOutput

type IntegrationActionCreateFilterConditionArrayInput 

type IntegrationActionCreateFilterConditionArrayInput interface {
	pulumi.Input

	ToIntegrationActionCreateFilterConditionArrayOutput() IntegrationActionCreateFilterConditionArrayOutput
	ToIntegrationActionCreateFilterConditionArrayOutputWithContext(context.Context) IntegrationActionCreateFilterConditionArrayOutput
}

IntegrationActionCreateFilterConditionArrayInput is an input type that accepts IntegrationActionCreateFilterConditionArray and IntegrationActionCreateFilterConditionArrayOutput values. You can construct a concrete instance of `IntegrationActionCreateFilterConditionArrayInput` via: 

IntegrationActionCreateFilterConditionArray{ IntegrationActionCreateFilterConditionArgs{...} }

type IntegrationActionCreateFilterConditionArrayOutput 

type IntegrationActionCreateFilterConditionArrayOutput struct{ *pulumi.OutputState }

func (IntegrationActionCreateFilterConditionArrayOutput) ElementType 

func (IntegrationActionCreateFilterConditionArrayOutput) ElementType() reflect.Type

func (IntegrationActionCreateFilterConditionArrayOutput) Index 

func (o IntegrationActionCreateFilterConditionArrayOutput) Index(i pulumi.IntInput) IntegrationActionCreateFilterConditionOutput

func (IntegrationActionCreateFilterConditionArrayOutput) ToIntegrationActionCreateFilterConditionArrayOutput 

func (o IntegrationActionCreateFilterConditionArrayOutput) ToIntegrationActionCreateFilterConditionArrayOutput() IntegrationActionCreateFilterConditionArrayOutput

func (IntegrationActionCreateFilterConditionArrayOutput) ToIntegrationActionCreateFilterConditionArrayOutputWithContext 

func (o IntegrationActionCreateFilterConditionArrayOutput) ToIntegrationActionCreateFilterConditionArrayOutputWithContext(ctx context.Context) IntegrationActionCreateFilterConditionArrayOutput

type IntegrationActionCreateFilterConditionInput 

type IntegrationActionCreateFilterConditionInput interface {
	pulumi.Input

	ToIntegrationActionCreateFilterConditionOutput() IntegrationActionCreateFilterConditionOutput
	ToIntegrationActionCreateFilterConditionOutputWithContext(context.Context) IntegrationActionCreateFilterConditionOutput
}

IntegrationActionCreateFilterConditionInput is an input type that accepts IntegrationActionCreateFilterConditionArgs and IntegrationActionCreateFilterConditionOutput values. You can construct a concrete instance of `IntegrationActionCreateFilterConditionInput` via: 

IntegrationActionCreateFilterConditionArgs{...}

type IntegrationActionCreateFilterConditionOutput 

type IntegrationActionCreateFilterConditionOutput struct{ *pulumi.OutputState }

func (IntegrationActionCreateFilterConditionOutput) ElementType 

func (IntegrationActionCreateFilterConditionOutput) ElementType() reflect.Type

func (IntegrationActionCreateFilterConditionOutput) ExpectedValue 

func (o IntegrationActionCreateFilterConditionOutput) ExpectedValue() pulumi.StringPtrOutput

func (IntegrationActionCreateFilterConditionOutput) Field 

func (o IntegrationActionCreateFilterConditionOutput) Field() pulumi.StringOutput

func (IntegrationActionCreateFilterConditionOutput) Key 

func (o IntegrationActionCreateFilterConditionOutput) Key() pulumi.StringPtrOutput

func (IntegrationActionCreateFilterConditionOutput) Not 

func (o IntegrationActionCreateFilterConditionOutput) Not() pulumi.BoolPtrOutput

func (IntegrationActionCreateFilterConditionOutput) Operation 

func (o IntegrationActionCreateFilterConditionOutput) Operation() pulumi.StringOutput

func (IntegrationActionCreateFilterConditionOutput) Order 

func (o IntegrationActionCreateFilterConditionOutput) Order() pulumi.IntPtrOutput

Integer value that defines in which order the action will be performed. Default: `1`.

func (IntegrationActionCreateFilterConditionOutput) ToIntegrationActionCreateFilterConditionOutput 

func (o IntegrationActionCreateFilterConditionOutput) ToIntegrationActionCreateFilterConditionOutput() IntegrationActionCreateFilterConditionOutput

func (IntegrationActionCreateFilterConditionOutput) ToIntegrationActionCreateFilterConditionOutputWithContext 

func (o IntegrationActionCreateFilterConditionOutput) ToIntegrationActionCreateFilterConditionOutputWithContext(ctx context.Context) IntegrationActionCreateFilterConditionOutput

type IntegrationActionCreateFilterInput 

type IntegrationActionCreateFilterInput interface {
	pulumi.Input

	ToIntegrationActionCreateFilterOutput() IntegrationActionCreateFilterOutput
	ToIntegrationActionCreateFilterOutputWithContext(context.Context) IntegrationActionCreateFilterOutput
}

IntegrationActionCreateFilterInput is an input type that accepts IntegrationActionCreateFilterArgs and IntegrationActionCreateFilterOutput values. You can construct a concrete instance of `IntegrationActionCreateFilterInput` via: 

IntegrationActionCreateFilterArgs{...}

type IntegrationActionCreateFilterOutput 

type IntegrationActionCreateFilterOutput struct{ *pulumi.OutputState }

func (IntegrationActionCreateFilterOutput) Conditions 

func (o IntegrationActionCreateFilterOutput) Conditions() IntegrationActionCreateFilterConditionArrayOutput

func (IntegrationActionCreateFilterOutput) ElementType 

func (IntegrationActionCreateFilterOutput) ElementType() reflect.Type

func (IntegrationActionCreateFilterOutput) ToIntegrationActionCreateFilterOutput 

func (o IntegrationActionCreateFilterOutput) ToIntegrationActionCreateFilterOutput() IntegrationActionCreateFilterOutput

func (IntegrationActionCreateFilterOutput) ToIntegrationActionCreateFilterOutputWithContext 

func (o IntegrationActionCreateFilterOutput) ToIntegrationActionCreateFilterOutputWithContext(ctx context.Context) IntegrationActionCreateFilterOutput

func (IntegrationActionCreateFilterOutput) Type 

func (o IntegrationActionCreateFilterOutput) Type() pulumi.StringOutput

type IntegrationActionCreateInput 

type IntegrationActionCreateInput interface {
	pulumi.Input

	ToIntegrationActionCreateOutput() IntegrationActionCreateOutput
	ToIntegrationActionCreateOutputWithContext(context.Context) IntegrationActionCreateOutput
}

IntegrationActionCreateInput is an input type that accepts IntegrationActionCreateArgs and IntegrationActionCreateOutput values. You can construct a concrete instance of `IntegrationActionCreateInput` via: 

IntegrationActionCreateArgs{...}

type IntegrationActionCreateOutput 

type IntegrationActionCreateOutput struct{ *pulumi.OutputState }

func (IntegrationActionCreateOutput) AlertActions 

func (o IntegrationActionCreateOutput) AlertActions() pulumi.StringArrayOutput

func (IntegrationActionCreateOutput) Alias 

func (o IntegrationActionCreateOutput) Alias() pulumi.StringPtrOutput

An identifier that is used for alert deduplication. Default: `{{alias}}`.

func (IntegrationActionCreateOutput) AppendAttachments 

func (o IntegrationActionCreateOutput) AppendAttachments() pulumi.BoolPtrOutput

func (IntegrationActionCreateOutput) CustomPriority 

func (o IntegrationActionCreateOutput) CustomPriority() pulumi.StringPtrOutput

func (IntegrationActionCreateOutput) Description 

func (o IntegrationActionCreateOutput) Description() pulumi.StringPtrOutput

func (IntegrationActionCreateOutput) ElementType 

func (IntegrationActionCreateOutput) ElementType() reflect.Type

func (IntegrationActionCreateOutput) Entity 

func (o IntegrationActionCreateOutput) Entity() pulumi.StringPtrOutput

func (IntegrationActionCreateOutput) ExtraProperties 

func (o IntegrationActionCreateOutput) ExtraProperties() pulumi.StringMapOutput

func (IntegrationActionCreateOutput) Filters 

func (o IntegrationActionCreateOutput) Filters() IntegrationActionCreateFilterArrayOutput

Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are: * For SNS integration: `actions`, `alias`, `entity`, `Message`, `recipients`, `responders`, `Subject`, `tags`, `teams`, `eventType`, `Timestamp`, `TopicArn`. * For API integration: `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `recipients`, `teams`, `priority`, `eventType`. * For Email integration: `fromAddress`, `fromName`, `conversationSubject`, `subject`

func (IntegrationActionCreateOutput) IgnoreAlertActionsFromPayload 

func (o IntegrationActionCreateOutput) IgnoreAlertActionsFromPayload() pulumi.BoolPtrOutput

func (IntegrationActionCreateOutput) IgnoreExtraPropertiesFromPayload 

func (o IntegrationActionCreateOutput) IgnoreExtraPropertiesFromPayload() pulumi.BoolPtrOutput

func (IntegrationActionCreateOutput) IgnoreRespondersFromPayload 

func (o IntegrationActionCreateOutput) IgnoreRespondersFromPayload() pulumi.BoolPtrOutput

func (IntegrationActionCreateOutput) IgnoreTagsFromPayload 

func (o IntegrationActionCreateOutput) IgnoreTagsFromPayload() pulumi.BoolPtrOutput

func (IntegrationActionCreateOutput) IgnoreTeamsFromPayload 

func (o IntegrationActionCreateOutput) IgnoreTeamsFromPayload() pulumi.BoolPtrOutput

func (IntegrationActionCreateOutput) Message 

func (o IntegrationActionCreateOutput) Message() pulumi.StringPtrOutput

func (IntegrationActionCreateOutput) Name 

func (o IntegrationActionCreateOutput) Name() pulumi.StringOutput

Name of the integration action.

func (IntegrationActionCreateOutput) Note 

func (o IntegrationActionCreateOutput) Note() pulumi.StringPtrOutput

Additional alert action note.

func (IntegrationActionCreateOutput) Order 

func (o IntegrationActionCreateOutput) Order() pulumi.IntPtrOutput

Integer value that defines in which order the action will be performed. Default: `1`.

func (IntegrationActionCreateOutput) Priority 

func (o IntegrationActionCreateOutput) Priority() pulumi.StringPtrOutput

func (IntegrationActionCreateOutput) Responders 

func (o IntegrationActionCreateOutput) Responders() IntegrationActionCreateResponderArrayOutput

func (IntegrationActionCreateOutput) Source 

func (o IntegrationActionCreateOutput) Source() pulumi.StringPtrOutput

func (IntegrationActionCreateOutput) Tags 

func (o IntegrationActionCreateOutput) Tags() pulumi.StringArrayOutput

func (IntegrationActionCreateOutput) ToIntegrationActionCreateOutput 

func (o IntegrationActionCreateOutput) ToIntegrationActionCreateOutput() IntegrationActionCreateOutput

func (IntegrationActionCreateOutput) ToIntegrationActionCreateOutputWithContext 

func (o IntegrationActionCreateOutput) ToIntegrationActionCreateOutputWithContext(ctx context.Context) IntegrationActionCreateOutput

func (IntegrationActionCreateOutput) Type 

func (o IntegrationActionCreateOutput) Type() pulumi.StringPtrOutput

func (IntegrationActionCreateOutput) User 

func (o IntegrationActionCreateOutput) User() pulumi.StringPtrOutput

Owner of the execution for integration action.

type IntegrationActionCreateResponder 

type IntegrationActionCreateResponder struct {
	// The id of the responder.
	Id string `pulumi:"id"`
	// The responder type - can be `escalation`, `team` or `user`.
	Type string `pulumi:"type"`
}

type IntegrationActionCreateResponderArgs 

type IntegrationActionCreateResponderArgs struct {
	// The id of the responder.
	Id pulumi.StringInput `pulumi:"id"`
	// The responder type - can be `escalation`, `team` or `user`.
	Type pulumi.StringInput `pulumi:"type"`
}

func (IntegrationActionCreateResponderArgs) ElementType 

func (IntegrationActionCreateResponderArgs) ElementType() reflect.Type

func (IntegrationActionCreateResponderArgs) ToIntegrationActionCreateResponderOutput 

func (i IntegrationActionCreateResponderArgs) ToIntegrationActionCreateResponderOutput() IntegrationActionCreateResponderOutput

func (IntegrationActionCreateResponderArgs) ToIntegrationActionCreateResponderOutputWithContext 

func (i IntegrationActionCreateResponderArgs) ToIntegrationActionCreateResponderOutputWithContext(ctx context.Context) IntegrationActionCreateResponderOutput

type IntegrationActionCreateResponderArray 

type IntegrationActionCreateResponderArray []IntegrationActionCreateResponderInput

func (IntegrationActionCreateResponderArray) ElementType 

func (IntegrationActionCreateResponderArray) ElementType() reflect.Type

func (IntegrationActionCreateResponderArray) ToIntegrationActionCreateResponderArrayOutput 

func (i IntegrationActionCreateResponderArray) ToIntegrationActionCreateResponderArrayOutput() IntegrationActionCreateResponderArrayOutput

func (IntegrationActionCreateResponderArray) ToIntegrationActionCreateResponderArrayOutputWithContext 

func (i IntegrationActionCreateResponderArray) ToIntegrationActionCreateResponderArrayOutputWithContext(ctx context.Context) IntegrationActionCreateResponderArrayOutput

type IntegrationActionCreateResponderArrayInput 

type IntegrationActionCreateResponderArrayInput interface {
	pulumi.Input

	ToIntegrationActionCreateResponderArrayOutput() IntegrationActionCreateResponderArrayOutput
	ToIntegrationActionCreateResponderArrayOutputWithContext(context.Context) IntegrationActionCreateResponderArrayOutput
}

IntegrationActionCreateResponderArrayInput is an input type that accepts IntegrationActionCreateResponderArray and IntegrationActionCreateResponderArrayOutput values. You can construct a concrete instance of `IntegrationActionCreateResponderArrayInput` via: 

IntegrationActionCreateResponderArray{ IntegrationActionCreateResponderArgs{...} }

type IntegrationActionCreateResponderArrayOutput 

type IntegrationActionCreateResponderArrayOutput struct{ *pulumi.OutputState }

func (IntegrationActionCreateResponderArrayOutput) ElementType 

func (IntegrationActionCreateResponderArrayOutput) ElementType() reflect.Type

func (IntegrationActionCreateResponderArrayOutput) Index 

func (o IntegrationActionCreateResponderArrayOutput) Index(i pulumi.IntInput) IntegrationActionCreateResponderOutput

func (IntegrationActionCreateResponderArrayOutput) ToIntegrationActionCreateResponderArrayOutput 

func (o IntegrationActionCreateResponderArrayOutput) ToIntegrationActionCreateResponderArrayOutput() IntegrationActionCreateResponderArrayOutput

func (IntegrationActionCreateResponderArrayOutput) ToIntegrationActionCreateResponderArrayOutputWithContext 

func (o IntegrationActionCreateResponderArrayOutput) ToIntegrationActionCreateResponderArrayOutputWithContext(ctx context.Context) IntegrationActionCreateResponderArrayOutput

type IntegrationActionCreateResponderInput 

type IntegrationActionCreateResponderInput interface {
	pulumi.Input

	ToIntegrationActionCreateResponderOutput() IntegrationActionCreateResponderOutput
	ToIntegrationActionCreateResponderOutputWithContext(context.Context) IntegrationActionCreateResponderOutput
}

IntegrationActionCreateResponderInput is an input type that accepts IntegrationActionCreateResponderArgs and IntegrationActionCreateResponderOutput values. You can construct a concrete instance of `IntegrationActionCreateResponderInput` via: 

IntegrationActionCreateResponderArgs{...}

type IntegrationActionCreateResponderOutput 

type IntegrationActionCreateResponderOutput struct{ *pulumi.OutputState }

func (IntegrationActionCreateResponderOutput) ElementType 

func (IntegrationActionCreateResponderOutput) ElementType() reflect.Type

func (IntegrationActionCreateResponderOutput) Id 

func (o IntegrationActionCreateResponderOutput) Id() pulumi.StringOutput

The id of the responder.

func (IntegrationActionCreateResponderOutput) ToIntegrationActionCreateResponderOutput 

func (o IntegrationActionCreateResponderOutput) ToIntegrationActionCreateResponderOutput() IntegrationActionCreateResponderOutput

func (IntegrationActionCreateResponderOutput) ToIntegrationActionCreateResponderOutputWithContext 

func (o IntegrationActionCreateResponderOutput) ToIntegrationActionCreateResponderOutputWithContext(ctx context.Context) IntegrationActionCreateResponderOutput

func (IntegrationActionCreateResponderOutput) Type 

func (o IntegrationActionCreateResponderOutput) Type() pulumi.StringOutput

The responder type - can be `escalation`, `team` or `user`.

type IntegrationActionIgnore 

type IntegrationActionIgnore struct {
	// Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:
	// * For SNS integration: `actions`, `alias`, `entity`, `Message`, `recipients`, `responders`, `Subject`, `tags`, `teams`, `eventType`, `Timestamp`, `TopicArn`.
	// * For API integration: `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `recipients`, `teams`, `priority`, `eventType`.
	// * For Email integration: `fromAddress`, `fromName`, `conversationSubject`, `subject`
	Filters []IntegrationActionIgnoreFilter `pulumi:"filters"`
	// Name of the integration action.
	Name string `pulumi:"name"`
	// Integer value that defines in which order the action will be performed. Default: `1`.
	Order *int    `pulumi:"order"`
	Type  *string `pulumi:"type"`
}

type IntegrationActionIgnoreArgs 

type IntegrationActionIgnoreArgs struct {
	// Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are:
	// * For SNS integration: `actions`, `alias`, `entity`, `Message`, `recipients`, `responders`, `Subject`, `tags`, `teams`, `eventType`, `Timestamp`, `TopicArn`.
	// * For API integration: `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `recipients`, `teams`, `priority`, `eventType`.
	// * For Email integration: `fromAddress`, `fromName`, `conversationSubject`, `subject`
	Filters IntegrationActionIgnoreFilterArrayInput `pulumi:"filters"`
	// Name of the integration action.
	Name pulumi.StringInput `pulumi:"name"`
	// Integer value that defines in which order the action will be performed. Default: `1`.
	Order pulumi.IntPtrInput    `pulumi:"order"`
	Type  pulumi.StringPtrInput `pulumi:"type"`
}

func (IntegrationActionIgnoreArgs) ElementType 

func (IntegrationActionIgnoreArgs) ElementType() reflect.Type

func (IntegrationActionIgnoreArgs) ToIntegrationActionIgnoreOutput 

func (i IntegrationActionIgnoreArgs) ToIntegrationActionIgnoreOutput() IntegrationActionIgnoreOutput

func (IntegrationActionIgnoreArgs) ToIntegrationActionIgnoreOutputWithContext 

func (i IntegrationActionIgnoreArgs) ToIntegrationActionIgnoreOutputWithContext(ctx context.Context) IntegrationActionIgnoreOutput

type IntegrationActionIgnoreArray 

type IntegrationActionIgnoreArray []IntegrationActionIgnoreInput

func (IntegrationActionIgnoreArray) ElementType 

func (IntegrationActionIgnoreArray) ElementType() reflect.Type

func (IntegrationActionIgnoreArray) ToIntegrationActionIgnoreArrayOutput 

func (i IntegrationActionIgnoreArray) ToIntegrationActionIgnoreArrayOutput() IntegrationActionIgnoreArrayOutput

func (IntegrationActionIgnoreArray) ToIntegrationActionIgnoreArrayOutputWithContext 

func (i IntegrationActionIgnoreArray) ToIntegrationActionIgnoreArrayOutputWithContext(ctx context.Context) IntegrationActionIgnoreArrayOutput

type IntegrationActionIgnoreArrayInput 

type IntegrationActionIgnoreArrayInput interface {
	pulumi.Input

	ToIntegrationActionIgnoreArrayOutput() IntegrationActionIgnoreArrayOutput
	ToIntegrationActionIgnoreArrayOutputWithContext(context.Context) IntegrationActionIgnoreArrayOutput
}

IntegrationActionIgnoreArrayInput is an input type that accepts IntegrationActionIgnoreArray and IntegrationActionIgnoreArrayOutput values. You can construct a concrete instance of `IntegrationActionIgnoreArrayInput` via: 

IntegrationActionIgnoreArray{ IntegrationActionIgnoreArgs{...} }

type IntegrationActionIgnoreArrayOutput 

type IntegrationActionIgnoreArrayOutput struct{ *pulumi.OutputState }

func (IntegrationActionIgnoreArrayOutput) ElementType 

func (IntegrationActionIgnoreArrayOutput) ElementType() reflect.Type

func (IntegrationActionIgnoreArrayOutput) Index 

func (o IntegrationActionIgnoreArrayOutput) Index(i pulumi.IntInput) IntegrationActionIgnoreOutput

func (IntegrationActionIgnoreArrayOutput) ToIntegrationActionIgnoreArrayOutput 

func (o IntegrationActionIgnoreArrayOutput) ToIntegrationActionIgnoreArrayOutput() IntegrationActionIgnoreArrayOutput

func (IntegrationActionIgnoreArrayOutput) ToIntegrationActionIgnoreArrayOutputWithContext 

func (o IntegrationActionIgnoreArrayOutput) ToIntegrationActionIgnoreArrayOutputWithContext(ctx context.Context) IntegrationActionIgnoreArrayOutput

type IntegrationActionIgnoreFilter 

type IntegrationActionIgnoreFilter struct {
	Conditions []IntegrationActionIgnoreFilterCondition `pulumi:"conditions"`
	Type       string                                   `pulumi:"type"`
}

type IntegrationActionIgnoreFilterArgs 

type IntegrationActionIgnoreFilterArgs struct {
	Conditions IntegrationActionIgnoreFilterConditionArrayInput `pulumi:"conditions"`
	Type       pulumi.StringInput                               `pulumi:"type"`
}

func (IntegrationActionIgnoreFilterArgs) ElementType 

func (IntegrationActionIgnoreFilterArgs) ElementType() reflect.Type

func (IntegrationActionIgnoreFilterArgs) ToIntegrationActionIgnoreFilterOutput 

func (i IntegrationActionIgnoreFilterArgs) ToIntegrationActionIgnoreFilterOutput() IntegrationActionIgnoreFilterOutput

func (IntegrationActionIgnoreFilterArgs) ToIntegrationActionIgnoreFilterOutputWithContext 

func (i IntegrationActionIgnoreFilterArgs) ToIntegrationActionIgnoreFilterOutputWithContext(ctx context.Context) IntegrationActionIgnoreFilterOutput

type IntegrationActionIgnoreFilterArray 

type IntegrationActionIgnoreFilterArray []IntegrationActionIgnoreFilterInput

func (IntegrationActionIgnoreFilterArray) ElementType 

func (IntegrationActionIgnoreFilterArray) ElementType() reflect.Type

func (IntegrationActionIgnoreFilterArray) ToIntegrationActionIgnoreFilterArrayOutput 

func (i IntegrationActionIgnoreFilterArray) ToIntegrationActionIgnoreFilterArrayOutput() IntegrationActionIgnoreFilterArrayOutput

func (IntegrationActionIgnoreFilterArray) ToIntegrationActionIgnoreFilterArrayOutputWithContext 

func (i IntegrationActionIgnoreFilterArray) ToIntegrationActionIgnoreFilterArrayOutputWithContext(ctx context.Context) IntegrationActionIgnoreFilterArrayOutput

type IntegrationActionIgnoreFilterArrayInput 

type IntegrationActionIgnoreFilterArrayInput interface {
	pulumi.Input

	ToIntegrationActionIgnoreFilterArrayOutput() IntegrationActionIgnoreFilterArrayOutput
	ToIntegrationActionIgnoreFilterArrayOutputWithContext(context.Context) IntegrationActionIgnoreFilterArrayOutput
}

IntegrationActionIgnoreFilterArrayInput is an input type that accepts IntegrationActionIgnoreFilterArray and IntegrationActionIgnoreFilterArrayOutput values. You can construct a concrete instance of `IntegrationActionIgnoreFilterArrayInput` via: 

IntegrationActionIgnoreFilterArray{ IntegrationActionIgnoreFilterArgs{...} }

type IntegrationActionIgnoreFilterArrayOutput 

type IntegrationActionIgnoreFilterArrayOutput struct{ *pulumi.OutputState }

func (IntegrationActionIgnoreFilterArrayOutput) ElementType 

func (IntegrationActionIgnoreFilterArrayOutput) ElementType() reflect.Type

func (IntegrationActionIgnoreFilterArrayOutput) Index 

func (o IntegrationActionIgnoreFilterArrayOutput) Index(i pulumi.IntInput) IntegrationActionIgnoreFilterOutput

func (IntegrationActionIgnoreFilterArrayOutput) ToIntegrationActionIgnoreFilterArrayOutput 

func (o IntegrationActionIgnoreFilterArrayOutput) ToIntegrationActionIgnoreFilterArrayOutput() IntegrationActionIgnoreFilterArrayOutput

func (IntegrationActionIgnoreFilterArrayOutput) ToIntegrationActionIgnoreFilterArrayOutputWithContext 

func (o IntegrationActionIgnoreFilterArrayOutput) ToIntegrationActionIgnoreFilterArrayOutputWithContext(ctx context.Context) IntegrationActionIgnoreFilterArrayOutput

type IntegrationActionIgnoreFilterCondition 

type IntegrationActionIgnoreFilterCondition struct {
	ExpectedValue *string `pulumi:"expectedValue"`
	Field         string  `pulumi:"field"`
	Key           *string `pulumi:"key"`
	Not           *bool   `pulumi:"not"`
	Operation     string  `pulumi:"operation"`
	// Integer value that defines in which order the action will be performed. Default: `1`.
	Order *int `pulumi:"order"`
}

type IntegrationActionIgnoreFilterConditionArgs 

type IntegrationActionIgnoreFilterConditionArgs struct {
	ExpectedValue pulumi.StringPtrInput `pulumi:"expectedValue"`
	Field         pulumi.StringInput    `pulumi:"field"`
	Key           pulumi.StringPtrInput `pulumi:"key"`
	Not           pulumi.BoolPtrInput   `pulumi:"not"`
	Operation     pulumi.StringInput    `pulumi:"operation"`
	// Integer value that defines in which order the action will be performed. Default: `1`.
	Order pulumi.IntPtrInput `pulumi:"order"`
}

func (IntegrationActionIgnoreFilterConditionArgs) ElementType 

func (IntegrationActionIgnoreFilterConditionArgs) ElementType() reflect.Type

func (IntegrationActionIgnoreFilterConditionArgs) ToIntegrationActionIgnoreFilterConditionOutput 

func (i IntegrationActionIgnoreFilterConditionArgs) ToIntegrationActionIgnoreFilterConditionOutput() IntegrationActionIgnoreFilterConditionOutput

func (IntegrationActionIgnoreFilterConditionArgs) ToIntegrationActionIgnoreFilterConditionOutputWithContext 

func (i IntegrationActionIgnoreFilterConditionArgs) ToIntegrationActionIgnoreFilterConditionOutputWithContext(ctx context.Context) IntegrationActionIgnoreFilterConditionOutput

type IntegrationActionIgnoreFilterConditionArray 

type IntegrationActionIgnoreFilterConditionArray []IntegrationActionIgnoreFilterConditionInput

func (IntegrationActionIgnoreFilterConditionArray) ElementType 

func (IntegrationActionIgnoreFilterConditionArray) ElementType() reflect.Type

func (IntegrationActionIgnoreFilterConditionArray) ToIntegrationActionIgnoreFilterConditionArrayOutput 

func (i IntegrationActionIgnoreFilterConditionArray) ToIntegrationActionIgnoreFilterConditionArrayOutput() IntegrationActionIgnoreFilterConditionArrayOutput

func (IntegrationActionIgnoreFilterConditionArray) ToIntegrationActionIgnoreFilterConditionArrayOutputWithContext 

func (i IntegrationActionIgnoreFilterConditionArray) ToIntegrationActionIgnoreFilterConditionArrayOutputWithContext(ctx context.Context) IntegrationActionIgnoreFilterConditionArrayOutput

type IntegrationActionIgnoreFilterConditionArrayInput 

type IntegrationActionIgnoreFilterConditionArrayInput interface {
	pulumi.Input

	ToIntegrationActionIgnoreFilterConditionArrayOutput() IntegrationActionIgnoreFilterConditionArrayOutput
	ToIntegrationActionIgnoreFilterConditionArrayOutputWithContext(context.Context) IntegrationActionIgnoreFilterConditionArrayOutput
}

IntegrationActionIgnoreFilterConditionArrayInput is an input type that accepts IntegrationActionIgnoreFilterConditionArray and IntegrationActionIgnoreFilterConditionArrayOutput values. You can construct a concrete instance of `IntegrationActionIgnoreFilterConditionArrayInput` via: 

IntegrationActionIgnoreFilterConditionArray{ IntegrationActionIgnoreFilterConditionArgs{...} }

type IntegrationActionIgnoreFilterConditionArrayOutput 

type IntegrationActionIgnoreFilterConditionArrayOutput struct{ *pulumi.OutputState }

func (IntegrationActionIgnoreFilterConditionArrayOutput) ElementType 

func (IntegrationActionIgnoreFilterConditionArrayOutput) ElementType() reflect.Type

func (IntegrationActionIgnoreFilterConditionArrayOutput) Index 

func (o IntegrationActionIgnoreFilterConditionArrayOutput) Index(i pulumi.IntInput) IntegrationActionIgnoreFilterConditionOutput

func (IntegrationActionIgnoreFilterConditionArrayOutput) ToIntegrationActionIgnoreFilterConditionArrayOutput 

func (o IntegrationActionIgnoreFilterConditionArrayOutput) ToIntegrationActionIgnoreFilterConditionArrayOutput() IntegrationActionIgnoreFilterConditionArrayOutput

func (IntegrationActionIgnoreFilterConditionArrayOutput) ToIntegrationActionIgnoreFilterConditionArrayOutputWithContext 

func (o IntegrationActionIgnoreFilterConditionArrayOutput) ToIntegrationActionIgnoreFilterConditionArrayOutputWithContext(ctx context.Context) IntegrationActionIgnoreFilterConditionArrayOutput

type IntegrationActionIgnoreFilterConditionInput 

type IntegrationActionIgnoreFilterConditionInput interface {
	pulumi.Input

	ToIntegrationActionIgnoreFilterConditionOutput() IntegrationActionIgnoreFilterConditionOutput
	ToIntegrationActionIgnoreFilterConditionOutputWithContext(context.Context) IntegrationActionIgnoreFilterConditionOutput
}

IntegrationActionIgnoreFilterConditionInput is an input type that accepts IntegrationActionIgnoreFilterConditionArgs and IntegrationActionIgnoreFilterConditionOutput values. You can construct a concrete instance of `IntegrationActionIgnoreFilterConditionInput` via: 

IntegrationActionIgnoreFilterConditionArgs{...}

type IntegrationActionIgnoreFilterConditionOutput 

type IntegrationActionIgnoreFilterConditionOutput struct{ *pulumi.OutputState }

func (IntegrationActionIgnoreFilterConditionOutput) ElementType 

func (IntegrationActionIgnoreFilterConditionOutput) ElementType() reflect.Type

func (IntegrationActionIgnoreFilterConditionOutput) ExpectedValue 

func (o IntegrationActionIgnoreFilterConditionOutput) ExpectedValue() pulumi.StringPtrOutput

func (IntegrationActionIgnoreFilterConditionOutput) Field 

func (o IntegrationActionIgnoreFilterConditionOutput) Field() pulumi.StringOutput

func (IntegrationActionIgnoreFilterConditionOutput) Key 

func (o IntegrationActionIgnoreFilterConditionOutput) Key() pulumi.StringPtrOutput

func (IntegrationActionIgnoreFilterConditionOutput) Not 

func (o IntegrationActionIgnoreFilterConditionOutput) Not() pulumi.BoolPtrOutput

func (IntegrationActionIgnoreFilterConditionOutput) Operation 

func (o IntegrationActionIgnoreFilterConditionOutput) Operation() pulumi.StringOutput

func (IntegrationActionIgnoreFilterConditionOutput) Order 

func (o IntegrationActionIgnoreFilterConditionOutput) Order() pulumi.IntPtrOutput

Integer value that defines in which order the action will be performed. Default: `1`.

func (IntegrationActionIgnoreFilterConditionOutput) ToIntegrationActionIgnoreFilterConditionOutput 

func (o IntegrationActionIgnoreFilterConditionOutput) ToIntegrationActionIgnoreFilterConditionOutput() IntegrationActionIgnoreFilterConditionOutput

func (IntegrationActionIgnoreFilterConditionOutput) ToIntegrationActionIgnoreFilterConditionOutputWithContext 

func (o IntegrationActionIgnoreFilterConditionOutput) ToIntegrationActionIgnoreFilterConditionOutputWithContext(ctx context.Context) IntegrationActionIgnoreFilterConditionOutput

type IntegrationActionIgnoreFilterInput 

type IntegrationActionIgnoreFilterInput interface {
	pulumi.Input

	ToIntegrationActionIgnoreFilterOutput() IntegrationActionIgnoreFilterOutput
	ToIntegrationActionIgnoreFilterOutputWithContext(context.Context) IntegrationActionIgnoreFilterOutput
}

IntegrationActionIgnoreFilterInput is an input type that accepts IntegrationActionIgnoreFilterArgs and IntegrationActionIgnoreFilterOutput values. You can construct a concrete instance of `IntegrationActionIgnoreFilterInput` via: 

IntegrationActionIgnoreFilterArgs{...}

type IntegrationActionIgnoreFilterOutput 

type IntegrationActionIgnoreFilterOutput struct{ *pulumi.OutputState }

func (IntegrationActionIgnoreFilterOutput) Conditions 

func (o IntegrationActionIgnoreFilterOutput) Conditions() IntegrationActionIgnoreFilterConditionArrayOutput

func (IntegrationActionIgnoreFilterOutput) ElementType 

func (IntegrationActionIgnoreFilterOutput) ElementType() reflect.Type

func (IntegrationActionIgnoreFilterOutput) ToIntegrationActionIgnoreFilterOutput 

func (o IntegrationActionIgnoreFilterOutput) ToIntegrationActionIgnoreFilterOutput() IntegrationActionIgnoreFilterOutput

func (IntegrationActionIgnoreFilterOutput) ToIntegrationActionIgnoreFilterOutputWithContext 

func (o IntegrationActionIgnoreFilterOutput) ToIntegrationActionIgnoreFilterOutputWithContext(ctx context.Context) IntegrationActionIgnoreFilterOutput

func (IntegrationActionIgnoreFilterOutput) Type 

func (o IntegrationActionIgnoreFilterOutput) Type() pulumi.StringOutput

type IntegrationActionIgnoreInput 

type IntegrationActionIgnoreInput interface {
	pulumi.Input

	ToIntegrationActionIgnoreOutput() IntegrationActionIgnoreOutput
	ToIntegrationActionIgnoreOutputWithContext(context.Context) IntegrationActionIgnoreOutput
}

IntegrationActionIgnoreInput is an input type that accepts IntegrationActionIgnoreArgs and IntegrationActionIgnoreOutput values. You can construct a concrete instance of `IntegrationActionIgnoreInput` via: 

IntegrationActionIgnoreArgs{...}

type IntegrationActionIgnoreOutput 

type IntegrationActionIgnoreOutput struct{ *pulumi.OutputState }

func (IntegrationActionIgnoreOutput) ElementType 

func (IntegrationActionIgnoreOutput) ElementType() reflect.Type

func (IntegrationActionIgnoreOutput) Filters 

func (o IntegrationActionIgnoreOutput) Filters() IntegrationActionIgnoreFilterArrayOutput

Used to specify rules for matching alerts and the filter type. Please note that depending on the integration type the field names in the filter conditions are: * For SNS integration: `actions`, `alias`, `entity`, `Message`, `recipients`, `responders`, `Subject`, `tags`, `teams`, `eventType`, `Timestamp`, `TopicArn`. * For API integration: `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `recipients`, `teams`, `priority`, `eventType`. * For Email integration: `fromAddress`, `fromName`, `conversationSubject`, `subject`

func (IntegrationActionIgnoreOutput) Name 

func (o IntegrationActionIgnoreOutput) Name() pulumi.StringOutput

Name of the integration action.

func (IntegrationActionIgnoreOutput) Order 

func (o IntegrationActionIgnoreOutput) Order() pulumi.IntPtrOutput

Integer value that defines in which order the action will be performed. Default: `1`.

func (IntegrationActionIgnoreOutput) ToIntegrationActionIgnoreOutput 

func (o IntegrationActionIgnoreOutput) ToIntegrationActionIgnoreOutput() IntegrationActionIgnoreOutput

func (IntegrationActionIgnoreOutput) ToIntegrationActionIgnoreOutputWithContext 

func (o IntegrationActionIgnoreOutput) ToIntegrationActionIgnoreOutputWithContext(ctx context.Context) IntegrationActionIgnoreOutput

func (IntegrationActionIgnoreOutput) Type 

func (o IntegrationActionIgnoreOutput) Type() pulumi.StringPtrOutput

type IntegrationActionInput 

type IntegrationActionInput interface {
	pulumi.Input

	ToIntegrationActionOutput() IntegrationActionOutput
	ToIntegrationActionOutputWithContext(ctx context.Context) IntegrationActionOutput
}

type IntegrationActionMap added in v0.1.3 

type IntegrationActionMap map[string]IntegrationActionInput

func (IntegrationActionMap) ElementType added in v0.1.3 

func (IntegrationActionMap) ElementType() reflect.Type

func (IntegrationActionMap) ToIntegrationActionMapOutput added in v0.1.3 

func (i IntegrationActionMap) ToIntegrationActionMapOutput() IntegrationActionMapOutput

func (IntegrationActionMap) ToIntegrationActionMapOutputWithContext added in v0.1.3 

func (i IntegrationActionMap) ToIntegrationActionMapOutputWithContext(ctx context.Context) IntegrationActionMapOutput

type IntegrationActionMapInput added in v0.1.3 

type IntegrationActionMapInput interface {
	pulumi.Input

	ToIntegrationActionMapOutput() IntegrationActionMapOutput
	ToIntegrationActionMapOutputWithContext(context.Context) IntegrationActionMapOutput
}

IntegrationActionMapInput is an input type that accepts IntegrationActionMap and IntegrationActionMapOutput values. You can construct a concrete instance of `IntegrationActionMapInput` via: 

IntegrationActionMap{ "key": IntegrationActionArgs{...} }

type IntegrationActionMapOutput added in v0.1.3 

type IntegrationActionMapOutput struct{ *pulumi.OutputState }

func (IntegrationActionMapOutput) ElementType added in v0.1.3 

func (IntegrationActionMapOutput) ElementType() reflect.Type

func (IntegrationActionMapOutput) MapIndex added in v0.1.3 

func (o IntegrationActionMapOutput) MapIndex(k pulumi.StringInput) IntegrationActionOutput

func (IntegrationActionMapOutput) ToIntegrationActionMapOutput added in v0.1.3 

func (o IntegrationActionMapOutput) ToIntegrationActionMapOutput() IntegrationActionMapOutput

func (IntegrationActionMapOutput) ToIntegrationActionMapOutputWithContext added in v0.1.3 

func (o IntegrationActionMapOutput) ToIntegrationActionMapOutputWithContext(ctx context.Context) IntegrationActionMapOutput

type IntegrationActionOutput 

type IntegrationActionOutput struct{ *pulumi.OutputState }

func (IntegrationActionOutput) Acknowledges added in v1.1.9 

func (o IntegrationActionOutput) Acknowledges() IntegrationActionAcknowledgeArrayOutput

func (IntegrationActionOutput) AddNotes added in v1.1.9 

func (o IntegrationActionOutput) AddNotes() IntegrationActionAddNoteArrayOutput

func (IntegrationActionOutput) Closes added in v1.1.9 

func (o IntegrationActionOutput) Closes() IntegrationActionCloseArrayOutput

func (IntegrationActionOutput) Creates added in v1.1.9 

func (o IntegrationActionOutput) Creates() IntegrationActionCreateArrayOutput

func (IntegrationActionOutput) ElementType 

func (IntegrationActionOutput) ElementType() reflect.Type

func (IntegrationActionOutput) Ignores added in v1.1.9 

func (o IntegrationActionOutput) Ignores() IntegrationActionIgnoreArrayOutput

func (IntegrationActionOutput) IntegrationId added in v1.1.9 

func (o IntegrationActionOutput) IntegrationId() pulumi.StringOutput

ID of the parent integration resource to bind to.

func (IntegrationActionOutput) ToIntegrationActionOutput 

func (o IntegrationActionOutput) ToIntegrationActionOutput() IntegrationActionOutput

func (IntegrationActionOutput) ToIntegrationActionOutputWithContext 

func (o IntegrationActionOutput) ToIntegrationActionOutputWithContext(ctx context.Context) IntegrationActionOutput

type IntegrationActionState 

type IntegrationActionState struct {
	Acknowledges IntegrationActionAcknowledgeArrayInput
	AddNotes     IntegrationActionAddNoteArrayInput
	Closes       IntegrationActionCloseArrayInput
	Creates      IntegrationActionCreateArrayInput
	Ignores      IntegrationActionIgnoreArrayInput
	// ID of the parent integration resource to bind to.
	IntegrationId pulumi.StringPtrInput
}

func (IntegrationActionState) ElementType 

func (IntegrationActionState) ElementType() reflect.Type

type LookupEscalationArgs 

type LookupEscalationArgs struct {
	// Escalation Description
	Description *string `pulumi:"description"`
	// Name of the escalation.
	Name string `pulumi:"name"`
	// If owner team exist the id of the team is exported
	OwnerTeamId *string `pulumi:"ownerTeamId"`
	// Escalation repeat preferences
	Repeats []GetEscalationRepeat `pulumi:"repeats"`
	// Escalation rules
	Rules []GetEscalationRule `pulumi:"rules"`
}

A collection of arguments for invoking getEscalation.

type LookupEscalationOutputArgs added in v1.1.0 

type LookupEscalationOutputArgs struct {
	// Escalation Description
	Description pulumi.StringPtrInput `pulumi:"description"`
	// Name of the escalation.
	Name pulumi.StringInput `pulumi:"name"`
	// If owner team exist the id of the team is exported
	OwnerTeamId pulumi.StringPtrInput `pulumi:"ownerTeamId"`
	// Escalation repeat preferences
	Repeats GetEscalationRepeatArrayInput `pulumi:"repeats"`
	// Escalation rules
	Rules GetEscalationRuleArrayInput `pulumi:"rules"`
}

A collection of arguments for invoking getEscalation.

func (LookupEscalationOutputArgs) ElementType added in v1.1.0 

func (LookupEscalationOutputArgs) ElementType() reflect.Type

type LookupEscalationResult 

type LookupEscalationResult struct {
	// Escalation Description
	Description *string `pulumi:"description"`
	// The provider-assigned unique ID for this managed resource.
	Id   string `pulumi:"id"`
	Name string `pulumi:"name"`
	// If owner team exist the id of the team is exported
	OwnerTeamId *string `pulumi:"ownerTeamId"`
	// Escalation repeat preferences
	Repeats []GetEscalationRepeat `pulumi:"repeats"`
	// Escalation rules
	Rules []GetEscalationRule `pulumi:"rules"`
}

A collection of values returned by getEscalation.

func LookupEscalation 

func LookupEscalation(ctx *pulumi.Context, args *LookupEscalationArgs, opts ...pulumi.InvokeOption) (*LookupEscalationResult, error)

Manages an Escalation within Opsgenie.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opsgenie.LookupEscalation(ctx, &opsgenie.LookupEscalationArgs{
			Name: "existing-escalation",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupEscalationResultOutput added in v1.1.0 

type LookupEscalationResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getEscalation.

func LookupEscalationOutput added in v1.1.0 

func LookupEscalationOutput(ctx *pulumi.Context, args LookupEscalationOutputArgs, opts ...pulumi.InvokeOption) LookupEscalationResultOutput

func (LookupEscalationResultOutput) Description added in v1.1.0 

func (o LookupEscalationResultOutput) Description() pulumi.StringPtrOutput

Escalation Description

func (LookupEscalationResultOutput) ElementType added in v1.1.0 

func (LookupEscalationResultOutput) ElementType() reflect.Type

func (LookupEscalationResultOutput) Id added in v1.1.0 

func (o LookupEscalationResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (LookupEscalationResultOutput) Name added in v1.1.0 

func (o LookupEscalationResultOutput) Name() pulumi.StringOutput

func (LookupEscalationResultOutput) OwnerTeamId added in v1.1.0 

func (o LookupEscalationResultOutput) OwnerTeamId() pulumi.StringPtrOutput

If owner team exist the id of the team is exported

func (LookupEscalationResultOutput) Repeats added in v1.1.0 

func (o LookupEscalationResultOutput) Repeats() GetEscalationRepeatArrayOutput

Escalation repeat preferences

func (LookupEscalationResultOutput) Rules added in v1.1.0 

func (o LookupEscalationResultOutput) Rules() GetEscalationRuleArrayOutput

Escalation rules

func (LookupEscalationResultOutput) ToLookupEscalationResultOutput added in v1.1.0 

func (o LookupEscalationResultOutput) ToLookupEscalationResultOutput() LookupEscalationResultOutput

func (LookupEscalationResultOutput) ToLookupEscalationResultOutputWithContext added in v1.1.0 

func (o LookupEscalationResultOutput) ToLookupEscalationResultOutputWithContext(ctx context.Context) LookupEscalationResultOutput

type LookupHeartbeatArgs 

type LookupHeartbeatArgs struct {
	// Specifies the alert message for heartbeat expiration alert. If this is not provided, default alert message is "HeartbeatName is expired".
	AlertMessage *string `pulumi:"alertMessage"`
	// Specifies the alert priority for heartbeat expiration alert. If this is not provided, default priority is P3.
	AlertPriority *string `pulumi:"alertPriority"`
	// Specifies the alert tags for heartbeat expiration alert.
	AlertTags []string `pulumi:"alertTags"`
	// An optional description of the heartbeat
	Description *string `pulumi:"description"`
	// Enable/disable heartbeat monitoring.
	Enabled *bool `pulumi:"enabled"`
	// Specifies how often a heartbeat message should be expected.
	Interval *int `pulumi:"interval"`
	// Interval specified as minutes, hours or days.
	IntervalUnit *string `pulumi:"intervalUnit"`
	// Name of the heartbeat
	Name string `pulumi:"name"`
	// Owner team of the heartbeat.
	OwnerTeamId *string `pulumi:"ownerTeamId"`
}

A collection of arguments for invoking getHeartbeat.

type LookupHeartbeatOutputArgs added in v1.1.0 

type LookupHeartbeatOutputArgs struct {
	// Specifies the alert message for heartbeat expiration alert. If this is not provided, default alert message is "HeartbeatName is expired".
	AlertMessage pulumi.StringPtrInput `pulumi:"alertMessage"`
	// Specifies the alert priority for heartbeat expiration alert. If this is not provided, default priority is P3.
	AlertPriority pulumi.StringPtrInput `pulumi:"alertPriority"`
	// Specifies the alert tags for heartbeat expiration alert.
	AlertTags pulumi.StringArrayInput `pulumi:"alertTags"`
	// An optional description of the heartbeat
	Description pulumi.StringPtrInput `pulumi:"description"`
	// Enable/disable heartbeat monitoring.
	Enabled pulumi.BoolPtrInput `pulumi:"enabled"`
	// Specifies how often a heartbeat message should be expected.
	Interval pulumi.IntPtrInput `pulumi:"interval"`
	// Interval specified as minutes, hours or days.
	IntervalUnit pulumi.StringPtrInput `pulumi:"intervalUnit"`
	// Name of the heartbeat
	Name pulumi.StringInput `pulumi:"name"`
	// Owner team of the heartbeat.
	OwnerTeamId pulumi.StringPtrInput `pulumi:"ownerTeamId"`
}

A collection of arguments for invoking getHeartbeat.

func (LookupHeartbeatOutputArgs) ElementType added in v1.1.0 

func (LookupHeartbeatOutputArgs) ElementType() reflect.Type

type LookupHeartbeatResult 

type LookupHeartbeatResult struct {
	// Specifies the alert message for heartbeat expiration alert. If this is not provided, default alert message is "HeartbeatName is expired".
	AlertMessage *string `pulumi:"alertMessage"`
	// Specifies the alert priority for heartbeat expiration alert. If this is not provided, default priority is P3.
	AlertPriority *string `pulumi:"alertPriority"`
	// Specifies the alert tags for heartbeat expiration alert.
	AlertTags []string `pulumi:"alertTags"`
	// An optional description of the heartbeat
	Description *string `pulumi:"description"`
	// Enable/disable heartbeat monitoring.
	Enabled *bool `pulumi:"enabled"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// Specifies how often a heartbeat message should be expected.
	Interval *int `pulumi:"interval"`
	// Interval specified as minutes, hours or days.
	IntervalUnit *string `pulumi:"intervalUnit"`
	Name         string  `pulumi:"name"`
	// Owner team of the heartbeat.
	OwnerTeamId *string `pulumi:"ownerTeamId"`
}

A collection of values returned by getHeartbeat.

func LookupHeartbeat 

func LookupHeartbeat(ctx *pulumi.Context, args *LookupHeartbeatArgs, opts ...pulumi.InvokeOption) (*LookupHeartbeatResult, error)

Manages existing heartbeat within Opsgenie.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opsgenie.LookupHeartbeat(ctx, &opsgenie.LookupHeartbeatArgs{
			Name: "genieheartbeat-existing",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupHeartbeatResultOutput added in v1.1.0 

type LookupHeartbeatResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getHeartbeat.

func LookupHeartbeatOutput added in v1.1.0 

func LookupHeartbeatOutput(ctx *pulumi.Context, args LookupHeartbeatOutputArgs, opts ...pulumi.InvokeOption) LookupHeartbeatResultOutput

func (LookupHeartbeatResultOutput) AlertMessage added in v1.1.0 

func (o LookupHeartbeatResultOutput) AlertMessage() pulumi.StringPtrOutput

Specifies the alert message for heartbeat expiration alert. If this is not provided, default alert message is "HeartbeatName is expired".

func (LookupHeartbeatResultOutput) AlertPriority added in v1.1.0 

func (o LookupHeartbeatResultOutput) AlertPriority() pulumi.StringPtrOutput

Specifies the alert priority for heartbeat expiration alert. If this is not provided, default priority is P3.

func (LookupHeartbeatResultOutput) AlertTags added in v1.1.0 

func (o LookupHeartbeatResultOutput) AlertTags() pulumi.StringArrayOutput

Specifies the alert tags for heartbeat expiration alert.

func (LookupHeartbeatResultOutput) Description added in v1.1.0 

func (o LookupHeartbeatResultOutput) Description() pulumi.StringPtrOutput

An optional description of the heartbeat

func (LookupHeartbeatResultOutput) ElementType added in v1.1.0 

func (LookupHeartbeatResultOutput) ElementType() reflect.Type

func (LookupHeartbeatResultOutput) Enabled added in v1.1.0 

func (o LookupHeartbeatResultOutput) Enabled() pulumi.BoolPtrOutput

Enable/disable heartbeat monitoring.

func (LookupHeartbeatResultOutput) Id added in v1.1.0 

func (o LookupHeartbeatResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (LookupHeartbeatResultOutput) Interval added in v1.1.0 

func (o LookupHeartbeatResultOutput) Interval() pulumi.IntPtrOutput

Specifies how often a heartbeat message should be expected.

func (LookupHeartbeatResultOutput) IntervalUnit added in v1.1.0 

func (o LookupHeartbeatResultOutput) IntervalUnit() pulumi.StringPtrOutput

Interval specified as minutes, hours or days.

func (LookupHeartbeatResultOutput) Name added in v1.1.0 

func (o LookupHeartbeatResultOutput) Name() pulumi.StringOutput

func (LookupHeartbeatResultOutput) OwnerTeamId added in v1.1.0 

func (o LookupHeartbeatResultOutput) OwnerTeamId() pulumi.StringPtrOutput

Owner team of the heartbeat.

func (LookupHeartbeatResultOutput) ToLookupHeartbeatResultOutput added in v1.1.0 

func (o LookupHeartbeatResultOutput) ToLookupHeartbeatResultOutput() LookupHeartbeatResultOutput

func (LookupHeartbeatResultOutput) ToLookupHeartbeatResultOutputWithContext added in v1.1.0 

func (o LookupHeartbeatResultOutput) ToLookupHeartbeatResultOutputWithContext(ctx context.Context) LookupHeartbeatResultOutput

type LookupScheduleArgs 

type LookupScheduleArgs struct {
	// Timezone of schedule. Please look at [Supported Timezone Ids](https://docs.opsgenie.com/docs/supported-timezone-ids) for available timezones - Default: `America/New_York`.
	Description *string `pulumi:"description"`
	// Enable/disable state of schedule
	Enabled *bool `pulumi:"enabled"`
	// Name of the schedule.
	Name string `pulumi:"name"`
	// Owner team id of the schedule.
	OwnerTeamId *string `pulumi:"ownerTeamId"`
	// The description of schedule.
	Timezone *string `pulumi:"timezone"`
}

A collection of arguments for invoking getSchedule.

type LookupScheduleOutputArgs added in v1.1.0 

type LookupScheduleOutputArgs struct {
	// Timezone of schedule. Please look at [Supported Timezone Ids](https://docs.opsgenie.com/docs/supported-timezone-ids) for available timezones - Default: `America/New_York`.
	Description pulumi.StringPtrInput `pulumi:"description"`
	// Enable/disable state of schedule
	Enabled pulumi.BoolPtrInput `pulumi:"enabled"`
	// Name of the schedule.
	Name pulumi.StringInput `pulumi:"name"`
	// Owner team id of the schedule.
	OwnerTeamId pulumi.StringPtrInput `pulumi:"ownerTeamId"`
	// The description of schedule.
	Timezone pulumi.StringPtrInput `pulumi:"timezone"`
}

A collection of arguments for invoking getSchedule.

func (LookupScheduleOutputArgs) ElementType added in v1.1.0 

func (LookupScheduleOutputArgs) ElementType() reflect.Type

type LookupScheduleResult 

type LookupScheduleResult struct {
	// Timezone of schedule. Please look at [Supported Timezone Ids](https://docs.opsgenie.com/docs/supported-timezone-ids) for available timezones - Default: `America/New_York`.
	Description *string `pulumi:"description"`
	// Enable/disable state of schedule
	Enabled *bool `pulumi:"enabled"`
	// The provider-assigned unique ID for this managed resource.
	Id   string `pulumi:"id"`
	Name string `pulumi:"name"`
	// Owner team id of the schedule.
	OwnerTeamId *string `pulumi:"ownerTeamId"`
	// The description of schedule.
	Timezone *string `pulumi:"timezone"`
}

A collection of values returned by getSchedule.

func LookupSchedule 

func LookupSchedule(ctx *pulumi.Context, args *LookupScheduleArgs, opts ...pulumi.InvokeOption) (*LookupScheduleResult, error)

Manages a Schedule within Opsgenie.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opsgenie.LookupSchedule(ctx, &opsgenie.LookupScheduleArgs{
			Name: "sre-team schedule",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupScheduleResultOutput added in v1.1.0 

type LookupScheduleResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getSchedule.

func LookupScheduleOutput added in v1.1.0 

func LookupScheduleOutput(ctx *pulumi.Context, args LookupScheduleOutputArgs, opts ...pulumi.InvokeOption) LookupScheduleResultOutput

func (LookupScheduleResultOutput) Description added in v1.1.0 

func (o LookupScheduleResultOutput) Description() pulumi.StringPtrOutput

Timezone of schedule. Please look at [Supported Timezone Ids](https://docs.opsgenie.com/docs/supported-timezone-ids) for available timezones - Default: `America/New_York`.

func (LookupScheduleResultOutput) ElementType added in v1.1.0 

func (LookupScheduleResultOutput) ElementType() reflect.Type

func (LookupScheduleResultOutput) Enabled added in v1.1.0 

func (o LookupScheduleResultOutput) Enabled() pulumi.BoolPtrOutput

Enable/disable state of schedule

func (LookupScheduleResultOutput) Id added in v1.1.0 

func (o LookupScheduleResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (LookupScheduleResultOutput) Name added in v1.1.0 

func (o LookupScheduleResultOutput) Name() pulumi.StringOutput

func (LookupScheduleResultOutput) OwnerTeamId added in v1.1.0 

func (o LookupScheduleResultOutput) OwnerTeamId() pulumi.StringPtrOutput

Owner team id of the schedule.

func (LookupScheduleResultOutput) Timezone added in v1.1.0 

func (o LookupScheduleResultOutput) Timezone() pulumi.StringPtrOutput

The description of schedule.

func (LookupScheduleResultOutput) ToLookupScheduleResultOutput added in v1.1.0 

func (o LookupScheduleResultOutput) ToLookupScheduleResultOutput() LookupScheduleResultOutput

func (LookupScheduleResultOutput) ToLookupScheduleResultOutputWithContext added in v1.1.0 

func (o LookupScheduleResultOutput) ToLookupScheduleResultOutputWithContext(ctx context.Context) LookupScheduleResultOutput

type LookupServiceArgs 

type LookupServiceArgs struct {
	// Description field of the service that is generally used to provide a detailed information about the service.
	Description *string `pulumi:"description"`
	// Name of the service. This field must not be longer than 100 characters.
	//
	// The following attributes are exported:
	Name string `pulumi:"name"`
	// Team id of the service.
	TeamId *string `pulumi:"teamId"`
}

A collection of arguments for invoking getService.

type LookupServiceOutputArgs added in v1.1.0 

type LookupServiceOutputArgs struct {
	// Description field of the service that is generally used to provide a detailed information about the service.
	Description pulumi.StringPtrInput `pulumi:"description"`
	// Name of the service. This field must not be longer than 100 characters.
	//
	// The following attributes are exported:
	Name pulumi.StringInput `pulumi:"name"`
	// Team id of the service.
	TeamId pulumi.StringPtrInput `pulumi:"teamId"`
}

A collection of arguments for invoking getService.

func (LookupServiceOutputArgs) ElementType added in v1.1.0 

func (LookupServiceOutputArgs) ElementType() reflect.Type

type LookupServiceResult 

type LookupServiceResult struct {
	Description *string `pulumi:"description"`
	// The provider-assigned unique ID for this managed resource.
	Id     string  `pulumi:"id"`
	Name   string  `pulumi:"name"`
	TeamId *string `pulumi:"teamId"`
}

A collection of values returned by getService.

func LookupService 

func LookupService(ctx *pulumi.Context, args *LookupServiceArgs, opts ...pulumi.InvokeOption) (*LookupServiceResult, error)

Manages existing Service within Opsgenie.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opsgenie.LookupService(ctx, &opsgenie.LookupServiceArgs{
			Name: "Payment",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupServiceResultOutput added in v1.1.0 

type LookupServiceResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getService.

func LookupServiceOutput added in v1.1.0 

func LookupServiceOutput(ctx *pulumi.Context, args LookupServiceOutputArgs, opts ...pulumi.InvokeOption) LookupServiceResultOutput

func (LookupServiceResultOutput) Description added in v1.1.0 

func (o LookupServiceResultOutput) Description() pulumi.StringPtrOutput

func (LookupServiceResultOutput) ElementType added in v1.1.0 

func (LookupServiceResultOutput) ElementType() reflect.Type

func (LookupServiceResultOutput) Id added in v1.1.0 

func (o LookupServiceResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (LookupServiceResultOutput) Name added in v1.1.0 

func (o LookupServiceResultOutput) Name() pulumi.StringOutput

func (LookupServiceResultOutput) TeamId added in v1.1.0 

func (o LookupServiceResultOutput) TeamId() pulumi.StringPtrOutput

func (LookupServiceResultOutput) ToLookupServiceResultOutput added in v1.1.0 

func (o LookupServiceResultOutput) ToLookupServiceResultOutput() LookupServiceResultOutput

func (LookupServiceResultOutput) ToLookupServiceResultOutputWithContext added in v1.1.0 

func (o LookupServiceResultOutput) ToLookupServiceResultOutputWithContext(ctx context.Context) LookupServiceResultOutput

type LookupTeamArgs 

type LookupTeamArgs struct {
	// A description for this team.
	Description *string `pulumi:"description"`
	// A Member block as documented below.
	Members []GetTeamMember `pulumi:"members"`
	// The name associated with this team. Opsgenie defines that this must not be longer than 100 characters.
	//
	// The following attributes are exported:
	Name string `pulumi:"name"`
}

A collection of arguments for invoking getTeam.

type LookupTeamOutputArgs added in v1.1.0 

type LookupTeamOutputArgs struct {
	// A description for this team.
	Description pulumi.StringPtrInput `pulumi:"description"`
	// A Member block as documented below.
	Members GetTeamMemberArrayInput `pulumi:"members"`
	// The name associated with this team. Opsgenie defines that this must not be longer than 100 characters.
	//
	// The following attributes are exported:
	Name pulumi.StringInput `pulumi:"name"`
}

A collection of arguments for invoking getTeam.

func (LookupTeamOutputArgs) ElementType added in v1.1.0 

func (LookupTeamOutputArgs) ElementType() reflect.Type

type LookupTeamResult 

type LookupTeamResult struct {
	Description *string `pulumi:"description"`
	// The provider-assigned unique ID for this managed resource.
	Id      string          `pulumi:"id"`
	Members []GetTeamMember `pulumi:"members"`
	Name    string          `pulumi:"name"`
}

A collection of values returned by getTeam.

func LookupTeam 

func LookupTeam(ctx *pulumi.Context, args *LookupTeamArgs, opts ...pulumi.InvokeOption) (*LookupTeamResult, error)

Manages existing Team within Opsgenie.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opsgenie.LookupTeam(ctx, &opsgenie.LookupTeamArgs{
			Name: "sre-team",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupTeamResultOutput added in v1.1.0 

type LookupTeamResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getTeam.

func LookupTeamOutput added in v1.1.0 

func LookupTeamOutput(ctx *pulumi.Context, args LookupTeamOutputArgs, opts ...pulumi.InvokeOption) LookupTeamResultOutput

func (LookupTeamResultOutput) Description added in v1.1.0 

func (o LookupTeamResultOutput) Description() pulumi.StringPtrOutput

func (LookupTeamResultOutput) ElementType added in v1.1.0 

func (LookupTeamResultOutput) ElementType() reflect.Type

func (LookupTeamResultOutput) Id added in v1.1.0 

func (o LookupTeamResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (LookupTeamResultOutput) Members added in v1.1.0 

func (o LookupTeamResultOutput) Members() GetTeamMemberArrayOutput

func (LookupTeamResultOutput) Name added in v1.1.0 

func (o LookupTeamResultOutput) Name() pulumi.StringOutput

func (LookupTeamResultOutput) ToLookupTeamResultOutput added in v1.1.0 

func (o LookupTeamResultOutput) ToLookupTeamResultOutput() LookupTeamResultOutput

func (LookupTeamResultOutput) ToLookupTeamResultOutputWithContext added in v1.1.0 

func (o LookupTeamResultOutput) ToLookupTeamResultOutputWithContext(ctx context.Context) LookupTeamResultOutput

type LookupUserArgs 

type LookupUserArgs struct {
	// The Full Name of the User.
	FullName *string `pulumi:"fullName"`
	// Location information for the user. Please look at [Supported Locale Ids](https://docs.opsgenie.com/docs/supported-locales) for available locales.
	Locale *string `pulumi:"locale"`
	// The Role assigned to the User. Either a built-in such as 'Owner', 'Admin' or 'User' - or the name of a custom role.
	Role *string `pulumi:"role"`
	// Timezone information of the user. Please look at [Supported Timezone Ids](https://docs.opsgenie.com/docs/supported-timezone-ids) for available timezones.
	Timezone *string `pulumi:"timezone"`
	// The email address associated with this user. Opsgenie defines that this must not be longer than 100 characters.
	Username string `pulumi:"username"`
}

A collection of arguments for invoking getUser.

type LookupUserOutputArgs added in v1.1.0 

type LookupUserOutputArgs struct {
	// The Full Name of the User.
	FullName pulumi.StringPtrInput `pulumi:"fullName"`
	// Location information for the user. Please look at [Supported Locale Ids](https://docs.opsgenie.com/docs/supported-locales) for available locales.
	Locale pulumi.StringPtrInput `pulumi:"locale"`
	// The Role assigned to the User. Either a built-in such as 'Owner', 'Admin' or 'User' - or the name of a custom role.
	Role pulumi.StringPtrInput `pulumi:"role"`
	// Timezone information of the user. Please look at [Supported Timezone Ids](https://docs.opsgenie.com/docs/supported-timezone-ids) for available timezones.
	Timezone pulumi.StringPtrInput `pulumi:"timezone"`
	// The email address associated with this user. Opsgenie defines that this must not be longer than 100 characters.
	Username pulumi.StringInput `pulumi:"username"`
}

A collection of arguments for invoking getUser.

func (LookupUserOutputArgs) ElementType added in v1.1.0 

func (LookupUserOutputArgs) ElementType() reflect.Type

type LookupUserResult 

type LookupUserResult struct {
	// The Full Name of the User.
	FullName *string `pulumi:"fullName"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// Location information for the user. Please look at [Supported Locale Ids](https://docs.opsgenie.com/docs/supported-locales) for available locales.
	Locale *string `pulumi:"locale"`
	// The Role assigned to the User. Either a built-in such as 'Owner', 'Admin' or 'User' - or the name of a custom role.
	Role *string `pulumi:"role"`
	// Timezone information of the user. Please look at [Supported Timezone Ids](https://docs.opsgenie.com/docs/supported-timezone-ids) for available timezones.
	Timezone *string `pulumi:"timezone"`
	Username string  `pulumi:"username"`
}

A collection of values returned by getUser.

func LookupUser 

func LookupUser(ctx *pulumi.Context, args *LookupUserArgs, opts ...pulumi.InvokeOption) (*LookupUserResult, error)

Manages existing User within Opsgenie.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opsgenie.LookupUser(ctx, &opsgenie.LookupUserArgs{
			Username: "user@domain.com",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupUserResultOutput added in v1.1.0 

type LookupUserResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getUser.

func LookupUserOutput added in v1.1.0 

func LookupUserOutput(ctx *pulumi.Context, args LookupUserOutputArgs, opts ...pulumi.InvokeOption) LookupUserResultOutput

func (LookupUserResultOutput) ElementType added in v1.1.0 

func (LookupUserResultOutput) ElementType() reflect.Type

func (LookupUserResultOutput) FullName added in v1.1.0 

func (o LookupUserResultOutput) FullName() pulumi.StringPtrOutput

The Full Name of the User.

func (LookupUserResultOutput) Id added in v1.1.0 

func (o LookupUserResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (LookupUserResultOutput) Locale added in v1.1.0 

func (o LookupUserResultOutput) Locale() pulumi.StringPtrOutput

Location information for the user. Please look at [Supported Locale Ids](https://docs.opsgenie.com/docs/supported-locales) for available locales.

func (LookupUserResultOutput) Role added in v1.1.0 

func (o LookupUserResultOutput) Role() pulumi.StringPtrOutput

The Role assigned to the User. Either a built-in such as 'Owner', 'Admin' or 'User' - or the name of a custom role.

func (LookupUserResultOutput) Timezone added in v1.1.0 

func (o LookupUserResultOutput) Timezone() pulumi.StringPtrOutput

Timezone information of the user. Please look at [Supported Timezone Ids](https://docs.opsgenie.com/docs/supported-timezone-ids) for available timezones.

func (LookupUserResultOutput) ToLookupUserResultOutput added in v1.1.0 

func (o LookupUserResultOutput) ToLookupUserResultOutput() LookupUserResultOutput

func (LookupUserResultOutput) ToLookupUserResultOutputWithContext added in v1.1.0 

func (o LookupUserResultOutput) ToLookupUserResultOutputWithContext(ctx context.Context) LookupUserResultOutput

func (LookupUserResultOutput) Username added in v1.1.0 

func (o LookupUserResultOutput) Username() pulumi.StringOutput

type Maintenance 

type Maintenance struct {
	pulumi.CustomResourceState

	// Description for the maintenance.
	Description pulumi.StringOutput `pulumi:"description"`
	// Rules of maintenance, which takes a list of rule objects and defines the maintenance rules over integrations and policies.
	Rules MaintenanceRuleArrayOutput `pulumi:"rules"`
	// Time configuration of maintenance. It takes a time object which has type, startDate and endDate fields
	Times MaintenanceTimeArrayOutput `pulumi:"times"`
}

Manages a Maintenance within Opsgenie.

## Import

Maintenance policies can be imported using the `policy_id`, e.g.

```sh $ pulumi import opsgenie:index/maintenance:Maintenance test policy_id` ```

func GetMaintenance 

func GetMaintenance(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *MaintenanceState, opts ...pulumi.ResourceOption) (*Maintenance, error)

GetMaintenance gets an existing Maintenance resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewMaintenance 

func NewMaintenance(ctx *pulumi.Context,
	name string, args *MaintenanceArgs, opts ...pulumi.ResourceOption) (*Maintenance, error)

NewMaintenance registers a new resource with the given unique name, arguments, and options.

func (*Maintenance) ElementType 

func (*Maintenance) ElementType() reflect.Type

func (*Maintenance) ToMaintenanceOutput 

func (i *Maintenance) ToMaintenanceOutput() MaintenanceOutput

func (*Maintenance) ToMaintenanceOutputWithContext 

func (i *Maintenance) ToMaintenanceOutputWithContext(ctx context.Context) MaintenanceOutput

type MaintenanceArgs 

type MaintenanceArgs struct {
	// Description for the maintenance.
	Description pulumi.StringInput
	// Rules of maintenance, which takes a list of rule objects and defines the maintenance rules over integrations and policies.
	Rules MaintenanceRuleArrayInput
	// Time configuration of maintenance. It takes a time object which has type, startDate and endDate fields
	Times MaintenanceTimeArrayInput
}

The set of arguments for constructing a Maintenance resource.

func (MaintenanceArgs) ElementType 

func (MaintenanceArgs) ElementType() reflect.Type

type MaintenanceArray added in v0.1.3 

type MaintenanceArray []MaintenanceInput

func (MaintenanceArray) ElementType added in v0.1.3 

func (MaintenanceArray) ElementType() reflect.Type

func (MaintenanceArray) ToMaintenanceArrayOutput added in v0.1.3 

func (i MaintenanceArray) ToMaintenanceArrayOutput() MaintenanceArrayOutput

func (MaintenanceArray) ToMaintenanceArrayOutputWithContext added in v0.1.3 

func (i MaintenanceArray) ToMaintenanceArrayOutputWithContext(ctx context.Context) MaintenanceArrayOutput

type MaintenanceArrayInput added in v0.1.3 

type MaintenanceArrayInput interface {
	pulumi.Input

	ToMaintenanceArrayOutput() MaintenanceArrayOutput
	ToMaintenanceArrayOutputWithContext(context.Context) MaintenanceArrayOutput
}

MaintenanceArrayInput is an input type that accepts MaintenanceArray and MaintenanceArrayOutput values. You can construct a concrete instance of `MaintenanceArrayInput` via: 

MaintenanceArray{ MaintenanceArgs{...} }

type MaintenanceArrayOutput added in v0.1.3 

type MaintenanceArrayOutput struct{ *pulumi.OutputState }

func (MaintenanceArrayOutput) ElementType added in v0.1.3 

func (MaintenanceArrayOutput) ElementType() reflect.Type

func (MaintenanceArrayOutput) Index added in v0.1.3 

func (o MaintenanceArrayOutput) Index(i pulumi.IntInput) MaintenanceOutput

func (MaintenanceArrayOutput) ToMaintenanceArrayOutput added in v0.1.3 

func (o MaintenanceArrayOutput) ToMaintenanceArrayOutput() MaintenanceArrayOutput

func (MaintenanceArrayOutput) ToMaintenanceArrayOutputWithContext added in v0.1.3 

func (o MaintenanceArrayOutput) ToMaintenanceArrayOutputWithContext(ctx context.Context) MaintenanceArrayOutput

type MaintenanceInput 

type MaintenanceInput interface {
	pulumi.Input

	ToMaintenanceOutput() MaintenanceOutput
	ToMaintenanceOutputWithContext(ctx context.Context) MaintenanceOutput
}

type MaintenanceMap added in v0.1.3 

type MaintenanceMap map[string]MaintenanceInput

func (MaintenanceMap) ElementType added in v0.1.3 

func (MaintenanceMap) ElementType() reflect.Type

func (MaintenanceMap) ToMaintenanceMapOutput added in v0.1.3 

func (i MaintenanceMap) ToMaintenanceMapOutput() MaintenanceMapOutput

func (MaintenanceMap) ToMaintenanceMapOutputWithContext added in v0.1.3 

func (i MaintenanceMap) ToMaintenanceMapOutputWithContext(ctx context.Context) MaintenanceMapOutput

type MaintenanceMapInput added in v0.1.3 

type MaintenanceMapInput interface {
	pulumi.Input

	ToMaintenanceMapOutput() MaintenanceMapOutput
	ToMaintenanceMapOutputWithContext(context.Context) MaintenanceMapOutput
}

MaintenanceMapInput is an input type that accepts MaintenanceMap and MaintenanceMapOutput values. You can construct a concrete instance of `MaintenanceMapInput` via: 

MaintenanceMap{ "key": MaintenanceArgs{...} }

type MaintenanceMapOutput added in v0.1.3 

type MaintenanceMapOutput struct{ *pulumi.OutputState }

func (MaintenanceMapOutput) ElementType added in v0.1.3 

func (MaintenanceMapOutput) ElementType() reflect.Type

func (MaintenanceMapOutput) MapIndex added in v0.1.3 

func (o MaintenanceMapOutput) MapIndex(k pulumi.StringInput) MaintenanceOutput

func (MaintenanceMapOutput) ToMaintenanceMapOutput added in v0.1.3 

func (o MaintenanceMapOutput) ToMaintenanceMapOutput() MaintenanceMapOutput

func (MaintenanceMapOutput) ToMaintenanceMapOutputWithContext added in v0.1.3 

func (o MaintenanceMapOutput) ToMaintenanceMapOutputWithContext(ctx context.Context) MaintenanceMapOutput

type MaintenanceOutput 

type MaintenanceOutput struct{ *pulumi.OutputState }

func (MaintenanceOutput) Description added in v1.1.9 

func (o MaintenanceOutput) Description() pulumi.StringOutput

Description for the maintenance.

func (MaintenanceOutput) ElementType 

func (MaintenanceOutput) ElementType() reflect.Type

func (MaintenanceOutput) Rules added in v1.1.9 

func (o MaintenanceOutput) Rules() MaintenanceRuleArrayOutput

Rules of maintenance, which takes a list of rule objects and defines the maintenance rules over integrations and policies.

func (MaintenanceOutput) Times added in v1.1.9 

func (o MaintenanceOutput) Times() MaintenanceTimeArrayOutput

Time configuration of maintenance. It takes a time object which has type, startDate and endDate fields

func (MaintenanceOutput) ToMaintenanceOutput 

func (o MaintenanceOutput) ToMaintenanceOutput() MaintenanceOutput

func (MaintenanceOutput) ToMaintenanceOutputWithContext 

func (o MaintenanceOutput) ToMaintenanceOutputWithContext(ctx context.Context) MaintenanceOutput

type MaintenanceRule 

type MaintenanceRule struct {
	// This field represents the entity that maintenance will be applied. Entity field takes two mandatory fields as id and type.
	Entities []MaintenanceRuleEntity `pulumi:"entities"`
	// State of rule that will be defined in maintenance and can take either enabled or disabled for policy type rules. This field has to be disabled for integration type entity rules.
	State *string `pulumi:"state"`
}

type MaintenanceRuleArgs 

type MaintenanceRuleArgs struct {
	// This field represents the entity that maintenance will be applied. Entity field takes two mandatory fields as id and type.
	Entities MaintenanceRuleEntityArrayInput `pulumi:"entities"`
	// State of rule that will be defined in maintenance and can take either enabled or disabled for policy type rules. This field has to be disabled for integration type entity rules.
	State pulumi.StringPtrInput `pulumi:"state"`
}

func (MaintenanceRuleArgs) ElementType 

func (MaintenanceRuleArgs) ElementType() reflect.Type

func (MaintenanceRuleArgs) ToMaintenanceRuleOutput 

func (i MaintenanceRuleArgs) ToMaintenanceRuleOutput() MaintenanceRuleOutput

func (MaintenanceRuleArgs) ToMaintenanceRuleOutputWithContext 

func (i MaintenanceRuleArgs) ToMaintenanceRuleOutputWithContext(ctx context.Context) MaintenanceRuleOutput

type MaintenanceRuleArray 

type MaintenanceRuleArray []MaintenanceRuleInput

func (MaintenanceRuleArray) ElementType 

func (MaintenanceRuleArray) ElementType() reflect.Type

func (MaintenanceRuleArray) ToMaintenanceRuleArrayOutput 

func (i MaintenanceRuleArray) ToMaintenanceRuleArrayOutput() MaintenanceRuleArrayOutput

func (MaintenanceRuleArray) ToMaintenanceRuleArrayOutputWithContext 

func (i MaintenanceRuleArray) ToMaintenanceRuleArrayOutputWithContext(ctx context.Context) MaintenanceRuleArrayOutput

type MaintenanceRuleArrayInput 

type MaintenanceRuleArrayInput interface {
	pulumi.Input

	ToMaintenanceRuleArrayOutput() MaintenanceRuleArrayOutput
	ToMaintenanceRuleArrayOutputWithContext(context.Context) MaintenanceRuleArrayOutput
}

MaintenanceRuleArrayInput is an input type that accepts MaintenanceRuleArray and MaintenanceRuleArrayOutput values. You can construct a concrete instance of `MaintenanceRuleArrayInput` via: 

MaintenanceRuleArray{ MaintenanceRuleArgs{...} }

type MaintenanceRuleArrayOutput 

type MaintenanceRuleArrayOutput struct{ *pulumi.OutputState }

func (MaintenanceRuleArrayOutput) ElementType 

func (MaintenanceRuleArrayOutput) ElementType() reflect.Type

func (MaintenanceRuleArrayOutput) Index 

func (o MaintenanceRuleArrayOutput) Index(i pulumi.IntInput) MaintenanceRuleOutput

func (MaintenanceRuleArrayOutput) ToMaintenanceRuleArrayOutput 

func (o MaintenanceRuleArrayOutput) ToMaintenanceRuleArrayOutput() MaintenanceRuleArrayOutput

func (MaintenanceRuleArrayOutput) ToMaintenanceRuleArrayOutputWithContext 

func (o MaintenanceRuleArrayOutput) ToMaintenanceRuleArrayOutputWithContext(ctx context.Context) MaintenanceRuleArrayOutput

type MaintenanceRuleEntity 

type MaintenanceRuleEntity struct {
	// The id of the entity that maintenance will be applied.
	Id *string `pulumi:"id"`
	// The type of the entity that maintenance will be applied. It can be either integration or policy.
	Type *string `pulumi:"type"`
}

type MaintenanceRuleEntityArgs 

type MaintenanceRuleEntityArgs struct {
	// The id of the entity that maintenance will be applied.
	Id pulumi.StringPtrInput `pulumi:"id"`
	// The type of the entity that maintenance will be applied. It can be either integration or policy.
	Type pulumi.StringPtrInput `pulumi:"type"`
}

func (MaintenanceRuleEntityArgs) ElementType 

func (MaintenanceRuleEntityArgs) ElementType() reflect.Type

func (MaintenanceRuleEntityArgs) ToMaintenanceRuleEntityOutput 

func (i MaintenanceRuleEntityArgs) ToMaintenanceRuleEntityOutput() MaintenanceRuleEntityOutput

func (MaintenanceRuleEntityArgs) ToMaintenanceRuleEntityOutputWithContext 

func (i MaintenanceRuleEntityArgs) ToMaintenanceRuleEntityOutputWithContext(ctx context.Context) MaintenanceRuleEntityOutput

type MaintenanceRuleEntityArray 

type MaintenanceRuleEntityArray []MaintenanceRuleEntityInput

func (MaintenanceRuleEntityArray) ElementType 

func (MaintenanceRuleEntityArray) ElementType() reflect.Type

func (MaintenanceRuleEntityArray) ToMaintenanceRuleEntityArrayOutput 

func (i MaintenanceRuleEntityArray) ToMaintenanceRuleEntityArrayOutput() MaintenanceRuleEntityArrayOutput

func (MaintenanceRuleEntityArray) ToMaintenanceRuleEntityArrayOutputWithContext 

func (i MaintenanceRuleEntityArray) ToMaintenanceRuleEntityArrayOutputWithContext(ctx context.Context) MaintenanceRuleEntityArrayOutput

type MaintenanceRuleEntityArrayInput 

type MaintenanceRuleEntityArrayInput interface {
	pulumi.Input

	ToMaintenanceRuleEntityArrayOutput() MaintenanceRuleEntityArrayOutput
	ToMaintenanceRuleEntityArrayOutputWithContext(context.Context) MaintenanceRuleEntityArrayOutput
}

MaintenanceRuleEntityArrayInput is an input type that accepts MaintenanceRuleEntityArray and MaintenanceRuleEntityArrayOutput values. You can construct a concrete instance of `MaintenanceRuleEntityArrayInput` via: 

MaintenanceRuleEntityArray{ MaintenanceRuleEntityArgs{...} }

type MaintenanceRuleEntityArrayOutput 

type MaintenanceRuleEntityArrayOutput struct{ *pulumi.OutputState }

func (MaintenanceRuleEntityArrayOutput) ElementType 

func (MaintenanceRuleEntityArrayOutput) ElementType() reflect.Type

func (MaintenanceRuleEntityArrayOutput) Index 

func (o MaintenanceRuleEntityArrayOutput) Index(i pulumi.IntInput) MaintenanceRuleEntityOutput

func (MaintenanceRuleEntityArrayOutput) ToMaintenanceRuleEntityArrayOutput 

func (o MaintenanceRuleEntityArrayOutput) ToMaintenanceRuleEntityArrayOutput() MaintenanceRuleEntityArrayOutput

func (MaintenanceRuleEntityArrayOutput) ToMaintenanceRuleEntityArrayOutputWithContext 

func (o MaintenanceRuleEntityArrayOutput) ToMaintenanceRuleEntityArrayOutputWithContext(ctx context.Context) MaintenanceRuleEntityArrayOutput

type MaintenanceRuleEntityInput 

type MaintenanceRuleEntityInput interface {
	pulumi.Input

	ToMaintenanceRuleEntityOutput() MaintenanceRuleEntityOutput
	ToMaintenanceRuleEntityOutputWithContext(context.Context) MaintenanceRuleEntityOutput
}

MaintenanceRuleEntityInput is an input type that accepts MaintenanceRuleEntityArgs and MaintenanceRuleEntityOutput values. You can construct a concrete instance of `MaintenanceRuleEntityInput` via: 

MaintenanceRuleEntityArgs{...}

type MaintenanceRuleEntityOutput 

type MaintenanceRuleEntityOutput struct{ *pulumi.OutputState }

func (MaintenanceRuleEntityOutput) ElementType 

func (MaintenanceRuleEntityOutput) ElementType() reflect.Type

func (MaintenanceRuleEntityOutput) Id 

func (o MaintenanceRuleEntityOutput) Id() pulumi.StringPtrOutput

The id of the entity that maintenance will be applied.

func (MaintenanceRuleEntityOutput) ToMaintenanceRuleEntityOutput 

func (o MaintenanceRuleEntityOutput) ToMaintenanceRuleEntityOutput() MaintenanceRuleEntityOutput

func (MaintenanceRuleEntityOutput) ToMaintenanceRuleEntityOutputWithContext 

func (o MaintenanceRuleEntityOutput) ToMaintenanceRuleEntityOutputWithContext(ctx context.Context) MaintenanceRuleEntityOutput

func (MaintenanceRuleEntityOutput) Type 

func (o MaintenanceRuleEntityOutput) Type() pulumi.StringPtrOutput

The type of the entity that maintenance will be applied. It can be either integration or policy.

type MaintenanceRuleInput 

type MaintenanceRuleInput interface {
	pulumi.Input

	ToMaintenanceRuleOutput() MaintenanceRuleOutput
	ToMaintenanceRuleOutputWithContext(context.Context) MaintenanceRuleOutput
}

MaintenanceRuleInput is an input type that accepts MaintenanceRuleArgs and MaintenanceRuleOutput values. You can construct a concrete instance of `MaintenanceRuleInput` via: 

MaintenanceRuleArgs{...}

type MaintenanceRuleOutput 

type MaintenanceRuleOutput struct{ *pulumi.OutputState }

func (MaintenanceRuleOutput) ElementType 

func (MaintenanceRuleOutput) ElementType() reflect.Type

func (MaintenanceRuleOutput) Entities 

func (o MaintenanceRuleOutput) Entities() MaintenanceRuleEntityArrayOutput

This field represents the entity that maintenance will be applied. Entity field takes two mandatory fields as id and type.

func (MaintenanceRuleOutput) State 

func (o MaintenanceRuleOutput) State() pulumi.StringPtrOutput

State of rule that will be defined in maintenance and can take either enabled or disabled for policy type rules. This field has to be disabled for integration type entity rules.

func (MaintenanceRuleOutput) ToMaintenanceRuleOutput 

func (o MaintenanceRuleOutput) ToMaintenanceRuleOutput() MaintenanceRuleOutput

func (MaintenanceRuleOutput) ToMaintenanceRuleOutputWithContext 

func (o MaintenanceRuleOutput) ToMaintenanceRuleOutputWithContext(ctx context.Context) MaintenanceRuleOutput

type MaintenanceState 

type MaintenanceState struct {
	// Description for the maintenance.
	Description pulumi.StringPtrInput
	// Rules of maintenance, which takes a list of rule objects and defines the maintenance rules over integrations and policies.
	Rules MaintenanceRuleArrayInput
	// Time configuration of maintenance. It takes a time object which has type, startDate and endDate fields
	Times MaintenanceTimeArrayInput
}

func (MaintenanceState) ElementType 

func (MaintenanceState) ElementType() reflect.Type

type MaintenanceTime 

type MaintenanceTime struct {
	EndDate   *string `pulumi:"endDate"`
	StartDate *string `pulumi:"startDate"`
	Type      string  `pulumi:"type"`
}

type MaintenanceTimeArgs 

type MaintenanceTimeArgs struct {
	EndDate   pulumi.StringPtrInput `pulumi:"endDate"`
	StartDate pulumi.StringPtrInput `pulumi:"startDate"`
	Type      pulumi.StringInput    `pulumi:"type"`
}

func (MaintenanceTimeArgs) ElementType 

func (MaintenanceTimeArgs) ElementType() reflect.Type

func (MaintenanceTimeArgs) ToMaintenanceTimeOutput 

func (i MaintenanceTimeArgs) ToMaintenanceTimeOutput() MaintenanceTimeOutput

func (MaintenanceTimeArgs) ToMaintenanceTimeOutputWithContext 

func (i MaintenanceTimeArgs) ToMaintenanceTimeOutputWithContext(ctx context.Context) MaintenanceTimeOutput

type MaintenanceTimeArray 

type MaintenanceTimeArray []MaintenanceTimeInput

func (MaintenanceTimeArray) ElementType 

func (MaintenanceTimeArray) ElementType() reflect.Type

func (MaintenanceTimeArray) ToMaintenanceTimeArrayOutput 

func (i MaintenanceTimeArray) ToMaintenanceTimeArrayOutput() MaintenanceTimeArrayOutput

func (MaintenanceTimeArray) ToMaintenanceTimeArrayOutputWithContext 

func (i MaintenanceTimeArray) ToMaintenanceTimeArrayOutputWithContext(ctx context.Context) MaintenanceTimeArrayOutput

type MaintenanceTimeArrayInput 

type MaintenanceTimeArrayInput interface {
	pulumi.Input

	ToMaintenanceTimeArrayOutput() MaintenanceTimeArrayOutput
	ToMaintenanceTimeArrayOutputWithContext(context.Context) MaintenanceTimeArrayOutput
}

MaintenanceTimeArrayInput is an input type that accepts MaintenanceTimeArray and MaintenanceTimeArrayOutput values. You can construct a concrete instance of `MaintenanceTimeArrayInput` via: 

MaintenanceTimeArray{ MaintenanceTimeArgs{...} }

type MaintenanceTimeArrayOutput 

type MaintenanceTimeArrayOutput struct{ *pulumi.OutputState }

func (MaintenanceTimeArrayOutput) ElementType 

func (MaintenanceTimeArrayOutput) ElementType() reflect.Type

func (MaintenanceTimeArrayOutput) Index 

func (o MaintenanceTimeArrayOutput) Index(i pulumi.IntInput) MaintenanceTimeOutput

func (MaintenanceTimeArrayOutput) ToMaintenanceTimeArrayOutput 

func (o MaintenanceTimeArrayOutput) ToMaintenanceTimeArrayOutput() MaintenanceTimeArrayOutput

func (MaintenanceTimeArrayOutput) ToMaintenanceTimeArrayOutputWithContext 

func (o MaintenanceTimeArrayOutput) ToMaintenanceTimeArrayOutputWithContext(ctx context.Context) MaintenanceTimeArrayOutput

type MaintenanceTimeInput 

type MaintenanceTimeInput interface {
	pulumi.Input

	ToMaintenanceTimeOutput() MaintenanceTimeOutput
	ToMaintenanceTimeOutputWithContext(context.Context) MaintenanceTimeOutput
}

MaintenanceTimeInput is an input type that accepts MaintenanceTimeArgs and MaintenanceTimeOutput values. You can construct a concrete instance of `MaintenanceTimeInput` via: 

MaintenanceTimeArgs{...}

type MaintenanceTimeOutput 

type MaintenanceTimeOutput struct{ *pulumi.OutputState }

func (MaintenanceTimeOutput) ElementType 

func (MaintenanceTimeOutput) ElementType() reflect.Type

func (MaintenanceTimeOutput) EndDate 

func (o MaintenanceTimeOutput) EndDate() pulumi.StringPtrOutput

func (MaintenanceTimeOutput) StartDate 

func (o MaintenanceTimeOutput) StartDate() pulumi.StringPtrOutput

func (MaintenanceTimeOutput) ToMaintenanceTimeOutput 

func (o MaintenanceTimeOutput) ToMaintenanceTimeOutput() MaintenanceTimeOutput

func (MaintenanceTimeOutput) ToMaintenanceTimeOutputWithContext 

func (o MaintenanceTimeOutput) ToMaintenanceTimeOutputWithContext(ctx context.Context) MaintenanceTimeOutput

func (MaintenanceTimeOutput) Type 

func (o MaintenanceTimeOutput) Type() pulumi.StringOutput

type NotificationPolicy 

type NotificationPolicy struct {
	pulumi.CustomResourceState

	// Auto Restart Action of the policy. This is a block, structure is documented below.
	AutoCloseActions NotificationPolicyAutoCloseActionArrayOutput `pulumi:"autoCloseActions"`
	// Auto Restart Action of the policy. This is a block, structure is documented below.
	AutoRestartActions NotificationPolicyAutoRestartActionArrayOutput `pulumi:"autoRestartActions"`
	// Deduplication Action of the policy. This is a block, structure is documented below.
	DeDuplicationActions NotificationPolicyDeDuplicationActionArrayOutput `pulumi:"deDuplicationActions"`
	// Delay notifications. This is a block, structure is documented below.
	DelayActions NotificationPolicyDelayActionArrayOutput `pulumi:"delayActions"`
	// If policy should be enabled. Default: `true`
	Enabled pulumi.BoolPtrOutput `pulumi:"enabled"`
	// A notification filter which will be applied. This filter can be empty: `filter {}` - this means `match-all`. This is a block, structure is documented below.
	Filters NotificationPolicyFilterArrayOutput `pulumi:"filters"`
	// Name of the notification policy
	Name pulumi.StringOutput `pulumi:"name"`
	// Description of the policy. This can be max 512 characters.
	PolicyDescription pulumi.StringPtrOutput `pulumi:"policyDescription"`
	// Suppress value of the policy. Values are: `true`, `false`. Default: `false`
	Suppress pulumi.BoolPtrOutput `pulumi:"suppress"`
	// Id of team that this policy belons to.
	TeamId pulumi.StringOutput `pulumi:"teamId"`
	// Time restrictions specified in this field must be met for this policy to work. This is a block, structure is documented below.
	TimeRestrictions NotificationPolicyTimeRestrictionArrayOutput `pulumi:"timeRestrictions"`
}

Manages a Notification Policy within Opsgenie.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		test, err := opsgenie.NewTeam(ctx, "test", &opsgenie.TeamArgs{
			Name:        pulumi.String("example team"),
			Description: pulumi.String("This team deals with all the things"),
		})
		if err != nil {
			return err
		}
		_, err = opsgenie.NewNotificationPolicy(ctx, "test", &opsgenie.NotificationPolicyArgs{
			Filters: opsgenie.NotificationPolicyFilterArray{
				nil,
			},
			Name:              pulumi.String("example policy"),
			TeamId:            test.ID(),
			PolicyDescription: pulumi.String("This policy has a delay action"),
			DelayActions: opsgenie.NotificationPolicyDelayActionArray{
				&opsgenie.NotificationPolicyDelayActionArgs{
					DelayOption: pulumi.String("next-time"),
					UntilMinute: pulumi.Int(1),
					UntilHour:   pulumi.Int(9),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Notification policies can be imported using the `team_id` and `notification_policy_id`, e.g.

```sh $ pulumi import opsgenie:index/notificationPolicy:NotificationPolicy test team_id/notification_policy_id` ```

func GetNotificationPolicy 

func GetNotificationPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *NotificationPolicyState, opts ...pulumi.ResourceOption) (*NotificationPolicy, error)

GetNotificationPolicy gets an existing NotificationPolicy resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewNotificationPolicy 

func NewNotificationPolicy(ctx *pulumi.Context,
	name string, args *NotificationPolicyArgs, opts ...pulumi.ResourceOption) (*NotificationPolicy, error)

NewNotificationPolicy registers a new resource with the given unique name, arguments, and options.

func (*NotificationPolicy) ElementType 

func (*NotificationPolicy) ElementType() reflect.Type

func (*NotificationPolicy) ToNotificationPolicyOutput 

func (i *NotificationPolicy) ToNotificationPolicyOutput() NotificationPolicyOutput

func (*NotificationPolicy) ToNotificationPolicyOutputWithContext 

func (i *NotificationPolicy) ToNotificationPolicyOutputWithContext(ctx context.Context) NotificationPolicyOutput

type NotificationPolicyArgs 

type NotificationPolicyArgs struct {
	// Auto Restart Action of the policy. This is a block, structure is documented below.
	AutoCloseActions NotificationPolicyAutoCloseActionArrayInput
	// Auto Restart Action of the policy. This is a block, structure is documented below.
	AutoRestartActions NotificationPolicyAutoRestartActionArrayInput
	// Deduplication Action of the policy. This is a block, structure is documented below.
	DeDuplicationActions NotificationPolicyDeDuplicationActionArrayInput
	// Delay notifications. This is a block, structure is documented below.
	DelayActions NotificationPolicyDelayActionArrayInput
	// If policy should be enabled. Default: `true`
	Enabled pulumi.BoolPtrInput
	// A notification filter which will be applied. This filter can be empty: `filter {}` - this means `match-all`. This is a block, structure is documented below.
	Filters NotificationPolicyFilterArrayInput
	// Name of the notification policy
	Name pulumi.StringPtrInput
	// Description of the policy. This can be max 512 characters.
	PolicyDescription pulumi.StringPtrInput
	// Suppress value of the policy. Values are: `true`, `false`. Default: `false`
	Suppress pulumi.BoolPtrInput
	// Id of team that this policy belons to.
	TeamId pulumi.StringInput
	// Time restrictions specified in this field must be met for this policy to work. This is a block, structure is documented below.
	TimeRestrictions NotificationPolicyTimeRestrictionArrayInput
}

The set of arguments for constructing a NotificationPolicy resource.

func (NotificationPolicyArgs) ElementType 

func (NotificationPolicyArgs) ElementType() reflect.Type

type NotificationPolicyArray added in v0.1.3 

type NotificationPolicyArray []NotificationPolicyInput

func (NotificationPolicyArray) ElementType added in v0.1.3 

func (NotificationPolicyArray) ElementType() reflect.Type

func (NotificationPolicyArray) ToNotificationPolicyArrayOutput added in v0.1.3 

func (i NotificationPolicyArray) ToNotificationPolicyArrayOutput() NotificationPolicyArrayOutput

func (NotificationPolicyArray) ToNotificationPolicyArrayOutputWithContext added in v0.1.3 

func (i NotificationPolicyArray) ToNotificationPolicyArrayOutputWithContext(ctx context.Context) NotificationPolicyArrayOutput

type NotificationPolicyArrayInput added in v0.1.3 

type NotificationPolicyArrayInput interface {
	pulumi.Input

	ToNotificationPolicyArrayOutput() NotificationPolicyArrayOutput
	ToNotificationPolicyArrayOutputWithContext(context.Context) NotificationPolicyArrayOutput
}

NotificationPolicyArrayInput is an input type that accepts NotificationPolicyArray and NotificationPolicyArrayOutput values. You can construct a concrete instance of `NotificationPolicyArrayInput` via: 

NotificationPolicyArray{ NotificationPolicyArgs{...} }

type NotificationPolicyArrayOutput added in v0.1.3 

type NotificationPolicyArrayOutput struct{ *pulumi.OutputState }

func (NotificationPolicyArrayOutput) ElementType added in v0.1.3 

func (NotificationPolicyArrayOutput) ElementType() reflect.Type

func (NotificationPolicyArrayOutput) Index added in v0.1.3 

func (o NotificationPolicyArrayOutput) Index(i pulumi.IntInput) NotificationPolicyOutput

func (NotificationPolicyArrayOutput) ToNotificationPolicyArrayOutput added in v0.1.3 

func (o NotificationPolicyArrayOutput) ToNotificationPolicyArrayOutput() NotificationPolicyArrayOutput

func (NotificationPolicyArrayOutput) ToNotificationPolicyArrayOutputWithContext added in v0.1.3 

func (o NotificationPolicyArrayOutput) ToNotificationPolicyArrayOutputWithContext(ctx context.Context) NotificationPolicyArrayOutput

type NotificationPolicyAutoCloseAction 

type NotificationPolicyAutoCloseAction struct {
	// Duration of this action. This is a block, structure is documented below.
	Durations []NotificationPolicyAutoCloseActionDuration `pulumi:"durations"`
}

type NotificationPolicyAutoCloseActionArgs 

type NotificationPolicyAutoCloseActionArgs struct {
	// Duration of this action. This is a block, structure is documented below.
	Durations NotificationPolicyAutoCloseActionDurationArrayInput `pulumi:"durations"`
}

func (NotificationPolicyAutoCloseActionArgs) ElementType 

func (NotificationPolicyAutoCloseActionArgs) ElementType() reflect.Type

func (NotificationPolicyAutoCloseActionArgs) ToNotificationPolicyAutoCloseActionOutput 

func (i NotificationPolicyAutoCloseActionArgs) ToNotificationPolicyAutoCloseActionOutput() NotificationPolicyAutoCloseActionOutput

func (NotificationPolicyAutoCloseActionArgs) ToNotificationPolicyAutoCloseActionOutputWithContext 

func (i NotificationPolicyAutoCloseActionArgs) ToNotificationPolicyAutoCloseActionOutputWithContext(ctx context.Context) NotificationPolicyAutoCloseActionOutput

type NotificationPolicyAutoCloseActionArray 

type NotificationPolicyAutoCloseActionArray []NotificationPolicyAutoCloseActionInput

func (NotificationPolicyAutoCloseActionArray) ElementType 

func (NotificationPolicyAutoCloseActionArray) ElementType() reflect.Type

func (NotificationPolicyAutoCloseActionArray) ToNotificationPolicyAutoCloseActionArrayOutput 

func (i NotificationPolicyAutoCloseActionArray) ToNotificationPolicyAutoCloseActionArrayOutput() NotificationPolicyAutoCloseActionArrayOutput

func (NotificationPolicyAutoCloseActionArray) ToNotificationPolicyAutoCloseActionArrayOutputWithContext 

func (i NotificationPolicyAutoCloseActionArray) ToNotificationPolicyAutoCloseActionArrayOutputWithContext(ctx context.Context) NotificationPolicyAutoCloseActionArrayOutput

type NotificationPolicyAutoCloseActionArrayInput 

type NotificationPolicyAutoCloseActionArrayInput interface {
	pulumi.Input

	ToNotificationPolicyAutoCloseActionArrayOutput() NotificationPolicyAutoCloseActionArrayOutput
	ToNotificationPolicyAutoCloseActionArrayOutputWithContext(context.Context) NotificationPolicyAutoCloseActionArrayOutput
}

NotificationPolicyAutoCloseActionArrayInput is an input type that accepts NotificationPolicyAutoCloseActionArray and NotificationPolicyAutoCloseActionArrayOutput values. You can construct a concrete instance of `NotificationPolicyAutoCloseActionArrayInput` via: 

NotificationPolicyAutoCloseActionArray{ NotificationPolicyAutoCloseActionArgs{...} }

type NotificationPolicyAutoCloseActionArrayOutput 

type NotificationPolicyAutoCloseActionArrayOutput struct{ *pulumi.OutputState }

func (NotificationPolicyAutoCloseActionArrayOutput) ElementType 

func (NotificationPolicyAutoCloseActionArrayOutput) ElementType() reflect.Type

func (NotificationPolicyAutoCloseActionArrayOutput) Index 

func (o NotificationPolicyAutoCloseActionArrayOutput) Index(i pulumi.IntInput) NotificationPolicyAutoCloseActionOutput

func (NotificationPolicyAutoCloseActionArrayOutput) ToNotificationPolicyAutoCloseActionArrayOutput 

func (o NotificationPolicyAutoCloseActionArrayOutput) ToNotificationPolicyAutoCloseActionArrayOutput() NotificationPolicyAutoCloseActionArrayOutput

func (NotificationPolicyAutoCloseActionArrayOutput) ToNotificationPolicyAutoCloseActionArrayOutputWithContext 

func (o NotificationPolicyAutoCloseActionArrayOutput) ToNotificationPolicyAutoCloseActionArrayOutputWithContext(ctx context.Context) NotificationPolicyAutoCloseActionArrayOutput

type NotificationPolicyAutoCloseActionDuration 

type NotificationPolicyAutoCloseActionDuration struct {
	// A amount of time in `timeUnits`. This is a integer attribute.
	TimeAmount int `pulumi:"timeAmount"`
	// Valid time units are: `minutes`, `hours`, `days`. Default: `minutes`
	TimeUnit *string `pulumi:"timeUnit"`
}

type NotificationPolicyAutoCloseActionDurationArgs 

type NotificationPolicyAutoCloseActionDurationArgs struct {
	// A amount of time in `timeUnits`. This is a integer attribute.
	TimeAmount pulumi.IntInput `pulumi:"timeAmount"`
	// Valid time units are: `minutes`, `hours`, `days`. Default: `minutes`
	TimeUnit pulumi.StringPtrInput `pulumi:"timeUnit"`
}

func (NotificationPolicyAutoCloseActionDurationArgs) ElementType 

func (NotificationPolicyAutoCloseActionDurationArgs) ElementType() reflect.Type

func (NotificationPolicyAutoCloseActionDurationArgs) ToNotificationPolicyAutoCloseActionDurationOutput 

func (i NotificationPolicyAutoCloseActionDurationArgs) ToNotificationPolicyAutoCloseActionDurationOutput() NotificationPolicyAutoCloseActionDurationOutput

func (NotificationPolicyAutoCloseActionDurationArgs) ToNotificationPolicyAutoCloseActionDurationOutputWithContext 

func (i NotificationPolicyAutoCloseActionDurationArgs) ToNotificationPolicyAutoCloseActionDurationOutputWithContext(ctx context.Context) NotificationPolicyAutoCloseActionDurationOutput

type NotificationPolicyAutoCloseActionDurationArray 

type NotificationPolicyAutoCloseActionDurationArray []NotificationPolicyAutoCloseActionDurationInput

func (NotificationPolicyAutoCloseActionDurationArray) ElementType 

func (NotificationPolicyAutoCloseActionDurationArray) ElementType() reflect.Type

func (NotificationPolicyAutoCloseActionDurationArray) ToNotificationPolicyAutoCloseActionDurationArrayOutput 

func (i NotificationPolicyAutoCloseActionDurationArray) ToNotificationPolicyAutoCloseActionDurationArrayOutput() NotificationPolicyAutoCloseActionDurationArrayOutput

func (NotificationPolicyAutoCloseActionDurationArray) ToNotificationPolicyAutoCloseActionDurationArrayOutputWithContext 

func (i NotificationPolicyAutoCloseActionDurationArray) ToNotificationPolicyAutoCloseActionDurationArrayOutputWithContext(ctx context.Context) NotificationPolicyAutoCloseActionDurationArrayOutput

type NotificationPolicyAutoCloseActionDurationArrayInput 

type NotificationPolicyAutoCloseActionDurationArrayInput interface {
	pulumi.Input

	ToNotificationPolicyAutoCloseActionDurationArrayOutput() NotificationPolicyAutoCloseActionDurationArrayOutput
	ToNotificationPolicyAutoCloseActionDurationArrayOutputWithContext(context.Context) NotificationPolicyAutoCloseActionDurationArrayOutput
}

NotificationPolicyAutoCloseActionDurationArrayInput is an input type that accepts NotificationPolicyAutoCloseActionDurationArray and NotificationPolicyAutoCloseActionDurationArrayOutput values. You can construct a concrete instance of `NotificationPolicyAutoCloseActionDurationArrayInput` via: 

NotificationPolicyAutoCloseActionDurationArray{ NotificationPolicyAutoCloseActionDurationArgs{...} }

type NotificationPolicyAutoCloseActionDurationArrayOutput 

type NotificationPolicyAutoCloseActionDurationArrayOutput struct{ *pulumi.OutputState }

func (NotificationPolicyAutoCloseActionDurationArrayOutput) ElementType 

func (NotificationPolicyAutoCloseActionDurationArrayOutput) ElementType() reflect.Type

func (NotificationPolicyAutoCloseActionDurationArrayOutput) Index 

func (o NotificationPolicyAutoCloseActionDurationArrayOutput) Index(i pulumi.IntInput) NotificationPolicyAutoCloseActionDurationOutput

func (NotificationPolicyAutoCloseActionDurationArrayOutput) ToNotificationPolicyAutoCloseActionDurationArrayOutput 

func (o NotificationPolicyAutoCloseActionDurationArrayOutput) ToNotificationPolicyAutoCloseActionDurationArrayOutput() NotificationPolicyAutoCloseActionDurationArrayOutput

func (NotificationPolicyAutoCloseActionDurationArrayOutput) ToNotificationPolicyAutoCloseActionDurationArrayOutputWithContext 

func (o NotificationPolicyAutoCloseActionDurationArrayOutput) ToNotificationPolicyAutoCloseActionDurationArrayOutputWithContext(ctx context.Context) NotificationPolicyAutoCloseActionDurationArrayOutput

type NotificationPolicyAutoCloseActionDurationInput 

type NotificationPolicyAutoCloseActionDurationInput interface {
	pulumi.Input

	ToNotificationPolicyAutoCloseActionDurationOutput() NotificationPolicyAutoCloseActionDurationOutput
	ToNotificationPolicyAutoCloseActionDurationOutputWithContext(context.Context) NotificationPolicyAutoCloseActionDurationOutput
}

NotificationPolicyAutoCloseActionDurationInput is an input type that accepts NotificationPolicyAutoCloseActionDurationArgs and NotificationPolicyAutoCloseActionDurationOutput values. You can construct a concrete instance of `NotificationPolicyAutoCloseActionDurationInput` via: 

NotificationPolicyAutoCloseActionDurationArgs{...}

type NotificationPolicyAutoCloseActionDurationOutput 

type NotificationPolicyAutoCloseActionDurationOutput struct{ *pulumi.OutputState }

func (NotificationPolicyAutoCloseActionDurationOutput) ElementType 

func (NotificationPolicyAutoCloseActionDurationOutput) ElementType() reflect.Type

func (NotificationPolicyAutoCloseActionDurationOutput) TimeAmount 

func (o NotificationPolicyAutoCloseActionDurationOutput) TimeAmount() pulumi.IntOutput

A amount of time in `timeUnits`. This is a integer attribute.

func (NotificationPolicyAutoCloseActionDurationOutput) TimeUnit 

func (o NotificationPolicyAutoCloseActionDurationOutput) TimeUnit() pulumi.StringPtrOutput

Valid time units are: `minutes`, `hours`, `days`. Default: `minutes`

func (NotificationPolicyAutoCloseActionDurationOutput) ToNotificationPolicyAutoCloseActionDurationOutput 

func (o NotificationPolicyAutoCloseActionDurationOutput) ToNotificationPolicyAutoCloseActionDurationOutput() NotificationPolicyAutoCloseActionDurationOutput

func (NotificationPolicyAutoCloseActionDurationOutput) ToNotificationPolicyAutoCloseActionDurationOutputWithContext 

func (o NotificationPolicyAutoCloseActionDurationOutput) ToNotificationPolicyAutoCloseActionDurationOutputWithContext(ctx context.Context) NotificationPolicyAutoCloseActionDurationOutput

type NotificationPolicyAutoCloseActionInput 

type NotificationPolicyAutoCloseActionInput interface {
	pulumi.Input

	ToNotificationPolicyAutoCloseActionOutput() NotificationPolicyAutoCloseActionOutput
	ToNotificationPolicyAutoCloseActionOutputWithContext(context.Context) NotificationPolicyAutoCloseActionOutput
}

NotificationPolicyAutoCloseActionInput is an input type that accepts NotificationPolicyAutoCloseActionArgs and NotificationPolicyAutoCloseActionOutput values. You can construct a concrete instance of `NotificationPolicyAutoCloseActionInput` via: 

NotificationPolicyAutoCloseActionArgs{...}

type NotificationPolicyAutoCloseActionOutput 

type NotificationPolicyAutoCloseActionOutput struct{ *pulumi.OutputState }

func (NotificationPolicyAutoCloseActionOutput) Durations 

func (o NotificationPolicyAutoCloseActionOutput) Durations() NotificationPolicyAutoCloseActionDurationArrayOutput

Duration of this action. This is a block, structure is documented below.

func (NotificationPolicyAutoCloseActionOutput) ElementType 

func (NotificationPolicyAutoCloseActionOutput) ElementType() reflect.Type

func (NotificationPolicyAutoCloseActionOutput) ToNotificationPolicyAutoCloseActionOutput 

func (o NotificationPolicyAutoCloseActionOutput) ToNotificationPolicyAutoCloseActionOutput() NotificationPolicyAutoCloseActionOutput

func (NotificationPolicyAutoCloseActionOutput) ToNotificationPolicyAutoCloseActionOutputWithContext 

func (o NotificationPolicyAutoCloseActionOutput) ToNotificationPolicyAutoCloseActionOutputWithContext(ctx context.Context) NotificationPolicyAutoCloseActionOutput

type NotificationPolicyAutoRestartAction 

type NotificationPolicyAutoRestartAction struct {
	// Duration of this action. This is a block, structure is documented below.
	Durations []NotificationPolicyAutoRestartActionDuration `pulumi:"durations"`
	// How many times to repeat. This is a integer attribute.
	MaxRepeatCount int `pulumi:"maxRepeatCount"`
}

type NotificationPolicyAutoRestartActionArgs 

type NotificationPolicyAutoRestartActionArgs struct {
	// Duration of this action. This is a block, structure is documented below.
	Durations NotificationPolicyAutoRestartActionDurationArrayInput `pulumi:"durations"`
	// How many times to repeat. This is a integer attribute.
	MaxRepeatCount pulumi.IntInput `pulumi:"maxRepeatCount"`
}

func (NotificationPolicyAutoRestartActionArgs) ElementType 

func (NotificationPolicyAutoRestartActionArgs) ElementType() reflect.Type

func (NotificationPolicyAutoRestartActionArgs) ToNotificationPolicyAutoRestartActionOutput 

func (i NotificationPolicyAutoRestartActionArgs) ToNotificationPolicyAutoRestartActionOutput() NotificationPolicyAutoRestartActionOutput

func (NotificationPolicyAutoRestartActionArgs) ToNotificationPolicyAutoRestartActionOutputWithContext 

func (i NotificationPolicyAutoRestartActionArgs) ToNotificationPolicyAutoRestartActionOutputWithContext(ctx context.Context) NotificationPolicyAutoRestartActionOutput

type NotificationPolicyAutoRestartActionArray 

type NotificationPolicyAutoRestartActionArray []NotificationPolicyAutoRestartActionInput

func (NotificationPolicyAutoRestartActionArray) ElementType 

func (NotificationPolicyAutoRestartActionArray) ElementType() reflect.Type

func (NotificationPolicyAutoRestartActionArray) ToNotificationPolicyAutoRestartActionArrayOutput 

func (i NotificationPolicyAutoRestartActionArray) ToNotificationPolicyAutoRestartActionArrayOutput() NotificationPolicyAutoRestartActionArrayOutput

func (NotificationPolicyAutoRestartActionArray) ToNotificationPolicyAutoRestartActionArrayOutputWithContext 

func (i NotificationPolicyAutoRestartActionArray) ToNotificationPolicyAutoRestartActionArrayOutputWithContext(ctx context.Context) NotificationPolicyAutoRestartActionArrayOutput

type NotificationPolicyAutoRestartActionArrayInput 

type NotificationPolicyAutoRestartActionArrayInput interface {
	pulumi.Input

	ToNotificationPolicyAutoRestartActionArrayOutput() NotificationPolicyAutoRestartActionArrayOutput
	ToNotificationPolicyAutoRestartActionArrayOutputWithContext(context.Context) NotificationPolicyAutoRestartActionArrayOutput
}

NotificationPolicyAutoRestartActionArrayInput is an input type that accepts NotificationPolicyAutoRestartActionArray and NotificationPolicyAutoRestartActionArrayOutput values. You can construct a concrete instance of `NotificationPolicyAutoRestartActionArrayInput` via: 

NotificationPolicyAutoRestartActionArray{ NotificationPolicyAutoRestartActionArgs{...} }

type NotificationPolicyAutoRestartActionArrayOutput 

type NotificationPolicyAutoRestartActionArrayOutput struct{ *pulumi.OutputState }

func (NotificationPolicyAutoRestartActionArrayOutput) ElementType 

func (NotificationPolicyAutoRestartActionArrayOutput) ElementType() reflect.Type

func (NotificationPolicyAutoRestartActionArrayOutput) Index 

func (o NotificationPolicyAutoRestartActionArrayOutput) Index(i pulumi.IntInput) NotificationPolicyAutoRestartActionOutput

func (NotificationPolicyAutoRestartActionArrayOutput) ToNotificationPolicyAutoRestartActionArrayOutput 

func (o NotificationPolicyAutoRestartActionArrayOutput) ToNotificationPolicyAutoRestartActionArrayOutput() NotificationPolicyAutoRestartActionArrayOutput

func (NotificationPolicyAutoRestartActionArrayOutput) ToNotificationPolicyAutoRestartActionArrayOutputWithContext 

func (o NotificationPolicyAutoRestartActionArrayOutput) ToNotificationPolicyAutoRestartActionArrayOutputWithContext(ctx context.Context) NotificationPolicyAutoRestartActionArrayOutput

type NotificationPolicyAutoRestartActionDuration 

type NotificationPolicyAutoRestartActionDuration struct {
	// A amount of time in `timeUnits`. This is a integer attribute.
	TimeAmount int `pulumi:"timeAmount"`
	// Valid time units are: `minutes`, `hours`, `days`. Default: `minutes`
	TimeUnit *string `pulumi:"timeUnit"`
}

type NotificationPolicyAutoRestartActionDurationArgs 

type NotificationPolicyAutoRestartActionDurationArgs struct {
	// A amount of time in `timeUnits`. This is a integer attribute.
	TimeAmount pulumi.IntInput `pulumi:"timeAmount"`
	// Valid time units are: `minutes`, `hours`, `days`. Default: `minutes`
	TimeUnit pulumi.StringPtrInput `pulumi:"timeUnit"`
}

func (NotificationPolicyAutoRestartActionDurationArgs) ElementType 

func (NotificationPolicyAutoRestartActionDurationArgs) ElementType() reflect.Type

func (NotificationPolicyAutoRestartActionDurationArgs) ToNotificationPolicyAutoRestartActionDurationOutput 

func (i NotificationPolicyAutoRestartActionDurationArgs) ToNotificationPolicyAutoRestartActionDurationOutput() NotificationPolicyAutoRestartActionDurationOutput

func (NotificationPolicyAutoRestartActionDurationArgs) ToNotificationPolicyAutoRestartActionDurationOutputWithContext 

func (i NotificationPolicyAutoRestartActionDurationArgs) ToNotificationPolicyAutoRestartActionDurationOutputWithContext(ctx context.Context) NotificationPolicyAutoRestartActionDurationOutput

type NotificationPolicyAutoRestartActionDurationArray 

type NotificationPolicyAutoRestartActionDurationArray []NotificationPolicyAutoRestartActionDurationInput

func (NotificationPolicyAutoRestartActionDurationArray) ElementType 

func (NotificationPolicyAutoRestartActionDurationArray) ElementType() reflect.Type

func (NotificationPolicyAutoRestartActionDurationArray) ToNotificationPolicyAutoRestartActionDurationArrayOutput 

func (i NotificationPolicyAutoRestartActionDurationArray) ToNotificationPolicyAutoRestartActionDurationArrayOutput() NotificationPolicyAutoRestartActionDurationArrayOutput

func (NotificationPolicyAutoRestartActionDurationArray) ToNotificationPolicyAutoRestartActionDurationArrayOutputWithContext 

func (i NotificationPolicyAutoRestartActionDurationArray) ToNotificationPolicyAutoRestartActionDurationArrayOutputWithContext(ctx context.Context) NotificationPolicyAutoRestartActionDurationArrayOutput

type NotificationPolicyAutoRestartActionDurationArrayInput 

type NotificationPolicyAutoRestartActionDurationArrayInput interface {
	pulumi.Input

	ToNotificationPolicyAutoRestartActionDurationArrayOutput() NotificationPolicyAutoRestartActionDurationArrayOutput
	ToNotificationPolicyAutoRestartActionDurationArrayOutputWithContext(context.Context) NotificationPolicyAutoRestartActionDurationArrayOutput
}

NotificationPolicyAutoRestartActionDurationArrayInput is an input type that accepts NotificationPolicyAutoRestartActionDurationArray and NotificationPolicyAutoRestartActionDurationArrayOutput values. You can construct a concrete instance of `NotificationPolicyAutoRestartActionDurationArrayInput` via: 

NotificationPolicyAutoRestartActionDurationArray{ NotificationPolicyAutoRestartActionDurationArgs{...} }

type NotificationPolicyAutoRestartActionDurationArrayOutput 

type NotificationPolicyAutoRestartActionDurationArrayOutput struct{ *pulumi.OutputState }

func (NotificationPolicyAutoRestartActionDurationArrayOutput) ElementType 

func (NotificationPolicyAutoRestartActionDurationArrayOutput) ElementType() reflect.Type

func (NotificationPolicyAutoRestartActionDurationArrayOutput) Index 

func (o NotificationPolicyAutoRestartActionDurationArrayOutput) Index(i pulumi.IntInput) NotificationPolicyAutoRestartActionDurationOutput

func (NotificationPolicyAutoRestartActionDurationArrayOutput) ToNotificationPolicyAutoRestartActionDurationArrayOutput 

func (o NotificationPolicyAutoRestartActionDurationArrayOutput) ToNotificationPolicyAutoRestartActionDurationArrayOutput() NotificationPolicyAutoRestartActionDurationArrayOutput

func (NotificationPolicyAutoRestartActionDurationArrayOutput) ToNotificationPolicyAutoRestartActionDurationArrayOutputWithContext 

func (o NotificationPolicyAutoRestartActionDurationArrayOutput) ToNotificationPolicyAutoRestartActionDurationArrayOutputWithContext(ctx context.Context) NotificationPolicyAutoRestartActionDurationArrayOutput

type NotificationPolicyAutoRestartActionDurationInput 

type NotificationPolicyAutoRestartActionDurationInput interface {
	pulumi.Input

	ToNotificationPolicyAutoRestartActionDurationOutput() NotificationPolicyAutoRestartActionDurationOutput
	ToNotificationPolicyAutoRestartActionDurationOutputWithContext(context.Context) NotificationPolicyAutoRestartActionDurationOutput
}

NotificationPolicyAutoRestartActionDurationInput is an input type that accepts NotificationPolicyAutoRestartActionDurationArgs and NotificationPolicyAutoRestartActionDurationOutput values. You can construct a concrete instance of `NotificationPolicyAutoRestartActionDurationInput` via: 

NotificationPolicyAutoRestartActionDurationArgs{...}

type NotificationPolicyAutoRestartActionDurationOutput 

type NotificationPolicyAutoRestartActionDurationOutput struct{ *pulumi.OutputState }

func (NotificationPolicyAutoRestartActionDurationOutput) ElementType 

func (NotificationPolicyAutoRestartActionDurationOutput) ElementType() reflect.Type

func (NotificationPolicyAutoRestartActionDurationOutput) TimeAmount 

func (o NotificationPolicyAutoRestartActionDurationOutput) TimeAmount() pulumi.IntOutput

A amount of time in `timeUnits`. This is a integer attribute.

func (NotificationPolicyAutoRestartActionDurationOutput) TimeUnit 

func (o NotificationPolicyAutoRestartActionDurationOutput) TimeUnit() pulumi.StringPtrOutput

Valid time units are: `minutes`, `hours`, `days`. Default: `minutes`

func (NotificationPolicyAutoRestartActionDurationOutput) ToNotificationPolicyAutoRestartActionDurationOutput 

func (o NotificationPolicyAutoRestartActionDurationOutput) ToNotificationPolicyAutoRestartActionDurationOutput() NotificationPolicyAutoRestartActionDurationOutput

func (NotificationPolicyAutoRestartActionDurationOutput) ToNotificationPolicyAutoRestartActionDurationOutputWithContext 

func (o NotificationPolicyAutoRestartActionDurationOutput) ToNotificationPolicyAutoRestartActionDurationOutputWithContext(ctx context.Context) NotificationPolicyAutoRestartActionDurationOutput

type NotificationPolicyAutoRestartActionInput 

type NotificationPolicyAutoRestartActionInput interface {
	pulumi.Input

	ToNotificationPolicyAutoRestartActionOutput() NotificationPolicyAutoRestartActionOutput
	ToNotificationPolicyAutoRestartActionOutputWithContext(context.Context) NotificationPolicyAutoRestartActionOutput
}

NotificationPolicyAutoRestartActionInput is an input type that accepts NotificationPolicyAutoRestartActionArgs and NotificationPolicyAutoRestartActionOutput values. You can construct a concrete instance of `NotificationPolicyAutoRestartActionInput` via: 

NotificationPolicyAutoRestartActionArgs{...}

type NotificationPolicyAutoRestartActionOutput 

type NotificationPolicyAutoRestartActionOutput struct{ *pulumi.OutputState }

func (NotificationPolicyAutoRestartActionOutput) Durations 

func (o NotificationPolicyAutoRestartActionOutput) Durations() NotificationPolicyAutoRestartActionDurationArrayOutput

Duration of this action. This is a block, structure is documented below.

func (NotificationPolicyAutoRestartActionOutput) ElementType 

func (NotificationPolicyAutoRestartActionOutput) ElementType() reflect.Type

func (NotificationPolicyAutoRestartActionOutput) MaxRepeatCount 

func (o NotificationPolicyAutoRestartActionOutput) MaxRepeatCount() pulumi.IntOutput

How many times to repeat. This is a integer attribute.

func (NotificationPolicyAutoRestartActionOutput) ToNotificationPolicyAutoRestartActionOutput 

func (o NotificationPolicyAutoRestartActionOutput) ToNotificationPolicyAutoRestartActionOutput() NotificationPolicyAutoRestartActionOutput

func (NotificationPolicyAutoRestartActionOutput) ToNotificationPolicyAutoRestartActionOutputWithContext 

func (o NotificationPolicyAutoRestartActionOutput) ToNotificationPolicyAutoRestartActionOutputWithContext(ctx context.Context) NotificationPolicyAutoRestartActionOutput

type NotificationPolicyDeDuplicationAction 

type NotificationPolicyDeDuplicationAction struct {
	// Count
	Count int `pulumi:"count"`
	// Deduplication type. Possible values are: "value-based", "frequency-based"
	DeDuplicationActionType string `pulumi:"deDuplicationActionType"`
	// Duration of this action (only required for "frequency-based" de-duplication action). This is a block, structure is documented below.
	Durations []NotificationPolicyDeDuplicationActionDuration `pulumi:"durations"`
}

type NotificationPolicyDeDuplicationActionArgs 

type NotificationPolicyDeDuplicationActionArgs struct {
	// Count
	Count pulumi.IntInput `pulumi:"count"`
	// Deduplication type. Possible values are: "value-based", "frequency-based"
	DeDuplicationActionType pulumi.StringInput `pulumi:"deDuplicationActionType"`
	// Duration of this action (only required for "frequency-based" de-duplication action). This is a block, structure is documented below.
	Durations NotificationPolicyDeDuplicationActionDurationArrayInput `pulumi:"durations"`
}

func (NotificationPolicyDeDuplicationActionArgs) ElementType 

func (NotificationPolicyDeDuplicationActionArgs) ElementType() reflect.Type

func (NotificationPolicyDeDuplicationActionArgs) ToNotificationPolicyDeDuplicationActionOutput 

func (i NotificationPolicyDeDuplicationActionArgs) ToNotificationPolicyDeDuplicationActionOutput() NotificationPolicyDeDuplicationActionOutput

func (NotificationPolicyDeDuplicationActionArgs) ToNotificationPolicyDeDuplicationActionOutputWithContext 

func (i NotificationPolicyDeDuplicationActionArgs) ToNotificationPolicyDeDuplicationActionOutputWithContext(ctx context.Context) NotificationPolicyDeDuplicationActionOutput

type NotificationPolicyDeDuplicationActionArray 

type NotificationPolicyDeDuplicationActionArray []NotificationPolicyDeDuplicationActionInput

func (NotificationPolicyDeDuplicationActionArray) ElementType 

func (NotificationPolicyDeDuplicationActionArray) ElementType() reflect.Type

func (NotificationPolicyDeDuplicationActionArray) ToNotificationPolicyDeDuplicationActionArrayOutput 

func (i NotificationPolicyDeDuplicationActionArray) ToNotificationPolicyDeDuplicationActionArrayOutput() NotificationPolicyDeDuplicationActionArrayOutput

func (NotificationPolicyDeDuplicationActionArray) ToNotificationPolicyDeDuplicationActionArrayOutputWithContext 

func (i NotificationPolicyDeDuplicationActionArray) ToNotificationPolicyDeDuplicationActionArrayOutputWithContext(ctx context.Context) NotificationPolicyDeDuplicationActionArrayOutput

type NotificationPolicyDeDuplicationActionArrayInput 

type NotificationPolicyDeDuplicationActionArrayInput interface {
	pulumi.Input

	ToNotificationPolicyDeDuplicationActionArrayOutput() NotificationPolicyDeDuplicationActionArrayOutput
	ToNotificationPolicyDeDuplicationActionArrayOutputWithContext(context.Context) NotificationPolicyDeDuplicationActionArrayOutput
}

NotificationPolicyDeDuplicationActionArrayInput is an input type that accepts NotificationPolicyDeDuplicationActionArray and NotificationPolicyDeDuplicationActionArrayOutput values. You can construct a concrete instance of `NotificationPolicyDeDuplicationActionArrayInput` via: 

NotificationPolicyDeDuplicationActionArray{ NotificationPolicyDeDuplicationActionArgs{...} }

type NotificationPolicyDeDuplicationActionArrayOutput 

type NotificationPolicyDeDuplicationActionArrayOutput struct{ *pulumi.OutputState }

func (NotificationPolicyDeDuplicationActionArrayOutput) ElementType 

func (NotificationPolicyDeDuplicationActionArrayOutput) ElementType() reflect.Type

func (NotificationPolicyDeDuplicationActionArrayOutput) Index 

func (o NotificationPolicyDeDuplicationActionArrayOutput) Index(i pulumi.IntInput) NotificationPolicyDeDuplicationActionOutput

func (NotificationPolicyDeDuplicationActionArrayOutput) ToNotificationPolicyDeDuplicationActionArrayOutput 

func (o NotificationPolicyDeDuplicationActionArrayOutput) ToNotificationPolicyDeDuplicationActionArrayOutput() NotificationPolicyDeDuplicationActionArrayOutput

func (NotificationPolicyDeDuplicationActionArrayOutput) ToNotificationPolicyDeDuplicationActionArrayOutputWithContext 

func (o NotificationPolicyDeDuplicationActionArrayOutput) ToNotificationPolicyDeDuplicationActionArrayOutputWithContext(ctx context.Context) NotificationPolicyDeDuplicationActionArrayOutput

type NotificationPolicyDeDuplicationActionDuration 

type NotificationPolicyDeDuplicationActionDuration struct {
	// A amount of time in `timeUnits`. This is a integer attribute.
	TimeAmount int `pulumi:"timeAmount"`
	// Valid time units are: `minutes`, `hours`, `days`. Default: `minutes`
	TimeUnit *string `pulumi:"timeUnit"`
}

type NotificationPolicyDeDuplicationActionDurationArgs 

type NotificationPolicyDeDuplicationActionDurationArgs struct {
	// A amount of time in `timeUnits`. This is a integer attribute.
	TimeAmount pulumi.IntInput `pulumi:"timeAmount"`
	// Valid time units are: `minutes`, `hours`, `days`. Default: `minutes`
	TimeUnit pulumi.StringPtrInput `pulumi:"timeUnit"`
}

func (NotificationPolicyDeDuplicationActionDurationArgs) ElementType 

func (NotificationPolicyDeDuplicationActionDurationArgs) ElementType() reflect.Type

func (NotificationPolicyDeDuplicationActionDurationArgs) ToNotificationPolicyDeDuplicationActionDurationOutput 

func (i NotificationPolicyDeDuplicationActionDurationArgs) ToNotificationPolicyDeDuplicationActionDurationOutput() NotificationPolicyDeDuplicationActionDurationOutput

func (NotificationPolicyDeDuplicationActionDurationArgs) ToNotificationPolicyDeDuplicationActionDurationOutputWithContext 

func (i NotificationPolicyDeDuplicationActionDurationArgs) ToNotificationPolicyDeDuplicationActionDurationOutputWithContext(ctx context.Context) NotificationPolicyDeDuplicationActionDurationOutput

type NotificationPolicyDeDuplicationActionDurationArray 

type NotificationPolicyDeDuplicationActionDurationArray []NotificationPolicyDeDuplicationActionDurationInput

func (NotificationPolicyDeDuplicationActionDurationArray) ElementType 

func (NotificationPolicyDeDuplicationActionDurationArray) ElementType() reflect.Type

func (NotificationPolicyDeDuplicationActionDurationArray) ToNotificationPolicyDeDuplicationActionDurationArrayOutput 

func (i NotificationPolicyDeDuplicationActionDurationArray) ToNotificationPolicyDeDuplicationActionDurationArrayOutput() NotificationPolicyDeDuplicationActionDurationArrayOutput

func (NotificationPolicyDeDuplicationActionDurationArray) ToNotificationPolicyDeDuplicationActionDurationArrayOutputWithContext 

func (i NotificationPolicyDeDuplicationActionDurationArray) ToNotificationPolicyDeDuplicationActionDurationArrayOutputWithContext(ctx context.Context) NotificationPolicyDeDuplicationActionDurationArrayOutput

type NotificationPolicyDeDuplicationActionDurationArrayInput 

type NotificationPolicyDeDuplicationActionDurationArrayInput interface {
	pulumi.Input

	ToNotificationPolicyDeDuplicationActionDurationArrayOutput() NotificationPolicyDeDuplicationActionDurationArrayOutput
	ToNotificationPolicyDeDuplicationActionDurationArrayOutputWithContext(context.Context) NotificationPolicyDeDuplicationActionDurationArrayOutput
}

NotificationPolicyDeDuplicationActionDurationArrayInput is an input type that accepts NotificationPolicyDeDuplicationActionDurationArray and NotificationPolicyDeDuplicationActionDurationArrayOutput values. You can construct a concrete instance of `NotificationPolicyDeDuplicationActionDurationArrayInput` via: 

NotificationPolicyDeDuplicationActionDurationArray{ NotificationPolicyDeDuplicationActionDurationArgs{...} }

type NotificationPolicyDeDuplicationActionDurationArrayOutput 

type NotificationPolicyDeDuplicationActionDurationArrayOutput struct{ *pulumi.OutputState }

func (NotificationPolicyDeDuplicationActionDurationArrayOutput) ElementType 

func (NotificationPolicyDeDuplicationActionDurationArrayOutput) ElementType() reflect.Type

func (NotificationPolicyDeDuplicationActionDurationArrayOutput) Index 

func (o NotificationPolicyDeDuplicationActionDurationArrayOutput) Index(i pulumi.IntInput) NotificationPolicyDeDuplicationActionDurationOutput

func (NotificationPolicyDeDuplicationActionDurationArrayOutput) ToNotificationPolicyDeDuplicationActionDurationArrayOutput 

func (o NotificationPolicyDeDuplicationActionDurationArrayOutput) ToNotificationPolicyDeDuplicationActionDurationArrayOutput() NotificationPolicyDeDuplicationActionDurationArrayOutput

func (NotificationPolicyDeDuplicationActionDurationArrayOutput) ToNotificationPolicyDeDuplicationActionDurationArrayOutputWithContext 

func (o NotificationPolicyDeDuplicationActionDurationArrayOutput) ToNotificationPolicyDeDuplicationActionDurationArrayOutputWithContext(ctx context.Context) NotificationPolicyDeDuplicationActionDurationArrayOutput

type NotificationPolicyDeDuplicationActionDurationInput 

type NotificationPolicyDeDuplicationActionDurationInput interface {
	pulumi.Input

	ToNotificationPolicyDeDuplicationActionDurationOutput() NotificationPolicyDeDuplicationActionDurationOutput
	ToNotificationPolicyDeDuplicationActionDurationOutputWithContext(context.Context) NotificationPolicyDeDuplicationActionDurationOutput
}

NotificationPolicyDeDuplicationActionDurationInput is an input type that accepts NotificationPolicyDeDuplicationActionDurationArgs and NotificationPolicyDeDuplicationActionDurationOutput values. You can construct a concrete instance of `NotificationPolicyDeDuplicationActionDurationInput` via: 

NotificationPolicyDeDuplicationActionDurationArgs{...}

type NotificationPolicyDeDuplicationActionDurationOutput 

type NotificationPolicyDeDuplicationActionDurationOutput struct{ *pulumi.OutputState }

func (NotificationPolicyDeDuplicationActionDurationOutput) ElementType 

func (NotificationPolicyDeDuplicationActionDurationOutput) ElementType() reflect.Type

func (NotificationPolicyDeDuplicationActionDurationOutput) TimeAmount 

func (o NotificationPolicyDeDuplicationActionDurationOutput) TimeAmount() pulumi.IntOutput

A amount of time in `timeUnits`. This is a integer attribute.

func (NotificationPolicyDeDuplicationActionDurationOutput) TimeUnit 

func (o NotificationPolicyDeDuplicationActionDurationOutput) TimeUnit() pulumi.StringPtrOutput

Valid time units are: `minutes`, `hours`, `days`. Default: `minutes`

func (NotificationPolicyDeDuplicationActionDurationOutput) ToNotificationPolicyDeDuplicationActionDurationOutput 

func (o NotificationPolicyDeDuplicationActionDurationOutput) ToNotificationPolicyDeDuplicationActionDurationOutput() NotificationPolicyDeDuplicationActionDurationOutput

func (NotificationPolicyDeDuplicationActionDurationOutput) ToNotificationPolicyDeDuplicationActionDurationOutputWithContext 

func (o NotificationPolicyDeDuplicationActionDurationOutput) ToNotificationPolicyDeDuplicationActionDurationOutputWithContext(ctx context.Context) NotificationPolicyDeDuplicationActionDurationOutput

type NotificationPolicyDeDuplicationActionInput 

type NotificationPolicyDeDuplicationActionInput interface {
	pulumi.Input

	ToNotificationPolicyDeDuplicationActionOutput() NotificationPolicyDeDuplicationActionOutput
	ToNotificationPolicyDeDuplicationActionOutputWithContext(context.Context) NotificationPolicyDeDuplicationActionOutput
}

NotificationPolicyDeDuplicationActionInput is an input type that accepts NotificationPolicyDeDuplicationActionArgs and NotificationPolicyDeDuplicationActionOutput values. You can construct a concrete instance of `NotificationPolicyDeDuplicationActionInput` via: 

NotificationPolicyDeDuplicationActionArgs{...}

type NotificationPolicyDeDuplicationActionOutput 

type NotificationPolicyDeDuplicationActionOutput struct{ *pulumi.OutputState }

func (NotificationPolicyDeDuplicationActionOutput) Count 

func (o NotificationPolicyDeDuplicationActionOutput) Count() pulumi.IntOutput

Count

func (NotificationPolicyDeDuplicationActionOutput) DeDuplicationActionType 

func (o NotificationPolicyDeDuplicationActionOutput) DeDuplicationActionType() pulumi.StringOutput

Deduplication type. Possible values are: "value-based", "frequency-based"

func (NotificationPolicyDeDuplicationActionOutput) Durations 

func (o NotificationPolicyDeDuplicationActionOutput) Durations() NotificationPolicyDeDuplicationActionDurationArrayOutput

Duration of this action (only required for "frequency-based" de-duplication action). This is a block, structure is documented below.

func (NotificationPolicyDeDuplicationActionOutput) ElementType 

func (NotificationPolicyDeDuplicationActionOutput) ElementType() reflect.Type

func (NotificationPolicyDeDuplicationActionOutput) ToNotificationPolicyDeDuplicationActionOutput 

func (o NotificationPolicyDeDuplicationActionOutput) ToNotificationPolicyDeDuplicationActionOutput() NotificationPolicyDeDuplicationActionOutput

func (NotificationPolicyDeDuplicationActionOutput) ToNotificationPolicyDeDuplicationActionOutputWithContext 

func (o NotificationPolicyDeDuplicationActionOutput) ToNotificationPolicyDeDuplicationActionOutputWithContext(ctx context.Context) NotificationPolicyDeDuplicationActionOutput

type NotificationPolicyDelayAction 

type NotificationPolicyDelayAction struct {
	// Defines until what day to delay or for what duration. Possible values are: `for-duration`, `next-time`, `next-weekday`, `next-monday`, `next-tuesday`, `next-wednesday`, `next-thursday`, `next-friday`, `next-saturday`, `next-sunday`
	DelayOption string `pulumi:"delayOption"`
	// Duration of this action. If `delayOption` = `for-duration` this has to be set. This is a block, structure is documented below.
	Durations []NotificationPolicyDelayActionDuration `pulumi:"durations"`
	// Until what hour notifications will be delayed. If `delayOption` is set to antyhing else then `for-duration` this has to be set.
	UntilHour *int `pulumi:"untilHour"`
	// Until what minute on `untilHour` notifications will be delayed. If `delayOption` is set to antyhing else then `for-duration` this has to be set.
	UntilMinute *int `pulumi:"untilMinute"`
}

type NotificationPolicyDelayActionArgs 

type NotificationPolicyDelayActionArgs struct {
	// Defines until what day to delay or for what duration. Possible values are: `for-duration`, `next-time`, `next-weekday`, `next-monday`, `next-tuesday`, `next-wednesday`, `next-thursday`, `next-friday`, `next-saturday`, `next-sunday`
	DelayOption pulumi.StringInput `pulumi:"delayOption"`
	// Duration of this action. If `delayOption` = `for-duration` this has to be set. This is a block, structure is documented below.
	Durations NotificationPolicyDelayActionDurationArrayInput `pulumi:"durations"`
	// Until what hour notifications will be delayed. If `delayOption` is set to antyhing else then `for-duration` this has to be set.
	UntilHour pulumi.IntPtrInput `pulumi:"untilHour"`
	// Until what minute on `untilHour` notifications will be delayed. If `delayOption` is set to antyhing else then `for-duration` this has to be set.
	UntilMinute pulumi.IntPtrInput `pulumi:"untilMinute"`
}

func (NotificationPolicyDelayActionArgs) ElementType 

func (NotificationPolicyDelayActionArgs) ElementType() reflect.Type

func (NotificationPolicyDelayActionArgs) ToNotificationPolicyDelayActionOutput 

func (i NotificationPolicyDelayActionArgs) ToNotificationPolicyDelayActionOutput() NotificationPolicyDelayActionOutput

func (NotificationPolicyDelayActionArgs) ToNotificationPolicyDelayActionOutputWithContext 

func (i NotificationPolicyDelayActionArgs) ToNotificationPolicyDelayActionOutputWithContext(ctx context.Context) NotificationPolicyDelayActionOutput

type NotificationPolicyDelayActionArray 

type NotificationPolicyDelayActionArray []NotificationPolicyDelayActionInput

func (NotificationPolicyDelayActionArray) ElementType 

func (NotificationPolicyDelayActionArray) ElementType() reflect.Type

func (NotificationPolicyDelayActionArray) ToNotificationPolicyDelayActionArrayOutput 

func (i NotificationPolicyDelayActionArray) ToNotificationPolicyDelayActionArrayOutput() NotificationPolicyDelayActionArrayOutput

func (NotificationPolicyDelayActionArray) ToNotificationPolicyDelayActionArrayOutputWithContext 

func (i NotificationPolicyDelayActionArray) ToNotificationPolicyDelayActionArrayOutputWithContext(ctx context.Context) NotificationPolicyDelayActionArrayOutput

type NotificationPolicyDelayActionArrayInput 

type NotificationPolicyDelayActionArrayInput interface {
	pulumi.Input

	ToNotificationPolicyDelayActionArrayOutput() NotificationPolicyDelayActionArrayOutput
	ToNotificationPolicyDelayActionArrayOutputWithContext(context.Context) NotificationPolicyDelayActionArrayOutput
}

NotificationPolicyDelayActionArrayInput is an input type that accepts NotificationPolicyDelayActionArray and NotificationPolicyDelayActionArrayOutput values. You can construct a concrete instance of `NotificationPolicyDelayActionArrayInput` via: 

NotificationPolicyDelayActionArray{ NotificationPolicyDelayActionArgs{...} }

type NotificationPolicyDelayActionArrayOutput 

type NotificationPolicyDelayActionArrayOutput struct{ *pulumi.OutputState }

func (NotificationPolicyDelayActionArrayOutput) ElementType 

func (NotificationPolicyDelayActionArrayOutput) ElementType() reflect.Type

func (NotificationPolicyDelayActionArrayOutput) Index 

func (o NotificationPolicyDelayActionArrayOutput) Index(i pulumi.IntInput) NotificationPolicyDelayActionOutput

func (NotificationPolicyDelayActionArrayOutput) ToNotificationPolicyDelayActionArrayOutput 

func (o NotificationPolicyDelayActionArrayOutput) ToNotificationPolicyDelayActionArrayOutput() NotificationPolicyDelayActionArrayOutput

func (NotificationPolicyDelayActionArrayOutput) ToNotificationPolicyDelayActionArrayOutputWithContext 

func (o NotificationPolicyDelayActionArrayOutput) ToNotificationPolicyDelayActionArrayOutputWithContext(ctx context.Context) NotificationPolicyDelayActionArrayOutput

type NotificationPolicyDelayActionDuration 

type NotificationPolicyDelayActionDuration struct {
	// A amount of time in `timeUnits`. This is a integer attribute.
	TimeAmount int `pulumi:"timeAmount"`
	// Valid time units are: `minutes`, `hours`, `days`. Default: `minutes`
	TimeUnit *string `pulumi:"timeUnit"`
}

type NotificationPolicyDelayActionDurationArgs 

type NotificationPolicyDelayActionDurationArgs struct {
	// A amount of time in `timeUnits`. This is a integer attribute.
	TimeAmount pulumi.IntInput `pulumi:"timeAmount"`
	// Valid time units are: `minutes`, `hours`, `days`. Default: `minutes`
	TimeUnit pulumi.StringPtrInput `pulumi:"timeUnit"`
}

func (NotificationPolicyDelayActionDurationArgs) ElementType 

func (NotificationPolicyDelayActionDurationArgs) ElementType() reflect.Type

func (NotificationPolicyDelayActionDurationArgs) ToNotificationPolicyDelayActionDurationOutput 

func (i NotificationPolicyDelayActionDurationArgs) ToNotificationPolicyDelayActionDurationOutput() NotificationPolicyDelayActionDurationOutput

func (NotificationPolicyDelayActionDurationArgs) ToNotificationPolicyDelayActionDurationOutputWithContext 

func (i NotificationPolicyDelayActionDurationArgs) ToNotificationPolicyDelayActionDurationOutputWithContext(ctx context.Context) NotificationPolicyDelayActionDurationOutput

type NotificationPolicyDelayActionDurationArray 

type NotificationPolicyDelayActionDurationArray []NotificationPolicyDelayActionDurationInput

func (NotificationPolicyDelayActionDurationArray) ElementType 

func (NotificationPolicyDelayActionDurationArray) ElementType() reflect.Type

func (NotificationPolicyDelayActionDurationArray) ToNotificationPolicyDelayActionDurationArrayOutput 

func (i NotificationPolicyDelayActionDurationArray) ToNotificationPolicyDelayActionDurationArrayOutput() NotificationPolicyDelayActionDurationArrayOutput

func (NotificationPolicyDelayActionDurationArray) ToNotificationPolicyDelayActionDurationArrayOutputWithContext 

func (i NotificationPolicyDelayActionDurationArray) ToNotificationPolicyDelayActionDurationArrayOutputWithContext(ctx context.Context) NotificationPolicyDelayActionDurationArrayOutput

type NotificationPolicyDelayActionDurationArrayInput 

type NotificationPolicyDelayActionDurationArrayInput interface {
	pulumi.Input

	ToNotificationPolicyDelayActionDurationArrayOutput() NotificationPolicyDelayActionDurationArrayOutput
	ToNotificationPolicyDelayActionDurationArrayOutputWithContext(context.Context) NotificationPolicyDelayActionDurationArrayOutput
}

NotificationPolicyDelayActionDurationArrayInput is an input type that accepts NotificationPolicyDelayActionDurationArray and NotificationPolicyDelayActionDurationArrayOutput values. You can construct a concrete instance of `NotificationPolicyDelayActionDurationArrayInput` via: 

NotificationPolicyDelayActionDurationArray{ NotificationPolicyDelayActionDurationArgs{...} }

type NotificationPolicyDelayActionDurationArrayOutput 

type NotificationPolicyDelayActionDurationArrayOutput struct{ *pulumi.OutputState }

func (NotificationPolicyDelayActionDurationArrayOutput) ElementType 

func (NotificationPolicyDelayActionDurationArrayOutput) ElementType() reflect.Type

func (NotificationPolicyDelayActionDurationArrayOutput) Index 

func (o NotificationPolicyDelayActionDurationArrayOutput) Index(i pulumi.IntInput) NotificationPolicyDelayActionDurationOutput

func (NotificationPolicyDelayActionDurationArrayOutput) ToNotificationPolicyDelayActionDurationArrayOutput 

func (o NotificationPolicyDelayActionDurationArrayOutput) ToNotificationPolicyDelayActionDurationArrayOutput() NotificationPolicyDelayActionDurationArrayOutput

func (NotificationPolicyDelayActionDurationArrayOutput) ToNotificationPolicyDelayActionDurationArrayOutputWithContext 

func (o NotificationPolicyDelayActionDurationArrayOutput) ToNotificationPolicyDelayActionDurationArrayOutputWithContext(ctx context.Context) NotificationPolicyDelayActionDurationArrayOutput

type NotificationPolicyDelayActionDurationInput 

type NotificationPolicyDelayActionDurationInput interface {
	pulumi.Input

	ToNotificationPolicyDelayActionDurationOutput() NotificationPolicyDelayActionDurationOutput
	ToNotificationPolicyDelayActionDurationOutputWithContext(context.Context) NotificationPolicyDelayActionDurationOutput
}

NotificationPolicyDelayActionDurationInput is an input type that accepts NotificationPolicyDelayActionDurationArgs and NotificationPolicyDelayActionDurationOutput values. You can construct a concrete instance of `NotificationPolicyDelayActionDurationInput` via: 

NotificationPolicyDelayActionDurationArgs{...}

type NotificationPolicyDelayActionDurationOutput 

type NotificationPolicyDelayActionDurationOutput struct{ *pulumi.OutputState }

func (NotificationPolicyDelayActionDurationOutput) ElementType 

func (NotificationPolicyDelayActionDurationOutput) ElementType() reflect.Type

func (NotificationPolicyDelayActionDurationOutput) TimeAmount 

func (o NotificationPolicyDelayActionDurationOutput) TimeAmount() pulumi.IntOutput

A amount of time in `timeUnits`. This is a integer attribute.

func (NotificationPolicyDelayActionDurationOutput) TimeUnit 

func (o NotificationPolicyDelayActionDurationOutput) TimeUnit() pulumi.StringPtrOutput

Valid time units are: `minutes`, `hours`, `days`. Default: `minutes`

func (NotificationPolicyDelayActionDurationOutput) ToNotificationPolicyDelayActionDurationOutput 

func (o NotificationPolicyDelayActionDurationOutput) ToNotificationPolicyDelayActionDurationOutput() NotificationPolicyDelayActionDurationOutput

func (NotificationPolicyDelayActionDurationOutput) ToNotificationPolicyDelayActionDurationOutputWithContext 

func (o NotificationPolicyDelayActionDurationOutput) ToNotificationPolicyDelayActionDurationOutputWithContext(ctx context.Context) NotificationPolicyDelayActionDurationOutput

type NotificationPolicyDelayActionInput 

type NotificationPolicyDelayActionInput interface {
	pulumi.Input

	ToNotificationPolicyDelayActionOutput() NotificationPolicyDelayActionOutput
	ToNotificationPolicyDelayActionOutputWithContext(context.Context) NotificationPolicyDelayActionOutput
}

NotificationPolicyDelayActionInput is an input type that accepts NotificationPolicyDelayActionArgs and NotificationPolicyDelayActionOutput values. You can construct a concrete instance of `NotificationPolicyDelayActionInput` via: 

NotificationPolicyDelayActionArgs{...}

type NotificationPolicyDelayActionOutput 

type NotificationPolicyDelayActionOutput struct{ *pulumi.OutputState }

func (NotificationPolicyDelayActionOutput) DelayOption 

func (o NotificationPolicyDelayActionOutput) DelayOption() pulumi.StringOutput

Defines until what day to delay or for what duration. Possible values are: `for-duration`, `next-time`, `next-weekday`, `next-monday`, `next-tuesday`, `next-wednesday`, `next-thursday`, `next-friday`, `next-saturday`, `next-sunday`

func (NotificationPolicyDelayActionOutput) Durations 

func (o NotificationPolicyDelayActionOutput) Durations() NotificationPolicyDelayActionDurationArrayOutput

Duration of this action. If `delayOption` = `for-duration` this has to be set. This is a block, structure is documented below.

func (NotificationPolicyDelayActionOutput) ElementType 

func (NotificationPolicyDelayActionOutput) ElementType() reflect.Type

func (NotificationPolicyDelayActionOutput) ToNotificationPolicyDelayActionOutput 

func (o NotificationPolicyDelayActionOutput) ToNotificationPolicyDelayActionOutput() NotificationPolicyDelayActionOutput

func (NotificationPolicyDelayActionOutput) ToNotificationPolicyDelayActionOutputWithContext 

func (o NotificationPolicyDelayActionOutput) ToNotificationPolicyDelayActionOutputWithContext(ctx context.Context) NotificationPolicyDelayActionOutput

func (NotificationPolicyDelayActionOutput) UntilHour 

func (o NotificationPolicyDelayActionOutput) UntilHour() pulumi.IntPtrOutput

Until what hour notifications will be delayed. If `delayOption` is set to antyhing else then `for-duration` this has to be set.

func (NotificationPolicyDelayActionOutput) UntilMinute 

func (o NotificationPolicyDelayActionOutput) UntilMinute() pulumi.IntPtrOutput

Until what minute on `untilHour` notifications will be delayed. If `delayOption` is set to antyhing else then `for-duration` this has to be set.

type NotificationPolicyFilter 

type NotificationPolicyFilter struct {
	// Conditions applied to filter. This is a block, structure is documented below.
	Conditions []NotificationPolicyFilterCondition `pulumi:"conditions"`
	// A filter type, supported types are: `match-all`, `match-any-condition`, `match-all-conditions`. Default: `match-all`
	Type *string `pulumi:"type"`
}

type NotificationPolicyFilterArgs 

type NotificationPolicyFilterArgs struct {
	// Conditions applied to filter. This is a block, structure is documented below.
	Conditions NotificationPolicyFilterConditionArrayInput `pulumi:"conditions"`
	// A filter type, supported types are: `match-all`, `match-any-condition`, `match-all-conditions`. Default: `match-all`
	Type pulumi.StringPtrInput `pulumi:"type"`
}

func (NotificationPolicyFilterArgs) ElementType 

func (NotificationPolicyFilterArgs) ElementType() reflect.Type

func (NotificationPolicyFilterArgs) ToNotificationPolicyFilterOutput 

func (i NotificationPolicyFilterArgs) ToNotificationPolicyFilterOutput() NotificationPolicyFilterOutput

func (NotificationPolicyFilterArgs) ToNotificationPolicyFilterOutputWithContext 

func (i NotificationPolicyFilterArgs) ToNotificationPolicyFilterOutputWithContext(ctx context.Context) NotificationPolicyFilterOutput

type NotificationPolicyFilterArray 

type NotificationPolicyFilterArray []NotificationPolicyFilterInput

func (NotificationPolicyFilterArray) ElementType 

func (NotificationPolicyFilterArray) ElementType() reflect.Type

func (NotificationPolicyFilterArray) ToNotificationPolicyFilterArrayOutput 

func (i NotificationPolicyFilterArray) ToNotificationPolicyFilterArrayOutput() NotificationPolicyFilterArrayOutput

func (NotificationPolicyFilterArray) ToNotificationPolicyFilterArrayOutputWithContext 

func (i NotificationPolicyFilterArray) ToNotificationPolicyFilterArrayOutputWithContext(ctx context.Context) NotificationPolicyFilterArrayOutput

type NotificationPolicyFilterArrayInput 

type NotificationPolicyFilterArrayInput interface {
	pulumi.Input

	ToNotificationPolicyFilterArrayOutput() NotificationPolicyFilterArrayOutput
	ToNotificationPolicyFilterArrayOutputWithContext(context.Context) NotificationPolicyFilterArrayOutput
}

NotificationPolicyFilterArrayInput is an input type that accepts NotificationPolicyFilterArray and NotificationPolicyFilterArrayOutput values. You can construct a concrete instance of `NotificationPolicyFilterArrayInput` via: 

NotificationPolicyFilterArray{ NotificationPolicyFilterArgs{...} }

type NotificationPolicyFilterArrayOutput 

type NotificationPolicyFilterArrayOutput struct{ *pulumi.OutputState }

func (NotificationPolicyFilterArrayOutput) ElementType 

func (NotificationPolicyFilterArrayOutput) ElementType() reflect.Type

func (NotificationPolicyFilterArrayOutput) Index 

func (o NotificationPolicyFilterArrayOutput) Index(i pulumi.IntInput) NotificationPolicyFilterOutput

func (NotificationPolicyFilterArrayOutput) ToNotificationPolicyFilterArrayOutput 

func (o NotificationPolicyFilterArrayOutput) ToNotificationPolicyFilterArrayOutput() NotificationPolicyFilterArrayOutput

func (NotificationPolicyFilterArrayOutput) ToNotificationPolicyFilterArrayOutputWithContext 

func (o NotificationPolicyFilterArrayOutput) ToNotificationPolicyFilterArrayOutputWithContext(ctx context.Context) NotificationPolicyFilterArrayOutput

type NotificationPolicyFilterCondition 

type NotificationPolicyFilterCondition struct {
	// User defined value that will be compared with alert field according to the operation. Default: empty string
	ExpectedValue *string `pulumi:"expectedValue"`
	// Specifies which alert field will be used in condition. Possible values are `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `responders`, `teams`, `priority`
	Field string `pulumi:"field"`
	// If `field` is set as extra-properties, key could be used for key-value pair
	Key *string `pulumi:"key"`
	// Indicates behaviour of the given operation. Default: `false`
	Not *bool `pulumi:"not"`
	// It is the operation that will be executed for the given field and key. Possible operations are `matches`, `contains`, `starts-with`, `ends-with`, `equals`, `contains-key`, `contains-value`, `greater-than`, `less-than`, `is-empty`, `equals-ignore-whitespace`.
	Operation string `pulumi:"operation"`
	// Order of the condition in conditions list
	Order *int `pulumi:"order"`
}

type NotificationPolicyFilterConditionArgs 

type NotificationPolicyFilterConditionArgs struct {
	// User defined value that will be compared with alert field according to the operation. Default: empty string
	ExpectedValue pulumi.StringPtrInput `pulumi:"expectedValue"`
	// Specifies which alert field will be used in condition. Possible values are `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `responders`, `teams`, `priority`
	Field pulumi.StringInput `pulumi:"field"`
	// If `field` is set as extra-properties, key could be used for key-value pair
	Key pulumi.StringPtrInput `pulumi:"key"`
	// Indicates behaviour of the given operation. Default: `false`
	Not pulumi.BoolPtrInput `pulumi:"not"`
	// It is the operation that will be executed for the given field and key. Possible operations are `matches`, `contains`, `starts-with`, `ends-with`, `equals`, `contains-key`, `contains-value`, `greater-than`, `less-than`, `is-empty`, `equals-ignore-whitespace`.
	Operation pulumi.StringInput `pulumi:"operation"`
	// Order of the condition in conditions list
	Order pulumi.IntPtrInput `pulumi:"order"`
}

func (NotificationPolicyFilterConditionArgs) ElementType 

func (NotificationPolicyFilterConditionArgs) ElementType() reflect.Type

func (NotificationPolicyFilterConditionArgs) ToNotificationPolicyFilterConditionOutput 

func (i NotificationPolicyFilterConditionArgs) ToNotificationPolicyFilterConditionOutput() NotificationPolicyFilterConditionOutput

func (NotificationPolicyFilterConditionArgs) ToNotificationPolicyFilterConditionOutputWithContext 

func (i NotificationPolicyFilterConditionArgs) ToNotificationPolicyFilterConditionOutputWithContext(ctx context.Context) NotificationPolicyFilterConditionOutput

type NotificationPolicyFilterConditionArray 

type NotificationPolicyFilterConditionArray []NotificationPolicyFilterConditionInput

func (NotificationPolicyFilterConditionArray) ElementType 

func (NotificationPolicyFilterConditionArray) ElementType() reflect.Type

func (NotificationPolicyFilterConditionArray) ToNotificationPolicyFilterConditionArrayOutput 

func (i NotificationPolicyFilterConditionArray) ToNotificationPolicyFilterConditionArrayOutput() NotificationPolicyFilterConditionArrayOutput

func (NotificationPolicyFilterConditionArray) ToNotificationPolicyFilterConditionArrayOutputWithContext 

func (i NotificationPolicyFilterConditionArray) ToNotificationPolicyFilterConditionArrayOutputWithContext(ctx context.Context) NotificationPolicyFilterConditionArrayOutput

type NotificationPolicyFilterConditionArrayInput 

type NotificationPolicyFilterConditionArrayInput interface {
	pulumi.Input

	ToNotificationPolicyFilterConditionArrayOutput() NotificationPolicyFilterConditionArrayOutput
	ToNotificationPolicyFilterConditionArrayOutputWithContext(context.Context) NotificationPolicyFilterConditionArrayOutput
}

NotificationPolicyFilterConditionArrayInput is an input type that accepts NotificationPolicyFilterConditionArray and NotificationPolicyFilterConditionArrayOutput values. You can construct a concrete instance of `NotificationPolicyFilterConditionArrayInput` via: 

NotificationPolicyFilterConditionArray{ NotificationPolicyFilterConditionArgs{...} }

type NotificationPolicyFilterConditionArrayOutput 

type NotificationPolicyFilterConditionArrayOutput struct{ *pulumi.OutputState }

func (NotificationPolicyFilterConditionArrayOutput) ElementType 

func (NotificationPolicyFilterConditionArrayOutput) ElementType() reflect.Type

func (NotificationPolicyFilterConditionArrayOutput) Index 

func (o NotificationPolicyFilterConditionArrayOutput) Index(i pulumi.IntInput) NotificationPolicyFilterConditionOutput

func (NotificationPolicyFilterConditionArrayOutput) ToNotificationPolicyFilterConditionArrayOutput 

func (o NotificationPolicyFilterConditionArrayOutput) ToNotificationPolicyFilterConditionArrayOutput() NotificationPolicyFilterConditionArrayOutput

func (NotificationPolicyFilterConditionArrayOutput) ToNotificationPolicyFilterConditionArrayOutputWithContext 

func (o NotificationPolicyFilterConditionArrayOutput) ToNotificationPolicyFilterConditionArrayOutputWithContext(ctx context.Context) NotificationPolicyFilterConditionArrayOutput

type NotificationPolicyFilterConditionInput 

type NotificationPolicyFilterConditionInput interface {
	pulumi.Input

	ToNotificationPolicyFilterConditionOutput() NotificationPolicyFilterConditionOutput
	ToNotificationPolicyFilterConditionOutputWithContext(context.Context) NotificationPolicyFilterConditionOutput
}

NotificationPolicyFilterConditionInput is an input type that accepts NotificationPolicyFilterConditionArgs and NotificationPolicyFilterConditionOutput values. You can construct a concrete instance of `NotificationPolicyFilterConditionInput` via: 

NotificationPolicyFilterConditionArgs{...}

type NotificationPolicyFilterConditionOutput 

type NotificationPolicyFilterConditionOutput struct{ *pulumi.OutputState }

func (NotificationPolicyFilterConditionOutput) ElementType 

func (NotificationPolicyFilterConditionOutput) ElementType() reflect.Type

func (NotificationPolicyFilterConditionOutput) ExpectedValue 

func (o NotificationPolicyFilterConditionOutput) ExpectedValue() pulumi.StringPtrOutput

User defined value that will be compared with alert field according to the operation. Default: empty string

func (NotificationPolicyFilterConditionOutput) Field 

func (o NotificationPolicyFilterConditionOutput) Field() pulumi.StringOutput

Specifies which alert field will be used in condition. Possible values are `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `responders`, `teams`, `priority`

func (NotificationPolicyFilterConditionOutput) Key 

func (o NotificationPolicyFilterConditionOutput) Key() pulumi.StringPtrOutput

If `field` is set as extra-properties, key could be used for key-value pair

func (NotificationPolicyFilterConditionOutput) Not 

func (o NotificationPolicyFilterConditionOutput) Not() pulumi.BoolPtrOutput

Indicates behaviour of the given operation. Default: `false`

func (NotificationPolicyFilterConditionOutput) Operation 

func (o NotificationPolicyFilterConditionOutput) Operation() pulumi.StringOutput

It is the operation that will be executed for the given field and key. Possible operations are `matches`, `contains`, `starts-with`, `ends-with`, `equals`, `contains-key`, `contains-value`, `greater-than`, `less-than`, `is-empty`, `equals-ignore-whitespace`.

func (NotificationPolicyFilterConditionOutput) Order 

func (o NotificationPolicyFilterConditionOutput) Order() pulumi.IntPtrOutput

Order of the condition in conditions list

func (NotificationPolicyFilterConditionOutput) ToNotificationPolicyFilterConditionOutput 

func (o NotificationPolicyFilterConditionOutput) ToNotificationPolicyFilterConditionOutput() NotificationPolicyFilterConditionOutput

func (NotificationPolicyFilterConditionOutput) ToNotificationPolicyFilterConditionOutputWithContext 

func (o NotificationPolicyFilterConditionOutput) ToNotificationPolicyFilterConditionOutputWithContext(ctx context.Context) NotificationPolicyFilterConditionOutput

type NotificationPolicyFilterInput 

type NotificationPolicyFilterInput interface {
	pulumi.Input

	ToNotificationPolicyFilterOutput() NotificationPolicyFilterOutput
	ToNotificationPolicyFilterOutputWithContext(context.Context) NotificationPolicyFilterOutput
}

NotificationPolicyFilterInput is an input type that accepts NotificationPolicyFilterArgs and NotificationPolicyFilterOutput values. You can construct a concrete instance of `NotificationPolicyFilterInput` via: 

NotificationPolicyFilterArgs{...}

type NotificationPolicyFilterOutput 

type NotificationPolicyFilterOutput struct{ *pulumi.OutputState }

func (NotificationPolicyFilterOutput) Conditions 

func (o NotificationPolicyFilterOutput) Conditions() NotificationPolicyFilterConditionArrayOutput

Conditions applied to filter. This is a block, structure is documented below.

func (NotificationPolicyFilterOutput) ElementType 

func (NotificationPolicyFilterOutput) ElementType() reflect.Type

func (NotificationPolicyFilterOutput) ToNotificationPolicyFilterOutput 

func (o NotificationPolicyFilterOutput) ToNotificationPolicyFilterOutput() NotificationPolicyFilterOutput

func (NotificationPolicyFilterOutput) ToNotificationPolicyFilterOutputWithContext 

func (o NotificationPolicyFilterOutput) ToNotificationPolicyFilterOutputWithContext(ctx context.Context) NotificationPolicyFilterOutput

func (NotificationPolicyFilterOutput) Type 

func (o NotificationPolicyFilterOutput) Type() pulumi.StringPtrOutput

A filter type, supported types are: `match-all`, `match-any-condition`, `match-all-conditions`. Default: `match-all`

type NotificationPolicyInput 

type NotificationPolicyInput interface {
	pulumi.Input

	ToNotificationPolicyOutput() NotificationPolicyOutput
	ToNotificationPolicyOutputWithContext(ctx context.Context) NotificationPolicyOutput
}

type NotificationPolicyMap added in v0.1.3 

type NotificationPolicyMap map[string]NotificationPolicyInput

func (NotificationPolicyMap) ElementType added in v0.1.3 

func (NotificationPolicyMap) ElementType() reflect.Type

func (NotificationPolicyMap) ToNotificationPolicyMapOutput added in v0.1.3 

func (i NotificationPolicyMap) ToNotificationPolicyMapOutput() NotificationPolicyMapOutput

func (NotificationPolicyMap) ToNotificationPolicyMapOutputWithContext added in v0.1.3 

func (i NotificationPolicyMap) ToNotificationPolicyMapOutputWithContext(ctx context.Context) NotificationPolicyMapOutput

type NotificationPolicyMapInput added in v0.1.3 

type NotificationPolicyMapInput interface {
	pulumi.Input

	ToNotificationPolicyMapOutput() NotificationPolicyMapOutput
	ToNotificationPolicyMapOutputWithContext(context.Context) NotificationPolicyMapOutput
}

NotificationPolicyMapInput is an input type that accepts NotificationPolicyMap and NotificationPolicyMapOutput values. You can construct a concrete instance of `NotificationPolicyMapInput` via: 

NotificationPolicyMap{ "key": NotificationPolicyArgs{...} }

type NotificationPolicyMapOutput added in v0.1.3 

type NotificationPolicyMapOutput struct{ *pulumi.OutputState }

func (NotificationPolicyMapOutput) ElementType added in v0.1.3 

func (NotificationPolicyMapOutput) ElementType() reflect.Type

func (NotificationPolicyMapOutput) MapIndex added in v0.1.3 

func (o NotificationPolicyMapOutput) MapIndex(k pulumi.StringInput) NotificationPolicyOutput

func (NotificationPolicyMapOutput) ToNotificationPolicyMapOutput added in v0.1.3 

func (o NotificationPolicyMapOutput) ToNotificationPolicyMapOutput() NotificationPolicyMapOutput

func (NotificationPolicyMapOutput) ToNotificationPolicyMapOutputWithContext added in v0.1.3 

func (o NotificationPolicyMapOutput) ToNotificationPolicyMapOutputWithContext(ctx context.Context) NotificationPolicyMapOutput

type NotificationPolicyOutput 

type NotificationPolicyOutput struct{ *pulumi.OutputState }

func (NotificationPolicyOutput) AutoCloseActions added in v1.1.9 

func (o NotificationPolicyOutput) AutoCloseActions() NotificationPolicyAutoCloseActionArrayOutput

Auto Restart Action of the policy. This is a block, structure is documented below.

func (NotificationPolicyOutput) AutoRestartActions added in v1.1.9 

func (o NotificationPolicyOutput) AutoRestartActions() NotificationPolicyAutoRestartActionArrayOutput

Auto Restart Action of the policy. This is a block, structure is documented below.

func (NotificationPolicyOutput) DeDuplicationActions added in v1.1.9 

func (o NotificationPolicyOutput) DeDuplicationActions() NotificationPolicyDeDuplicationActionArrayOutput

Deduplication Action of the policy. This is a block, structure is documented below.

func (NotificationPolicyOutput) DelayActions added in v1.1.9 

func (o NotificationPolicyOutput) DelayActions() NotificationPolicyDelayActionArrayOutput

Delay notifications. This is a block, structure is documented below.

func (NotificationPolicyOutput) ElementType 

func (NotificationPolicyOutput) ElementType() reflect.Type

func (NotificationPolicyOutput) Enabled added in v1.1.9 

func (o NotificationPolicyOutput) Enabled() pulumi.BoolPtrOutput

If policy should be enabled. Default: `true`

func (NotificationPolicyOutput) Filters added in v1.1.9 

func (o NotificationPolicyOutput) Filters() NotificationPolicyFilterArrayOutput

A notification filter which will be applied. This filter can be empty: `filter {}` - this means `match-all`. This is a block, structure is documented below.

func (NotificationPolicyOutput) Name added in v1.1.9 

func (o NotificationPolicyOutput) Name() pulumi.StringOutput

Name of the notification policy

func (NotificationPolicyOutput) PolicyDescription added in v1.1.9 

func (o NotificationPolicyOutput) PolicyDescription() pulumi.StringPtrOutput

Description of the policy. This can be max 512 characters.

func (NotificationPolicyOutput) Suppress added in v1.1.9 

func (o NotificationPolicyOutput) Suppress() pulumi.BoolPtrOutput

Suppress value of the policy. Values are: `true`, `false`. Default: `false`

func (NotificationPolicyOutput) TeamId added in v1.1.9 

func (o NotificationPolicyOutput) TeamId() pulumi.StringOutput

Id of team that this policy belons to.

func (NotificationPolicyOutput) TimeRestrictions added in v1.1.9 

func (o NotificationPolicyOutput) TimeRestrictions() NotificationPolicyTimeRestrictionArrayOutput

Time restrictions specified in this field must be met for this policy to work. This is a block, structure is documented below.

func (NotificationPolicyOutput) ToNotificationPolicyOutput 

func (o NotificationPolicyOutput) ToNotificationPolicyOutput() NotificationPolicyOutput

func (NotificationPolicyOutput) ToNotificationPolicyOutputWithContext 

func (o NotificationPolicyOutput) ToNotificationPolicyOutputWithContext(ctx context.Context) NotificationPolicyOutput

type NotificationPolicyState 

type NotificationPolicyState struct {
	// Auto Restart Action of the policy. This is a block, structure is documented below.
	AutoCloseActions NotificationPolicyAutoCloseActionArrayInput
	// Auto Restart Action of the policy. This is a block, structure is documented below.
	AutoRestartActions NotificationPolicyAutoRestartActionArrayInput
	// Deduplication Action of the policy. This is a block, structure is documented below.
	DeDuplicationActions NotificationPolicyDeDuplicationActionArrayInput
	// Delay notifications. This is a block, structure is documented below.
	DelayActions NotificationPolicyDelayActionArrayInput
	// If policy should be enabled. Default: `true`
	Enabled pulumi.BoolPtrInput
	// A notification filter which will be applied. This filter can be empty: `filter {}` - this means `match-all`. This is a block, structure is documented below.
	Filters NotificationPolicyFilterArrayInput
	// Name of the notification policy
	Name pulumi.StringPtrInput
	// Description of the policy. This can be max 512 characters.
	PolicyDescription pulumi.StringPtrInput
	// Suppress value of the policy. Values are: `true`, `false`. Default: `false`
	Suppress pulumi.BoolPtrInput
	// Id of team that this policy belons to.
	TeamId pulumi.StringPtrInput
	// Time restrictions specified in this field must be met for this policy to work. This is a block, structure is documented below.
	TimeRestrictions NotificationPolicyTimeRestrictionArrayInput
}

func (NotificationPolicyState) ElementType 

func (NotificationPolicyState) ElementType() reflect.Type

type NotificationPolicyTimeRestriction 

type NotificationPolicyTimeRestriction struct {
	// A definition of hourly definition applied daily, this has to be used with combination: type = `time-of-day`. This is a block, structure is documented below.
	Restriction []NotificationPolicyTimeRestrictionRestriction `pulumi:"restriction"`
	// List of days and hours definitions for field type = `weekday-and-time-of-day`. This is a block, structure is documented below.
	RestrictionList []NotificationPolicyTimeRestrictionRestrictionList `pulumi:"restrictionList"`
	// Defines if restriction should apply daily on given hours or on certain days and hours. Possible values are: `time-of-day`, `weekday-and-time-of-day`
	Type string `pulumi:"type"`
}

type NotificationPolicyTimeRestrictionArgs 

type NotificationPolicyTimeRestrictionArgs struct {
	// A definition of hourly definition applied daily, this has to be used with combination: type = `time-of-day`. This is a block, structure is documented below.
	Restriction NotificationPolicyTimeRestrictionRestrictionArrayInput `pulumi:"restriction"`
	// List of days and hours definitions for field type = `weekday-and-time-of-day`. This is a block, structure is documented below.
	RestrictionList NotificationPolicyTimeRestrictionRestrictionListArrayInput `pulumi:"restrictionList"`
	// Defines if restriction should apply daily on given hours or on certain days and hours. Possible values are: `time-of-day`, `weekday-and-time-of-day`
	Type pulumi.StringInput `pulumi:"type"`
}

func (NotificationPolicyTimeRestrictionArgs) ElementType 

func (NotificationPolicyTimeRestrictionArgs) ElementType() reflect.Type

func (NotificationPolicyTimeRestrictionArgs) ToNotificationPolicyTimeRestrictionOutput 

func (i NotificationPolicyTimeRestrictionArgs) ToNotificationPolicyTimeRestrictionOutput() NotificationPolicyTimeRestrictionOutput

func (NotificationPolicyTimeRestrictionArgs) ToNotificationPolicyTimeRestrictionOutputWithContext 

func (i NotificationPolicyTimeRestrictionArgs) ToNotificationPolicyTimeRestrictionOutputWithContext(ctx context.Context) NotificationPolicyTimeRestrictionOutput

type NotificationPolicyTimeRestrictionArray 

type NotificationPolicyTimeRestrictionArray []NotificationPolicyTimeRestrictionInput

func (NotificationPolicyTimeRestrictionArray) ElementType 

func (NotificationPolicyTimeRestrictionArray) ElementType() reflect.Type

func (NotificationPolicyTimeRestrictionArray) ToNotificationPolicyTimeRestrictionArrayOutput 

func (i NotificationPolicyTimeRestrictionArray) ToNotificationPolicyTimeRestrictionArrayOutput() NotificationPolicyTimeRestrictionArrayOutput

func (NotificationPolicyTimeRestrictionArray) ToNotificationPolicyTimeRestrictionArrayOutputWithContext 

func (i NotificationPolicyTimeRestrictionArray) ToNotificationPolicyTimeRestrictionArrayOutputWithContext(ctx context.Context) NotificationPolicyTimeRestrictionArrayOutput

type NotificationPolicyTimeRestrictionArrayInput 

type NotificationPolicyTimeRestrictionArrayInput interface {
	pulumi.Input

	ToNotificationPolicyTimeRestrictionArrayOutput() NotificationPolicyTimeRestrictionArrayOutput
	ToNotificationPolicyTimeRestrictionArrayOutputWithContext(context.Context) NotificationPolicyTimeRestrictionArrayOutput
}

NotificationPolicyTimeRestrictionArrayInput is an input type that accepts NotificationPolicyTimeRestrictionArray and NotificationPolicyTimeRestrictionArrayOutput values. You can construct a concrete instance of `NotificationPolicyTimeRestrictionArrayInput` via: 

NotificationPolicyTimeRestrictionArray{ NotificationPolicyTimeRestrictionArgs{...} }

type NotificationPolicyTimeRestrictionArrayOutput 

type NotificationPolicyTimeRestrictionArrayOutput struct{ *pulumi.OutputState }

func (NotificationPolicyTimeRestrictionArrayOutput) ElementType 

func (NotificationPolicyTimeRestrictionArrayOutput) ElementType() reflect.Type

func (NotificationPolicyTimeRestrictionArrayOutput) Index 

func (o NotificationPolicyTimeRestrictionArrayOutput) Index(i pulumi.IntInput) NotificationPolicyTimeRestrictionOutput

func (NotificationPolicyTimeRestrictionArrayOutput) ToNotificationPolicyTimeRestrictionArrayOutput 

func (o NotificationPolicyTimeRestrictionArrayOutput) ToNotificationPolicyTimeRestrictionArrayOutput() NotificationPolicyTimeRestrictionArrayOutput

func (NotificationPolicyTimeRestrictionArrayOutput) ToNotificationPolicyTimeRestrictionArrayOutputWithContext 

func (o NotificationPolicyTimeRestrictionArrayOutput) ToNotificationPolicyTimeRestrictionArrayOutputWithContext(ctx context.Context) NotificationPolicyTimeRestrictionArrayOutput

type NotificationPolicyTimeRestrictionInput 

type NotificationPolicyTimeRestrictionInput interface {
	pulumi.Input

	ToNotificationPolicyTimeRestrictionOutput() NotificationPolicyTimeRestrictionOutput
	ToNotificationPolicyTimeRestrictionOutputWithContext(context.Context) NotificationPolicyTimeRestrictionOutput
}

NotificationPolicyTimeRestrictionInput is an input type that accepts NotificationPolicyTimeRestrictionArgs and NotificationPolicyTimeRestrictionOutput values. You can construct a concrete instance of `NotificationPolicyTimeRestrictionInput` via: 

NotificationPolicyTimeRestrictionArgs{...}

type NotificationPolicyTimeRestrictionOutput 

type NotificationPolicyTimeRestrictionOutput struct{ *pulumi.OutputState }

func (NotificationPolicyTimeRestrictionOutput) ElementType 

func (NotificationPolicyTimeRestrictionOutput) ElementType() reflect.Type

func (NotificationPolicyTimeRestrictionOutput) Restriction added in v1.1.6 

func (o NotificationPolicyTimeRestrictionOutput) Restriction() NotificationPolicyTimeRestrictionRestrictionArrayOutput

A definition of hourly definition applied daily, this has to be used with combination: type = `time-of-day`. This is a block, structure is documented below.

func (NotificationPolicyTimeRestrictionOutput) RestrictionList added in v1.1.7 

func (o NotificationPolicyTimeRestrictionOutput) RestrictionList() NotificationPolicyTimeRestrictionRestrictionListArrayOutput

List of days and hours definitions for field type = `weekday-and-time-of-day`. This is a block, structure is documented below.

func (NotificationPolicyTimeRestrictionOutput) ToNotificationPolicyTimeRestrictionOutput 

func (o NotificationPolicyTimeRestrictionOutput) ToNotificationPolicyTimeRestrictionOutput() NotificationPolicyTimeRestrictionOutput

func (NotificationPolicyTimeRestrictionOutput) ToNotificationPolicyTimeRestrictionOutputWithContext 

func (o NotificationPolicyTimeRestrictionOutput) ToNotificationPolicyTimeRestrictionOutputWithContext(ctx context.Context) NotificationPolicyTimeRestrictionOutput

func (NotificationPolicyTimeRestrictionOutput) Type 

func (o NotificationPolicyTimeRestrictionOutput) Type() pulumi.StringOutput

Defines if restriction should apply daily on given hours or on certain days and hours. Possible values are: `time-of-day`, `weekday-and-time-of-day`

type NotificationPolicyTimeRestrictionRestriction 

type NotificationPolicyTimeRestrictionRestriction struct {
	// Ending hour of restriction.
	EndHour int `pulumi:"endHour"`
	// Ending minute of restriction on defined `endHour`
	EndMin int `pulumi:"endMin"`
	// Starting hour of restriction.
	StartHour int `pulumi:"startHour"`
	// Staring minute of restriction on defined `startHour`
	StartMin int `pulumi:"startMin"`
}

type NotificationPolicyTimeRestrictionRestrictionArgs 

type NotificationPolicyTimeRestrictionRestrictionArgs struct {
	// Ending hour of restriction.
	EndHour pulumi.IntInput `pulumi:"endHour"`
	// Ending minute of restriction on defined `endHour`
	EndMin pulumi.IntInput `pulumi:"endMin"`
	// Starting hour of restriction.
	StartHour pulumi.IntInput `pulumi:"startHour"`
	// Staring minute of restriction on defined `startHour`
	StartMin pulumi.IntInput `pulumi:"startMin"`
}

func (NotificationPolicyTimeRestrictionRestrictionArgs) ElementType 

func (NotificationPolicyTimeRestrictionRestrictionArgs) ElementType() reflect.Type

func (NotificationPolicyTimeRestrictionRestrictionArgs) ToNotificationPolicyTimeRestrictionRestrictionOutput 

func (i NotificationPolicyTimeRestrictionRestrictionArgs) ToNotificationPolicyTimeRestrictionRestrictionOutput() NotificationPolicyTimeRestrictionRestrictionOutput

func (NotificationPolicyTimeRestrictionRestrictionArgs) ToNotificationPolicyTimeRestrictionRestrictionOutputWithContext 

func (i NotificationPolicyTimeRestrictionRestrictionArgs) ToNotificationPolicyTimeRestrictionRestrictionOutputWithContext(ctx context.Context) NotificationPolicyTimeRestrictionRestrictionOutput

type NotificationPolicyTimeRestrictionRestrictionArray 

type NotificationPolicyTimeRestrictionRestrictionArray []NotificationPolicyTimeRestrictionRestrictionInput

func (NotificationPolicyTimeRestrictionRestrictionArray) ElementType 

func (NotificationPolicyTimeRestrictionRestrictionArray) ElementType() reflect.Type

func (NotificationPolicyTimeRestrictionRestrictionArray) ToNotificationPolicyTimeRestrictionRestrictionArrayOutput 

func (i NotificationPolicyTimeRestrictionRestrictionArray) ToNotificationPolicyTimeRestrictionRestrictionArrayOutput() NotificationPolicyTimeRestrictionRestrictionArrayOutput

func (NotificationPolicyTimeRestrictionRestrictionArray) ToNotificationPolicyTimeRestrictionRestrictionArrayOutputWithContext 

func (i NotificationPolicyTimeRestrictionRestrictionArray) ToNotificationPolicyTimeRestrictionRestrictionArrayOutputWithContext(ctx context.Context) NotificationPolicyTimeRestrictionRestrictionArrayOutput

type NotificationPolicyTimeRestrictionRestrictionArrayInput 

type NotificationPolicyTimeRestrictionRestrictionArrayInput interface {
	pulumi.Input

	ToNotificationPolicyTimeRestrictionRestrictionArrayOutput() NotificationPolicyTimeRestrictionRestrictionArrayOutput
	ToNotificationPolicyTimeRestrictionRestrictionArrayOutputWithContext(context.Context) NotificationPolicyTimeRestrictionRestrictionArrayOutput
}

NotificationPolicyTimeRestrictionRestrictionArrayInput is an input type that accepts NotificationPolicyTimeRestrictionRestrictionArray and NotificationPolicyTimeRestrictionRestrictionArrayOutput values. You can construct a concrete instance of `NotificationPolicyTimeRestrictionRestrictionArrayInput` via: 

NotificationPolicyTimeRestrictionRestrictionArray{ NotificationPolicyTimeRestrictionRestrictionArgs{...} }

type NotificationPolicyTimeRestrictionRestrictionArrayOutput 

type NotificationPolicyTimeRestrictionRestrictionArrayOutput struct{ *pulumi.OutputState }

func (NotificationPolicyTimeRestrictionRestrictionArrayOutput) ElementType 

func (NotificationPolicyTimeRestrictionRestrictionArrayOutput) ElementType() reflect.Type

func (NotificationPolicyTimeRestrictionRestrictionArrayOutput) Index 

func (o NotificationPolicyTimeRestrictionRestrictionArrayOutput) Index(i pulumi.IntInput) NotificationPolicyTimeRestrictionRestrictionOutput

func (NotificationPolicyTimeRestrictionRestrictionArrayOutput) ToNotificationPolicyTimeRestrictionRestrictionArrayOutput 

func (o NotificationPolicyTimeRestrictionRestrictionArrayOutput) ToNotificationPolicyTimeRestrictionRestrictionArrayOutput() NotificationPolicyTimeRestrictionRestrictionArrayOutput

func (NotificationPolicyTimeRestrictionRestrictionArrayOutput) ToNotificationPolicyTimeRestrictionRestrictionArrayOutputWithContext 

func (o NotificationPolicyTimeRestrictionRestrictionArrayOutput) ToNotificationPolicyTimeRestrictionRestrictionArrayOutputWithContext(ctx context.Context) NotificationPolicyTimeRestrictionRestrictionArrayOutput

type NotificationPolicyTimeRestrictionRestrictionInput 

type NotificationPolicyTimeRestrictionRestrictionInput interface {
	pulumi.Input

	ToNotificationPolicyTimeRestrictionRestrictionOutput() NotificationPolicyTimeRestrictionRestrictionOutput
	ToNotificationPolicyTimeRestrictionRestrictionOutputWithContext(context.Context) NotificationPolicyTimeRestrictionRestrictionOutput
}

NotificationPolicyTimeRestrictionRestrictionInput is an input type that accepts NotificationPolicyTimeRestrictionRestrictionArgs and NotificationPolicyTimeRestrictionRestrictionOutput values. You can construct a concrete instance of `NotificationPolicyTimeRestrictionRestrictionInput` via: 

NotificationPolicyTimeRestrictionRestrictionArgs{...}

type NotificationPolicyTimeRestrictionRestrictionList added in v1.1.7 

type NotificationPolicyTimeRestrictionRestrictionList struct {
	// Ending day of restriction (eg. `wednesday`)
	EndDay string `pulumi:"endDay"`
	// Ending hour of restriction on defined `endDay`
	EndHour int `pulumi:"endHour"`
	// Ending minute of restriction on defined `endHour`
	EndMin int `pulumi:"endMin"`
	// Starting day of restriction (eg. `monday`)
	StartDay string `pulumi:"startDay"`
	// Starting hour of restriction on defined `startDay`
	StartHour int `pulumi:"startHour"`
	// Staring minute of restriction on defined `startHour`
	StartMin int `pulumi:"startMin"`
}

type NotificationPolicyTimeRestrictionRestrictionListArgs added in v1.1.7 

type NotificationPolicyTimeRestrictionRestrictionListArgs struct {
	// Ending day of restriction (eg. `wednesday`)
	EndDay pulumi.StringInput `pulumi:"endDay"`
	// Ending hour of restriction on defined `endDay`
	EndHour pulumi.IntInput `pulumi:"endHour"`
	// Ending minute of restriction on defined `endHour`
	EndMin pulumi.IntInput `pulumi:"endMin"`
	// Starting day of restriction (eg. `monday`)
	StartDay pulumi.StringInput `pulumi:"startDay"`
	// Starting hour of restriction on defined `startDay`
	StartHour pulumi.IntInput `pulumi:"startHour"`
	// Staring minute of restriction on defined `startHour`
	StartMin pulumi.IntInput `pulumi:"startMin"`
}

func (NotificationPolicyTimeRestrictionRestrictionListArgs) ElementType added in v1.1.7 

func (NotificationPolicyTimeRestrictionRestrictionListArgs) ElementType() reflect.Type

func (NotificationPolicyTimeRestrictionRestrictionListArgs) ToNotificationPolicyTimeRestrictionRestrictionListOutput added in v1.1.7 

func (i NotificationPolicyTimeRestrictionRestrictionListArgs) ToNotificationPolicyTimeRestrictionRestrictionListOutput() NotificationPolicyTimeRestrictionRestrictionListOutput

func (NotificationPolicyTimeRestrictionRestrictionListArgs) ToNotificationPolicyTimeRestrictionRestrictionListOutputWithContext added in v1.1.7 

func (i NotificationPolicyTimeRestrictionRestrictionListArgs) ToNotificationPolicyTimeRestrictionRestrictionListOutputWithContext(ctx context.Context) NotificationPolicyTimeRestrictionRestrictionListOutput

type NotificationPolicyTimeRestrictionRestrictionListArray added in v1.1.7 

type NotificationPolicyTimeRestrictionRestrictionListArray []NotificationPolicyTimeRestrictionRestrictionListInput

func (NotificationPolicyTimeRestrictionRestrictionListArray) ElementType added in v1.1.7 

func (NotificationPolicyTimeRestrictionRestrictionListArray) ElementType() reflect.Type

func (NotificationPolicyTimeRestrictionRestrictionListArray) ToNotificationPolicyTimeRestrictionRestrictionListArrayOutput added in v1.1.7 

func (i NotificationPolicyTimeRestrictionRestrictionListArray) ToNotificationPolicyTimeRestrictionRestrictionListArrayOutput() NotificationPolicyTimeRestrictionRestrictionListArrayOutput

func (NotificationPolicyTimeRestrictionRestrictionListArray) ToNotificationPolicyTimeRestrictionRestrictionListArrayOutputWithContext added in v1.1.7 

func (i NotificationPolicyTimeRestrictionRestrictionListArray) ToNotificationPolicyTimeRestrictionRestrictionListArrayOutputWithContext(ctx context.Context) NotificationPolicyTimeRestrictionRestrictionListArrayOutput

type NotificationPolicyTimeRestrictionRestrictionListArrayInput added in v1.1.7 

type NotificationPolicyTimeRestrictionRestrictionListArrayInput interface {
	pulumi.Input

	ToNotificationPolicyTimeRestrictionRestrictionListArrayOutput() NotificationPolicyTimeRestrictionRestrictionListArrayOutput
	ToNotificationPolicyTimeRestrictionRestrictionListArrayOutputWithContext(context.Context) NotificationPolicyTimeRestrictionRestrictionListArrayOutput
}

NotificationPolicyTimeRestrictionRestrictionListArrayInput is an input type that accepts NotificationPolicyTimeRestrictionRestrictionListArray and NotificationPolicyTimeRestrictionRestrictionListArrayOutput values. You can construct a concrete instance of `NotificationPolicyTimeRestrictionRestrictionListArrayInput` via: 

NotificationPolicyTimeRestrictionRestrictionListArray{ NotificationPolicyTimeRestrictionRestrictionListArgs{...} }

type NotificationPolicyTimeRestrictionRestrictionListArrayOutput added in v1.1.7 

type NotificationPolicyTimeRestrictionRestrictionListArrayOutput struct{ *pulumi.OutputState }

func (NotificationPolicyTimeRestrictionRestrictionListArrayOutput) ElementType added in v1.1.7 

func (NotificationPolicyTimeRestrictionRestrictionListArrayOutput) ElementType() reflect.Type

func (NotificationPolicyTimeRestrictionRestrictionListArrayOutput) Index added in v1.1.7 

func (o NotificationPolicyTimeRestrictionRestrictionListArrayOutput) Index(i pulumi.IntInput) NotificationPolicyTimeRestrictionRestrictionListOutput

func (NotificationPolicyTimeRestrictionRestrictionListArrayOutput) ToNotificationPolicyTimeRestrictionRestrictionListArrayOutput added in v1.1.7 

func (o NotificationPolicyTimeRestrictionRestrictionListArrayOutput) ToNotificationPolicyTimeRestrictionRestrictionListArrayOutput() NotificationPolicyTimeRestrictionRestrictionListArrayOutput

func (NotificationPolicyTimeRestrictionRestrictionListArrayOutput) ToNotificationPolicyTimeRestrictionRestrictionListArrayOutputWithContext added in v1.1.7 

func (o NotificationPolicyTimeRestrictionRestrictionListArrayOutput) ToNotificationPolicyTimeRestrictionRestrictionListArrayOutputWithContext(ctx context.Context) NotificationPolicyTimeRestrictionRestrictionListArrayOutput

type NotificationPolicyTimeRestrictionRestrictionListInput added in v1.1.7 

type NotificationPolicyTimeRestrictionRestrictionListInput interface {
	pulumi.Input

	ToNotificationPolicyTimeRestrictionRestrictionListOutput() NotificationPolicyTimeRestrictionRestrictionListOutput
	ToNotificationPolicyTimeRestrictionRestrictionListOutputWithContext(context.Context) NotificationPolicyTimeRestrictionRestrictionListOutput
}

NotificationPolicyTimeRestrictionRestrictionListInput is an input type that accepts NotificationPolicyTimeRestrictionRestrictionListArgs and NotificationPolicyTimeRestrictionRestrictionListOutput values. You can construct a concrete instance of `NotificationPolicyTimeRestrictionRestrictionListInput` via: 

NotificationPolicyTimeRestrictionRestrictionListArgs{...}

type NotificationPolicyTimeRestrictionRestrictionListOutput added in v1.1.7 

type NotificationPolicyTimeRestrictionRestrictionListOutput struct{ *pulumi.OutputState }

func (NotificationPolicyTimeRestrictionRestrictionListOutput) ElementType added in v1.1.7 

func (NotificationPolicyTimeRestrictionRestrictionListOutput) ElementType() reflect.Type

func (NotificationPolicyTimeRestrictionRestrictionListOutput) EndDay added in v1.1.7 

func (o NotificationPolicyTimeRestrictionRestrictionListOutput) EndDay() pulumi.StringOutput

Ending day of restriction (eg. `wednesday`)

func (NotificationPolicyTimeRestrictionRestrictionListOutput) EndHour added in v1.1.7 

func (o NotificationPolicyTimeRestrictionRestrictionListOutput) EndHour() pulumi.IntOutput

Ending hour of restriction on defined `endDay`

func (NotificationPolicyTimeRestrictionRestrictionListOutput) EndMin added in v1.1.7 

func (o NotificationPolicyTimeRestrictionRestrictionListOutput) EndMin() pulumi.IntOutput

Ending minute of restriction on defined `endHour`

func (NotificationPolicyTimeRestrictionRestrictionListOutput) StartDay added in v1.1.7 

func (o NotificationPolicyTimeRestrictionRestrictionListOutput) StartDay() pulumi.StringOutput

Starting day of restriction (eg. `monday`)

func (NotificationPolicyTimeRestrictionRestrictionListOutput) StartHour added in v1.1.7 

func (o NotificationPolicyTimeRestrictionRestrictionListOutput) StartHour() pulumi.IntOutput

Starting hour of restriction on defined `startDay`

func (NotificationPolicyTimeRestrictionRestrictionListOutput) StartMin added in v1.1.7 

func (o NotificationPolicyTimeRestrictionRestrictionListOutput) StartMin() pulumi.IntOutput

Staring minute of restriction on defined `startHour`

func (NotificationPolicyTimeRestrictionRestrictionListOutput) ToNotificationPolicyTimeRestrictionRestrictionListOutput added in v1.1.7 

func (o NotificationPolicyTimeRestrictionRestrictionListOutput) ToNotificationPolicyTimeRestrictionRestrictionListOutput() NotificationPolicyTimeRestrictionRestrictionListOutput

func (NotificationPolicyTimeRestrictionRestrictionListOutput) ToNotificationPolicyTimeRestrictionRestrictionListOutputWithContext added in v1.1.7 

func (o NotificationPolicyTimeRestrictionRestrictionListOutput) ToNotificationPolicyTimeRestrictionRestrictionListOutputWithContext(ctx context.Context) NotificationPolicyTimeRestrictionRestrictionListOutput

type NotificationPolicyTimeRestrictionRestrictionOutput 

type NotificationPolicyTimeRestrictionRestrictionOutput struct{ *pulumi.OutputState }

func (NotificationPolicyTimeRestrictionRestrictionOutput) ElementType 

func (NotificationPolicyTimeRestrictionRestrictionOutput) ElementType() reflect.Type

func (NotificationPolicyTimeRestrictionRestrictionOutput) EndHour 

func (o NotificationPolicyTimeRestrictionRestrictionOutput) EndHour() pulumi.IntOutput

Ending hour of restriction.

func (NotificationPolicyTimeRestrictionRestrictionOutput) EndMin 

func (o NotificationPolicyTimeRestrictionRestrictionOutput) EndMin() pulumi.IntOutput

Ending minute of restriction on defined `endHour`

func (NotificationPolicyTimeRestrictionRestrictionOutput) StartHour 

func (o NotificationPolicyTimeRestrictionRestrictionOutput) StartHour() pulumi.IntOutput

Starting hour of restriction.

func (NotificationPolicyTimeRestrictionRestrictionOutput) StartMin 

func (o NotificationPolicyTimeRestrictionRestrictionOutput) StartMin() pulumi.IntOutput

Staring minute of restriction on defined `startHour`

func (NotificationPolicyTimeRestrictionRestrictionOutput) ToNotificationPolicyTimeRestrictionRestrictionOutput 

func (o NotificationPolicyTimeRestrictionRestrictionOutput) ToNotificationPolicyTimeRestrictionRestrictionOutput() NotificationPolicyTimeRestrictionRestrictionOutput

func (NotificationPolicyTimeRestrictionRestrictionOutput) ToNotificationPolicyTimeRestrictionRestrictionOutputWithContext 

func (o NotificationPolicyTimeRestrictionRestrictionOutput) ToNotificationPolicyTimeRestrictionRestrictionOutputWithContext(ctx context.Context) NotificationPolicyTimeRestrictionRestrictionOutput

type NotificationRule 

type NotificationRule struct {
	pulumi.CustomResourceState

	// Type of the action that notification rule will have. Allowed values: `create-alert`, `acknowledged-alert`, `closed-alert`, `assigned-alert`, `add-note`, `schedule-start`, `schedule-end`, `incoming-call-routing`
	ActionType pulumi.StringOutput                 `pulumi:"actionType"`
	Criterias  NotificationRuleCriteriaArrayOutput `pulumi:"criterias"`
	// If policy should be enabled. Default: `true`
	Enabled pulumi.BoolPtrOutput `pulumi:"enabled"`
	// Name of the notification policy
	Name pulumi.StringOutput `pulumi:"name"`
	// List of Time Periods that notification for schedule start/end will be sent. Allowed values: `just-before`, `15-minutes-ago`, `1-hour-ago`, `1-day-ago`. If `actionType` is `schedule-start` or `schedule-end` then it is required.
	NotificationTimes pulumi.StringArrayOutput            `pulumi:"notificationTimes"`
	Order             pulumi.IntOutput                    `pulumi:"order"`
	Repeats           NotificationRuleRepeatArrayOutput   `pulumi:"repeats"`
	Schedules         NotificationRuleScheduleArrayOutput `pulumi:"schedules"`
	// Notification rule steps to take (eg. SMS or email message). This is a block, structure is documented below.
	Steps            NotificationRuleStepArrayOutput            `pulumi:"steps"`
	TimeRestrictions NotificationRuleTimeRestrictionArrayOutput `pulumi:"timeRestrictions"`
	// Username of user to which this notification rule belongs to.
	Username pulumi.StringOutput `pulumi:"username"`
}

Manages a Notification Rule within Opsgenie.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		test, err := opsgenie.NewUser(ctx, "test", &opsgenie.UserArgs{
			Username: pulumi.String("Example user"),
			FullName: pulumi.String("Name Lastname"),
			Role:     pulumi.String("User"),
		})
		if err != nil {
			return err
		}
		_, err = opsgenie.NewNotificationRule(ctx, "test", &opsgenie.NotificationRuleArgs{
			Name:       pulumi.String("Example notification rule"),
			Username:   test.Username,
			ActionType: pulumi.String("schedule-end"),
			NotificationTimes: pulumi.StringArray{
				pulumi.String("just-before"),
				pulumi.String("15-minutes-ago"),
			},
			Steps: opsgenie.NotificationRuleStepArray{
				&opsgenie.NotificationRuleStepArgs{
					Contacts: opsgenie.NotificationRuleStepContactArray{
						&opsgenie.NotificationRuleStepContactArgs{
							Method: pulumi.String("email"),
							To:     pulumi.String("example@user.com"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Notification policies can be imported using the `user_id/notification_rule_id`, e.g.

```sh $ pulumi import opsgenie:index/notificationRule:NotificationRule test user_id/notification_rule_id` ```

func GetNotificationRule 

func GetNotificationRule(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *NotificationRuleState, opts ...pulumi.ResourceOption) (*NotificationRule, error)

GetNotificationRule gets an existing NotificationRule resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewNotificationRule 

func NewNotificationRule(ctx *pulumi.Context,
	name string, args *NotificationRuleArgs, opts ...pulumi.ResourceOption) (*NotificationRule, error)

NewNotificationRule registers a new resource with the given unique name, arguments, and options.

func (*NotificationRule) ElementType 

func (*NotificationRule) ElementType() reflect.Type

func (*NotificationRule) ToNotificationRuleOutput 

func (i *NotificationRule) ToNotificationRuleOutput() NotificationRuleOutput

func (*NotificationRule) ToNotificationRuleOutputWithContext 

func (i *NotificationRule) ToNotificationRuleOutputWithContext(ctx context.Context) NotificationRuleOutput

type NotificationRuleArgs 

type NotificationRuleArgs struct {
	// Type of the action that notification rule will have. Allowed values: `create-alert`, `acknowledged-alert`, `closed-alert`, `assigned-alert`, `add-note`, `schedule-start`, `schedule-end`, `incoming-call-routing`
	ActionType pulumi.StringInput
	Criterias  NotificationRuleCriteriaArrayInput
	// If policy should be enabled. Default: `true`
	Enabled pulumi.BoolPtrInput
	// Name of the notification policy
	Name pulumi.StringPtrInput
	// List of Time Periods that notification for schedule start/end will be sent. Allowed values: `just-before`, `15-minutes-ago`, `1-hour-ago`, `1-day-ago`. If `actionType` is `schedule-start` or `schedule-end` then it is required.
	NotificationTimes pulumi.StringArrayInput
	Order             pulumi.IntPtrInput
	Repeats           NotificationRuleRepeatArrayInput
	Schedules         NotificationRuleScheduleArrayInput
	// Notification rule steps to take (eg. SMS or email message). This is a block, structure is documented below.
	Steps            NotificationRuleStepArrayInput
	TimeRestrictions NotificationRuleTimeRestrictionArrayInput
	// Username of user to which this notification rule belongs to.
	Username pulumi.StringInput
}

The set of arguments for constructing a NotificationRule resource.

func (NotificationRuleArgs) ElementType 

func (NotificationRuleArgs) ElementType() reflect.Type

type NotificationRuleArray added in v0.1.3 

type NotificationRuleArray []NotificationRuleInput

func (NotificationRuleArray) ElementType added in v0.1.3 

func (NotificationRuleArray) ElementType() reflect.Type

func (NotificationRuleArray) ToNotificationRuleArrayOutput added in v0.1.3 

func (i NotificationRuleArray) ToNotificationRuleArrayOutput() NotificationRuleArrayOutput

func (NotificationRuleArray) ToNotificationRuleArrayOutputWithContext added in v0.1.3 

func (i NotificationRuleArray) ToNotificationRuleArrayOutputWithContext(ctx context.Context) NotificationRuleArrayOutput

type NotificationRuleArrayInput added in v0.1.3 

type NotificationRuleArrayInput interface {
	pulumi.Input

	ToNotificationRuleArrayOutput() NotificationRuleArrayOutput
	ToNotificationRuleArrayOutputWithContext(context.Context) NotificationRuleArrayOutput
}

NotificationRuleArrayInput is an input type that accepts NotificationRuleArray and NotificationRuleArrayOutput values. You can construct a concrete instance of `NotificationRuleArrayInput` via: 

NotificationRuleArray{ NotificationRuleArgs{...} }

type NotificationRuleArrayOutput added in v0.1.3 

type NotificationRuleArrayOutput struct{ *pulumi.OutputState }

func (NotificationRuleArrayOutput) ElementType added in v0.1.3 

func (NotificationRuleArrayOutput) ElementType() reflect.Type

func (NotificationRuleArrayOutput) Index added in v0.1.3 

func (o NotificationRuleArrayOutput) Index(i pulumi.IntInput) NotificationRuleOutput

func (NotificationRuleArrayOutput) ToNotificationRuleArrayOutput added in v0.1.3 

func (o NotificationRuleArrayOutput) ToNotificationRuleArrayOutput() NotificationRuleArrayOutput

func (NotificationRuleArrayOutput) ToNotificationRuleArrayOutputWithContext added in v0.1.3 

func (o NotificationRuleArrayOutput) ToNotificationRuleArrayOutputWithContext(ctx context.Context) NotificationRuleArrayOutput

type NotificationRuleCriteria 

type NotificationRuleCriteria struct {
	// Defines the fields and values when the condition applies
	Conditions []NotificationRuleCriteriaCondition `pulumi:"conditions"`
	// Kind of matching filter. Possible values: `match-all`, `match-any-condition`, `match-all-conditions`
	Type string `pulumi:"type"`
}

type NotificationRuleCriteriaArgs 

type NotificationRuleCriteriaArgs struct {
	// Defines the fields and values when the condition applies
	Conditions NotificationRuleCriteriaConditionArrayInput `pulumi:"conditions"`
	// Kind of matching filter. Possible values: `match-all`, `match-any-condition`, `match-all-conditions`
	Type pulumi.StringInput `pulumi:"type"`
}

func (NotificationRuleCriteriaArgs) ElementType 

func (NotificationRuleCriteriaArgs) ElementType() reflect.Type

func (NotificationRuleCriteriaArgs) ToNotificationRuleCriteriaOutput 

func (i NotificationRuleCriteriaArgs) ToNotificationRuleCriteriaOutput() NotificationRuleCriteriaOutput

func (NotificationRuleCriteriaArgs) ToNotificationRuleCriteriaOutputWithContext 

func (i NotificationRuleCriteriaArgs) ToNotificationRuleCriteriaOutputWithContext(ctx context.Context) NotificationRuleCriteriaOutput

type NotificationRuleCriteriaArray 

type NotificationRuleCriteriaArray []NotificationRuleCriteriaInput

func (NotificationRuleCriteriaArray) ElementType 

func (NotificationRuleCriteriaArray) ElementType() reflect.Type

func (NotificationRuleCriteriaArray) ToNotificationRuleCriteriaArrayOutput 

func (i NotificationRuleCriteriaArray) ToNotificationRuleCriteriaArrayOutput() NotificationRuleCriteriaArrayOutput

func (NotificationRuleCriteriaArray) ToNotificationRuleCriteriaArrayOutputWithContext 

func (i NotificationRuleCriteriaArray) ToNotificationRuleCriteriaArrayOutputWithContext(ctx context.Context) NotificationRuleCriteriaArrayOutput

type NotificationRuleCriteriaArrayInput 

type NotificationRuleCriteriaArrayInput interface {
	pulumi.Input

	ToNotificationRuleCriteriaArrayOutput() NotificationRuleCriteriaArrayOutput
	ToNotificationRuleCriteriaArrayOutputWithContext(context.Context) NotificationRuleCriteriaArrayOutput
}

NotificationRuleCriteriaArrayInput is an input type that accepts NotificationRuleCriteriaArray and NotificationRuleCriteriaArrayOutput values. You can construct a concrete instance of `NotificationRuleCriteriaArrayInput` via: 

NotificationRuleCriteriaArray{ NotificationRuleCriteriaArgs{...} }

type NotificationRuleCriteriaArrayOutput 

type NotificationRuleCriteriaArrayOutput struct{ *pulumi.OutputState }

func (NotificationRuleCriteriaArrayOutput) ElementType 

func (NotificationRuleCriteriaArrayOutput) ElementType() reflect.Type

func (NotificationRuleCriteriaArrayOutput) Index 

func (o NotificationRuleCriteriaArrayOutput) Index(i pulumi.IntInput) NotificationRuleCriteriaOutput

func (NotificationRuleCriteriaArrayOutput) ToNotificationRuleCriteriaArrayOutput 

func (o NotificationRuleCriteriaArrayOutput) ToNotificationRuleCriteriaArrayOutput() NotificationRuleCriteriaArrayOutput

func (NotificationRuleCriteriaArrayOutput) ToNotificationRuleCriteriaArrayOutputWithContext 

func (o NotificationRuleCriteriaArrayOutput) ToNotificationRuleCriteriaArrayOutputWithContext(ctx context.Context) NotificationRuleCriteriaArrayOutput

type NotificationRuleCriteriaCondition 

type NotificationRuleCriteriaCondition struct {
	// User defined value that will be compared with alert field according to the operation. Default: empty string
	ExpectedValue *string `pulumi:"expectedValue"`
	// Possible values: `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `recipients`, `teams`, `priority`
	Field string `pulumi:"field"`
	// If 'field' is set as 'extra-properties', key could be used for key-value pair
	Key *string `pulumi:"key"`
	// Indicates behaviour of the given operation. Default: `false`
	Not *bool `pulumi:"not"`
	// Possible values: `matches`, `contains`, `starts-with`, `ends-with`, `equals`, `contains-key`, `contains-value`, `greater-than`, `less-than`, `is-empty`, `equals-ignore-whitespace`
	Operation string `pulumi:"operation"`
	// Order of the condition in conditions list
	Order *int `pulumi:"order"`
}

type NotificationRuleCriteriaConditionArgs 

type NotificationRuleCriteriaConditionArgs struct {
	// User defined value that will be compared with alert field according to the operation. Default: empty string
	ExpectedValue pulumi.StringPtrInput `pulumi:"expectedValue"`
	// Possible values: `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `recipients`, `teams`, `priority`
	Field pulumi.StringInput `pulumi:"field"`
	// If 'field' is set as 'extra-properties', key could be used for key-value pair
	Key pulumi.StringPtrInput `pulumi:"key"`
	// Indicates behaviour of the given operation. Default: `false`
	Not pulumi.BoolPtrInput `pulumi:"not"`
	// Possible values: `matches`, `contains`, `starts-with`, `ends-with`, `equals`, `contains-key`, `contains-value`, `greater-than`, `less-than`, `is-empty`, `equals-ignore-whitespace`
	Operation pulumi.StringInput `pulumi:"operation"`
	// Order of the condition in conditions list
	Order pulumi.IntPtrInput `pulumi:"order"`
}

func (NotificationRuleCriteriaConditionArgs) ElementType 

func (NotificationRuleCriteriaConditionArgs) ElementType() reflect.Type

func (NotificationRuleCriteriaConditionArgs) ToNotificationRuleCriteriaConditionOutput 

func (i NotificationRuleCriteriaConditionArgs) ToNotificationRuleCriteriaConditionOutput() NotificationRuleCriteriaConditionOutput

func (NotificationRuleCriteriaConditionArgs) ToNotificationRuleCriteriaConditionOutputWithContext 

func (i NotificationRuleCriteriaConditionArgs) ToNotificationRuleCriteriaConditionOutputWithContext(ctx context.Context) NotificationRuleCriteriaConditionOutput

type NotificationRuleCriteriaConditionArray 

type NotificationRuleCriteriaConditionArray []NotificationRuleCriteriaConditionInput

func (NotificationRuleCriteriaConditionArray) ElementType 

func (NotificationRuleCriteriaConditionArray) ElementType() reflect.Type

func (NotificationRuleCriteriaConditionArray) ToNotificationRuleCriteriaConditionArrayOutput 

func (i NotificationRuleCriteriaConditionArray) ToNotificationRuleCriteriaConditionArrayOutput() NotificationRuleCriteriaConditionArrayOutput

func (NotificationRuleCriteriaConditionArray) ToNotificationRuleCriteriaConditionArrayOutputWithContext 

func (i NotificationRuleCriteriaConditionArray) ToNotificationRuleCriteriaConditionArrayOutputWithContext(ctx context.Context) NotificationRuleCriteriaConditionArrayOutput

type NotificationRuleCriteriaConditionArrayInput 

type NotificationRuleCriteriaConditionArrayInput interface {
	pulumi.Input

	ToNotificationRuleCriteriaConditionArrayOutput() NotificationRuleCriteriaConditionArrayOutput
	ToNotificationRuleCriteriaConditionArrayOutputWithContext(context.Context) NotificationRuleCriteriaConditionArrayOutput
}

NotificationRuleCriteriaConditionArrayInput is an input type that accepts NotificationRuleCriteriaConditionArray and NotificationRuleCriteriaConditionArrayOutput values. You can construct a concrete instance of `NotificationRuleCriteriaConditionArrayInput` via: 

NotificationRuleCriteriaConditionArray{ NotificationRuleCriteriaConditionArgs{...} }

type NotificationRuleCriteriaConditionArrayOutput 

type NotificationRuleCriteriaConditionArrayOutput struct{ *pulumi.OutputState }

func (NotificationRuleCriteriaConditionArrayOutput) ElementType 

func (NotificationRuleCriteriaConditionArrayOutput) ElementType() reflect.Type

func (NotificationRuleCriteriaConditionArrayOutput) Index 

func (o NotificationRuleCriteriaConditionArrayOutput) Index(i pulumi.IntInput) NotificationRuleCriteriaConditionOutput

func (NotificationRuleCriteriaConditionArrayOutput) ToNotificationRuleCriteriaConditionArrayOutput 

func (o NotificationRuleCriteriaConditionArrayOutput) ToNotificationRuleCriteriaConditionArrayOutput() NotificationRuleCriteriaConditionArrayOutput

func (NotificationRuleCriteriaConditionArrayOutput) ToNotificationRuleCriteriaConditionArrayOutputWithContext 

func (o NotificationRuleCriteriaConditionArrayOutput) ToNotificationRuleCriteriaConditionArrayOutputWithContext(ctx context.Context) NotificationRuleCriteriaConditionArrayOutput

type NotificationRuleCriteriaConditionInput 

type NotificationRuleCriteriaConditionInput interface {
	pulumi.Input

	ToNotificationRuleCriteriaConditionOutput() NotificationRuleCriteriaConditionOutput
	ToNotificationRuleCriteriaConditionOutputWithContext(context.Context) NotificationRuleCriteriaConditionOutput
}

NotificationRuleCriteriaConditionInput is an input type that accepts NotificationRuleCriteriaConditionArgs and NotificationRuleCriteriaConditionOutput values. You can construct a concrete instance of `NotificationRuleCriteriaConditionInput` via: 

NotificationRuleCriteriaConditionArgs{...}

type NotificationRuleCriteriaConditionOutput 

type NotificationRuleCriteriaConditionOutput struct{ *pulumi.OutputState }

func (NotificationRuleCriteriaConditionOutput) ElementType 

func (NotificationRuleCriteriaConditionOutput) ElementType() reflect.Type

func (NotificationRuleCriteriaConditionOutput) ExpectedValue 

func (o NotificationRuleCriteriaConditionOutput) ExpectedValue() pulumi.StringPtrOutput

User defined value that will be compared with alert field according to the operation. Default: empty string

func (NotificationRuleCriteriaConditionOutput) Field 

func (o NotificationRuleCriteriaConditionOutput) Field() pulumi.StringOutput

Possible values: `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `recipients`, `teams`, `priority`

func (NotificationRuleCriteriaConditionOutput) Key 

func (o NotificationRuleCriteriaConditionOutput) Key() pulumi.StringPtrOutput

If 'field' is set as 'extra-properties', key could be used for key-value pair

func (NotificationRuleCriteriaConditionOutput) Not 

func (o NotificationRuleCriteriaConditionOutput) Not() pulumi.BoolPtrOutput

Indicates behaviour of the given operation. Default: `false`

func (NotificationRuleCriteriaConditionOutput) Operation 

func (o NotificationRuleCriteriaConditionOutput) Operation() pulumi.StringOutput

Possible values: `matches`, `contains`, `starts-with`, `ends-with`, `equals`, `contains-key`, `contains-value`, `greater-than`, `less-than`, `is-empty`, `equals-ignore-whitespace`

func (NotificationRuleCriteriaConditionOutput) Order 

func (o NotificationRuleCriteriaConditionOutput) Order() pulumi.IntPtrOutput

Order of the condition in conditions list

func (NotificationRuleCriteriaConditionOutput) ToNotificationRuleCriteriaConditionOutput 

func (o NotificationRuleCriteriaConditionOutput) ToNotificationRuleCriteriaConditionOutput() NotificationRuleCriteriaConditionOutput

func (NotificationRuleCriteriaConditionOutput) ToNotificationRuleCriteriaConditionOutputWithContext 

func (o NotificationRuleCriteriaConditionOutput) ToNotificationRuleCriteriaConditionOutputWithContext(ctx context.Context) NotificationRuleCriteriaConditionOutput

type NotificationRuleCriteriaInput 

type NotificationRuleCriteriaInput interface {
	pulumi.Input

	ToNotificationRuleCriteriaOutput() NotificationRuleCriteriaOutput
	ToNotificationRuleCriteriaOutputWithContext(context.Context) NotificationRuleCriteriaOutput
}

NotificationRuleCriteriaInput is an input type that accepts NotificationRuleCriteriaArgs and NotificationRuleCriteriaOutput values. You can construct a concrete instance of `NotificationRuleCriteriaInput` via: 

NotificationRuleCriteriaArgs{...}

type NotificationRuleCriteriaOutput 

type NotificationRuleCriteriaOutput struct{ *pulumi.OutputState }

func (NotificationRuleCriteriaOutput) Conditions 

func (o NotificationRuleCriteriaOutput) Conditions() NotificationRuleCriteriaConditionArrayOutput

Defines the fields and values when the condition applies

func (NotificationRuleCriteriaOutput) ElementType 

func (NotificationRuleCriteriaOutput) ElementType() reflect.Type

func (NotificationRuleCriteriaOutput) ToNotificationRuleCriteriaOutput 

func (o NotificationRuleCriteriaOutput) ToNotificationRuleCriteriaOutput() NotificationRuleCriteriaOutput

func (NotificationRuleCriteriaOutput) ToNotificationRuleCriteriaOutputWithContext 

func (o NotificationRuleCriteriaOutput) ToNotificationRuleCriteriaOutputWithContext(ctx context.Context) NotificationRuleCriteriaOutput

func (NotificationRuleCriteriaOutput) Type 

func (o NotificationRuleCriteriaOutput) Type() pulumi.StringOutput

Kind of matching filter. Possible values: `match-all`, `match-any-condition`, `match-all-conditions`

type NotificationRuleInput 

type NotificationRuleInput interface {
	pulumi.Input

	ToNotificationRuleOutput() NotificationRuleOutput
	ToNotificationRuleOutputWithContext(ctx context.Context) NotificationRuleOutput
}

type NotificationRuleMap added in v0.1.3 

type NotificationRuleMap map[string]NotificationRuleInput

func (NotificationRuleMap) ElementType added in v0.1.3 

func (NotificationRuleMap) ElementType() reflect.Type

func (NotificationRuleMap) ToNotificationRuleMapOutput added in v0.1.3 

func (i NotificationRuleMap) ToNotificationRuleMapOutput() NotificationRuleMapOutput

func (NotificationRuleMap) ToNotificationRuleMapOutputWithContext added in v0.1.3 

func (i NotificationRuleMap) ToNotificationRuleMapOutputWithContext(ctx context.Context) NotificationRuleMapOutput

type NotificationRuleMapInput added in v0.1.3 

type NotificationRuleMapInput interface {
	pulumi.Input

	ToNotificationRuleMapOutput() NotificationRuleMapOutput
	ToNotificationRuleMapOutputWithContext(context.Context) NotificationRuleMapOutput
}

NotificationRuleMapInput is an input type that accepts NotificationRuleMap and NotificationRuleMapOutput values. You can construct a concrete instance of `NotificationRuleMapInput` via: 

NotificationRuleMap{ "key": NotificationRuleArgs{...} }

type NotificationRuleMapOutput added in v0.1.3 

type NotificationRuleMapOutput struct{ *pulumi.OutputState }

func (NotificationRuleMapOutput) ElementType added in v0.1.3 

func (NotificationRuleMapOutput) ElementType() reflect.Type

func (NotificationRuleMapOutput) MapIndex added in v0.1.3 

func (o NotificationRuleMapOutput) MapIndex(k pulumi.StringInput) NotificationRuleOutput

func (NotificationRuleMapOutput) ToNotificationRuleMapOutput added in v0.1.3 

func (o NotificationRuleMapOutput) ToNotificationRuleMapOutput() NotificationRuleMapOutput

func (NotificationRuleMapOutput) ToNotificationRuleMapOutputWithContext added in v0.1.3 

func (o NotificationRuleMapOutput) ToNotificationRuleMapOutputWithContext(ctx context.Context) NotificationRuleMapOutput

type NotificationRuleOutput 

type NotificationRuleOutput struct{ *pulumi.OutputState }

func (NotificationRuleOutput) ActionType added in v1.1.9 

func (o NotificationRuleOutput) ActionType() pulumi.StringOutput

Type of the action that notification rule will have. Allowed values: `create-alert`, `acknowledged-alert`, `closed-alert`, `assigned-alert`, `add-note`, `schedule-start`, `schedule-end`, `incoming-call-routing`

func (NotificationRuleOutput) Criterias added in v1.1.9 

func (o NotificationRuleOutput) Criterias() NotificationRuleCriteriaArrayOutput

func (NotificationRuleOutput) ElementType 

func (NotificationRuleOutput) ElementType() reflect.Type

func (NotificationRuleOutput) Enabled added in v1.1.9 

func (o NotificationRuleOutput) Enabled() pulumi.BoolPtrOutput

If policy should be enabled. Default: `true`

func (NotificationRuleOutput) Name added in v1.1.9 

func (o NotificationRuleOutput) Name() pulumi.StringOutput

Name of the notification policy

func (NotificationRuleOutput) NotificationTimes added in v1.1.9 

func (o NotificationRuleOutput) NotificationTimes() pulumi.StringArrayOutput

List of Time Periods that notification for schedule start/end will be sent. Allowed values: `just-before`, `15-minutes-ago`, `1-hour-ago`, `1-day-ago`. If `actionType` is `schedule-start` or `schedule-end` then it is required.

func (NotificationRuleOutput) Order added in v1.1.9 

func (o NotificationRuleOutput) Order() pulumi.IntOutput

func (NotificationRuleOutput) Repeats added in v1.1.9 

func (o NotificationRuleOutput) Repeats() NotificationRuleRepeatArrayOutput

func (NotificationRuleOutput) Schedules added in v1.1.9 

func (o NotificationRuleOutput) Schedules() NotificationRuleScheduleArrayOutput

func (NotificationRuleOutput) Steps added in v1.1.9 

func (o NotificationRuleOutput) Steps() NotificationRuleStepArrayOutput

Notification rule steps to take (eg. SMS or email message). This is a block, structure is documented below.

func (NotificationRuleOutput) TimeRestrictions added in v1.1.9 

func (o NotificationRuleOutput) TimeRestrictions() NotificationRuleTimeRestrictionArrayOutput

func (NotificationRuleOutput) ToNotificationRuleOutput 

func (o NotificationRuleOutput) ToNotificationRuleOutput() NotificationRuleOutput

func (NotificationRuleOutput) ToNotificationRuleOutputWithContext 

func (o NotificationRuleOutput) ToNotificationRuleOutputWithContext(ctx context.Context) NotificationRuleOutput

func (NotificationRuleOutput) Username added in v1.1.9 

func (o NotificationRuleOutput) Username() pulumi.StringOutput

Username of user to which this notification rule belongs to.

type NotificationRuleRepeat 

type NotificationRuleRepeat struct {
	// If policy should be enabled. Default: `true`
	Enabled   *bool `pulumi:"enabled"`
	LoopAfter int   `pulumi:"loopAfter"`
}

type NotificationRuleRepeatArgs 

type NotificationRuleRepeatArgs struct {
	// If policy should be enabled. Default: `true`
	Enabled   pulumi.BoolPtrInput `pulumi:"enabled"`
	LoopAfter pulumi.IntInput     `pulumi:"loopAfter"`
}

func (NotificationRuleRepeatArgs) ElementType 

func (NotificationRuleRepeatArgs) ElementType() reflect.Type

func (NotificationRuleRepeatArgs) ToNotificationRuleRepeatOutput 

func (i NotificationRuleRepeatArgs) ToNotificationRuleRepeatOutput() NotificationRuleRepeatOutput

func (NotificationRuleRepeatArgs) ToNotificationRuleRepeatOutputWithContext 

func (i NotificationRuleRepeatArgs) ToNotificationRuleRepeatOutputWithContext(ctx context.Context) NotificationRuleRepeatOutput

type NotificationRuleRepeatArray 

type NotificationRuleRepeatArray []NotificationRuleRepeatInput

func (NotificationRuleRepeatArray) ElementType 

func (NotificationRuleRepeatArray) ElementType() reflect.Type

func (NotificationRuleRepeatArray) ToNotificationRuleRepeatArrayOutput 

func (i NotificationRuleRepeatArray) ToNotificationRuleRepeatArrayOutput() NotificationRuleRepeatArrayOutput

func (NotificationRuleRepeatArray) ToNotificationRuleRepeatArrayOutputWithContext 

func (i NotificationRuleRepeatArray) ToNotificationRuleRepeatArrayOutputWithContext(ctx context.Context) NotificationRuleRepeatArrayOutput

type NotificationRuleRepeatArrayInput 

type NotificationRuleRepeatArrayInput interface {
	pulumi.Input

	ToNotificationRuleRepeatArrayOutput() NotificationRuleRepeatArrayOutput
	ToNotificationRuleRepeatArrayOutputWithContext(context.Context) NotificationRuleRepeatArrayOutput
}

NotificationRuleRepeatArrayInput is an input type that accepts NotificationRuleRepeatArray and NotificationRuleRepeatArrayOutput values. You can construct a concrete instance of `NotificationRuleRepeatArrayInput` via: 

NotificationRuleRepeatArray{ NotificationRuleRepeatArgs{...} }

type NotificationRuleRepeatArrayOutput 

type NotificationRuleRepeatArrayOutput struct{ *pulumi.OutputState }

func (NotificationRuleRepeatArrayOutput) ElementType 

func (NotificationRuleRepeatArrayOutput) ElementType() reflect.Type

func (NotificationRuleRepeatArrayOutput) Index 

func (o NotificationRuleRepeatArrayOutput) Index(i pulumi.IntInput) NotificationRuleRepeatOutput

func (NotificationRuleRepeatArrayOutput) ToNotificationRuleRepeatArrayOutput 

func (o NotificationRuleRepeatArrayOutput) ToNotificationRuleRepeatArrayOutput() NotificationRuleRepeatArrayOutput

func (NotificationRuleRepeatArrayOutput) ToNotificationRuleRepeatArrayOutputWithContext 

func (o NotificationRuleRepeatArrayOutput) ToNotificationRuleRepeatArrayOutputWithContext(ctx context.Context) NotificationRuleRepeatArrayOutput

type NotificationRuleRepeatInput 

type NotificationRuleRepeatInput interface {
	pulumi.Input

	ToNotificationRuleRepeatOutput() NotificationRuleRepeatOutput
	ToNotificationRuleRepeatOutputWithContext(context.Context) NotificationRuleRepeatOutput
}

NotificationRuleRepeatInput is an input type that accepts NotificationRuleRepeatArgs and NotificationRuleRepeatOutput values. You can construct a concrete instance of `NotificationRuleRepeatInput` via: 

NotificationRuleRepeatArgs{...}

type NotificationRuleRepeatOutput 

type NotificationRuleRepeatOutput struct{ *pulumi.OutputState }

func (NotificationRuleRepeatOutput) ElementType 

func (NotificationRuleRepeatOutput) ElementType() reflect.Type

func (NotificationRuleRepeatOutput) Enabled 

func (o NotificationRuleRepeatOutput) Enabled() pulumi.BoolPtrOutput

If policy should be enabled. Default: `true`

func (NotificationRuleRepeatOutput) LoopAfter 

func (o NotificationRuleRepeatOutput) LoopAfter() pulumi.IntOutput

func (NotificationRuleRepeatOutput) ToNotificationRuleRepeatOutput 

func (o NotificationRuleRepeatOutput) ToNotificationRuleRepeatOutput() NotificationRuleRepeatOutput

func (NotificationRuleRepeatOutput) ToNotificationRuleRepeatOutputWithContext 

func (o NotificationRuleRepeatOutput) ToNotificationRuleRepeatOutputWithContext(ctx context.Context) NotificationRuleRepeatOutput

type NotificationRuleSchedule 

type NotificationRuleSchedule struct {
	// Name of the notification policy
	Name string `pulumi:"name"`
	Type string `pulumi:"type"`
}

type NotificationRuleScheduleArgs 

type NotificationRuleScheduleArgs struct {
	// Name of the notification policy
	Name pulumi.StringInput `pulumi:"name"`
	Type pulumi.StringInput `pulumi:"type"`
}

func (NotificationRuleScheduleArgs) ElementType 

func (NotificationRuleScheduleArgs) ElementType() reflect.Type

func (NotificationRuleScheduleArgs) ToNotificationRuleScheduleOutput 

func (i NotificationRuleScheduleArgs) ToNotificationRuleScheduleOutput() NotificationRuleScheduleOutput

func (NotificationRuleScheduleArgs) ToNotificationRuleScheduleOutputWithContext 

func (i NotificationRuleScheduleArgs) ToNotificationRuleScheduleOutputWithContext(ctx context.Context) NotificationRuleScheduleOutput

type NotificationRuleScheduleArray 

type NotificationRuleScheduleArray []NotificationRuleScheduleInput

func (NotificationRuleScheduleArray) ElementType 

func (NotificationRuleScheduleArray) ElementType() reflect.Type

func (NotificationRuleScheduleArray) ToNotificationRuleScheduleArrayOutput 

func (i NotificationRuleScheduleArray) ToNotificationRuleScheduleArrayOutput() NotificationRuleScheduleArrayOutput

func (NotificationRuleScheduleArray) ToNotificationRuleScheduleArrayOutputWithContext 

func (i NotificationRuleScheduleArray) ToNotificationRuleScheduleArrayOutputWithContext(ctx context.Context) NotificationRuleScheduleArrayOutput

type NotificationRuleScheduleArrayInput 

type NotificationRuleScheduleArrayInput interface {
	pulumi.Input

	ToNotificationRuleScheduleArrayOutput() NotificationRuleScheduleArrayOutput
	ToNotificationRuleScheduleArrayOutputWithContext(context.Context) NotificationRuleScheduleArrayOutput
}

NotificationRuleScheduleArrayInput is an input type that accepts NotificationRuleScheduleArray and NotificationRuleScheduleArrayOutput values. You can construct a concrete instance of `NotificationRuleScheduleArrayInput` via: 

NotificationRuleScheduleArray{ NotificationRuleScheduleArgs{...} }

type NotificationRuleScheduleArrayOutput 

type NotificationRuleScheduleArrayOutput struct{ *pulumi.OutputState }

func (NotificationRuleScheduleArrayOutput) ElementType 

func (NotificationRuleScheduleArrayOutput) ElementType() reflect.Type

func (NotificationRuleScheduleArrayOutput) Index 

func (o NotificationRuleScheduleArrayOutput) Index(i pulumi.IntInput) NotificationRuleScheduleOutput

func (NotificationRuleScheduleArrayOutput) ToNotificationRuleScheduleArrayOutput 

func (o NotificationRuleScheduleArrayOutput) ToNotificationRuleScheduleArrayOutput() NotificationRuleScheduleArrayOutput

func (NotificationRuleScheduleArrayOutput) ToNotificationRuleScheduleArrayOutputWithContext 

func (o NotificationRuleScheduleArrayOutput) ToNotificationRuleScheduleArrayOutputWithContext(ctx context.Context) NotificationRuleScheduleArrayOutput

type NotificationRuleScheduleInput 

type NotificationRuleScheduleInput interface {
	pulumi.Input

	ToNotificationRuleScheduleOutput() NotificationRuleScheduleOutput
	ToNotificationRuleScheduleOutputWithContext(context.Context) NotificationRuleScheduleOutput
}

NotificationRuleScheduleInput is an input type that accepts NotificationRuleScheduleArgs and NotificationRuleScheduleOutput values. You can construct a concrete instance of `NotificationRuleScheduleInput` via: 

NotificationRuleScheduleArgs{...}

type NotificationRuleScheduleOutput 

type NotificationRuleScheduleOutput struct{ *pulumi.OutputState }

func (NotificationRuleScheduleOutput) ElementType 

func (NotificationRuleScheduleOutput) ElementType() reflect.Type

func (NotificationRuleScheduleOutput) Name 

func (o NotificationRuleScheduleOutput) Name() pulumi.StringOutput

Name of the notification policy

func (NotificationRuleScheduleOutput) ToNotificationRuleScheduleOutput 

func (o NotificationRuleScheduleOutput) ToNotificationRuleScheduleOutput() NotificationRuleScheduleOutput

func (NotificationRuleScheduleOutput) ToNotificationRuleScheduleOutputWithContext 

func (o NotificationRuleScheduleOutput) ToNotificationRuleScheduleOutputWithContext(ctx context.Context) NotificationRuleScheduleOutput

func (NotificationRuleScheduleOutput) Type 

func (o NotificationRuleScheduleOutput) Type() pulumi.StringOutput

type NotificationRuleState 

type NotificationRuleState struct {
	// Type of the action that notification rule will have. Allowed values: `create-alert`, `acknowledged-alert`, `closed-alert`, `assigned-alert`, `add-note`, `schedule-start`, `schedule-end`, `incoming-call-routing`
	ActionType pulumi.StringPtrInput
	Criterias  NotificationRuleCriteriaArrayInput
	// If policy should be enabled. Default: `true`
	Enabled pulumi.BoolPtrInput
	// Name of the notification policy
	Name pulumi.StringPtrInput
	// List of Time Periods that notification for schedule start/end will be sent. Allowed values: `just-before`, `15-minutes-ago`, `1-hour-ago`, `1-day-ago`. If `actionType` is `schedule-start` or `schedule-end` then it is required.
	NotificationTimes pulumi.StringArrayInput
	Order             pulumi.IntPtrInput
	Repeats           NotificationRuleRepeatArrayInput
	Schedules         NotificationRuleScheduleArrayInput
	// Notification rule steps to take (eg. SMS or email message). This is a block, structure is documented below.
	Steps            NotificationRuleStepArrayInput
	TimeRestrictions NotificationRuleTimeRestrictionArrayInput
	// Username of user to which this notification rule belongs to.
	Username pulumi.StringPtrInput
}

func (NotificationRuleState) ElementType 

func (NotificationRuleState) ElementType() reflect.Type

type NotificationRuleStep 

type NotificationRuleStep struct {
	// Defines the contact that notification will be sent to. This is a block, structure is documented below.
	Contacts []NotificationRuleStepContact `pulumi:"contacts"`
	// Defined if this step is enabled. Default: `true`
	Enabled *bool `pulumi:"enabled"`
	// Time period, in minutes, notification will be sent after.
	SendAfter *int `pulumi:"sendAfter"`
}

type NotificationRuleStepArgs 

type NotificationRuleStepArgs struct {
	// Defines the contact that notification will be sent to. This is a block, structure is documented below.
	Contacts NotificationRuleStepContactArrayInput `pulumi:"contacts"`
	// Defined if this step is enabled. Default: `true`
	Enabled pulumi.BoolPtrInput `pulumi:"enabled"`
	// Time period, in minutes, notification will be sent after.
	SendAfter pulumi.IntPtrInput `pulumi:"sendAfter"`
}

func (NotificationRuleStepArgs) ElementType 

func (NotificationRuleStepArgs) ElementType() reflect.Type

func (NotificationRuleStepArgs) ToNotificationRuleStepOutput 

func (i NotificationRuleStepArgs) ToNotificationRuleStepOutput() NotificationRuleStepOutput

func (NotificationRuleStepArgs) ToNotificationRuleStepOutputWithContext 

func (i NotificationRuleStepArgs) ToNotificationRuleStepOutputWithContext(ctx context.Context) NotificationRuleStepOutput

type NotificationRuleStepArray 

type NotificationRuleStepArray []NotificationRuleStepInput

func (NotificationRuleStepArray) ElementType 

func (NotificationRuleStepArray) ElementType() reflect.Type

func (NotificationRuleStepArray) ToNotificationRuleStepArrayOutput 

func (i NotificationRuleStepArray) ToNotificationRuleStepArrayOutput() NotificationRuleStepArrayOutput

func (NotificationRuleStepArray) ToNotificationRuleStepArrayOutputWithContext 

func (i NotificationRuleStepArray) ToNotificationRuleStepArrayOutputWithContext(ctx context.Context) NotificationRuleStepArrayOutput

type NotificationRuleStepArrayInput 

type NotificationRuleStepArrayInput interface {
	pulumi.Input

	ToNotificationRuleStepArrayOutput() NotificationRuleStepArrayOutput
	ToNotificationRuleStepArrayOutputWithContext(context.Context) NotificationRuleStepArrayOutput
}

NotificationRuleStepArrayInput is an input type that accepts NotificationRuleStepArray and NotificationRuleStepArrayOutput values. You can construct a concrete instance of `NotificationRuleStepArrayInput` via: 

NotificationRuleStepArray{ NotificationRuleStepArgs{...} }

type NotificationRuleStepArrayOutput 

type NotificationRuleStepArrayOutput struct{ *pulumi.OutputState }

func (NotificationRuleStepArrayOutput) ElementType 

func (NotificationRuleStepArrayOutput) ElementType() reflect.Type

func (NotificationRuleStepArrayOutput) Index 

func (o NotificationRuleStepArrayOutput) Index(i pulumi.IntInput) NotificationRuleStepOutput

func (NotificationRuleStepArrayOutput) ToNotificationRuleStepArrayOutput 

func (o NotificationRuleStepArrayOutput) ToNotificationRuleStepArrayOutput() NotificationRuleStepArrayOutput

func (NotificationRuleStepArrayOutput) ToNotificationRuleStepArrayOutputWithContext 

func (o NotificationRuleStepArrayOutput) ToNotificationRuleStepArrayOutputWithContext(ctx context.Context) NotificationRuleStepArrayOutput

type NotificationRuleStepContact 

type NotificationRuleStepContact struct {
	// Contact method. Possible values: `email`, `sms`, `voice`, `mobile`
	Method string `pulumi:"method"`
	// Address of a given method (eg. email address for `email`, phone number for `sms`/`voice` or mobile application name for `mobile`)
	To string `pulumi:"to"`
}

type NotificationRuleStepContactArgs 

type NotificationRuleStepContactArgs struct {
	// Contact method. Possible values: `email`, `sms`, `voice`, `mobile`
	Method pulumi.StringInput `pulumi:"method"`
	// Address of a given method (eg. email address for `email`, phone number for `sms`/`voice` or mobile application name for `mobile`)
	To pulumi.StringInput `pulumi:"to"`
}

func (NotificationRuleStepContactArgs) ElementType 

func (NotificationRuleStepContactArgs) ElementType() reflect.Type

func (NotificationRuleStepContactArgs) ToNotificationRuleStepContactOutput 

func (i NotificationRuleStepContactArgs) ToNotificationRuleStepContactOutput() NotificationRuleStepContactOutput

func (NotificationRuleStepContactArgs) ToNotificationRuleStepContactOutputWithContext 

func (i NotificationRuleStepContactArgs) ToNotificationRuleStepContactOutputWithContext(ctx context.Context) NotificationRuleStepContactOutput

type NotificationRuleStepContactArray 

type NotificationRuleStepContactArray []NotificationRuleStepContactInput

func (NotificationRuleStepContactArray) ElementType 

func (NotificationRuleStepContactArray) ElementType() reflect.Type

func (NotificationRuleStepContactArray) ToNotificationRuleStepContactArrayOutput 

func (i NotificationRuleStepContactArray) ToNotificationRuleStepContactArrayOutput() NotificationRuleStepContactArrayOutput

func (NotificationRuleStepContactArray) ToNotificationRuleStepContactArrayOutputWithContext 

func (i NotificationRuleStepContactArray) ToNotificationRuleStepContactArrayOutputWithContext(ctx context.Context) NotificationRuleStepContactArrayOutput

type NotificationRuleStepContactArrayInput 

type NotificationRuleStepContactArrayInput interface {
	pulumi.Input

	ToNotificationRuleStepContactArrayOutput() NotificationRuleStepContactArrayOutput
	ToNotificationRuleStepContactArrayOutputWithContext(context.Context) NotificationRuleStepContactArrayOutput
}

NotificationRuleStepContactArrayInput is an input type that accepts NotificationRuleStepContactArray and NotificationRuleStepContactArrayOutput values. You can construct a concrete instance of `NotificationRuleStepContactArrayInput` via: 

NotificationRuleStepContactArray{ NotificationRuleStepContactArgs{...} }

type NotificationRuleStepContactArrayOutput 

type NotificationRuleStepContactArrayOutput struct{ *pulumi.OutputState }

func (NotificationRuleStepContactArrayOutput) ElementType 

func (NotificationRuleStepContactArrayOutput) ElementType() reflect.Type

func (NotificationRuleStepContactArrayOutput) Index 

func (o NotificationRuleStepContactArrayOutput) Index(i pulumi.IntInput) NotificationRuleStepContactOutput

func (NotificationRuleStepContactArrayOutput) ToNotificationRuleStepContactArrayOutput 

func (o NotificationRuleStepContactArrayOutput) ToNotificationRuleStepContactArrayOutput() NotificationRuleStepContactArrayOutput

func (NotificationRuleStepContactArrayOutput) ToNotificationRuleStepContactArrayOutputWithContext 

func (o NotificationRuleStepContactArrayOutput) ToNotificationRuleStepContactArrayOutputWithContext(ctx context.Context) NotificationRuleStepContactArrayOutput

type NotificationRuleStepContactInput 

type NotificationRuleStepContactInput interface {
	pulumi.Input

	ToNotificationRuleStepContactOutput() NotificationRuleStepContactOutput
	ToNotificationRuleStepContactOutputWithContext(context.Context) NotificationRuleStepContactOutput
}

NotificationRuleStepContactInput is an input type that accepts NotificationRuleStepContactArgs and NotificationRuleStepContactOutput values. You can construct a concrete instance of `NotificationRuleStepContactInput` via: 

NotificationRuleStepContactArgs{...}

type NotificationRuleStepContactOutput 

type NotificationRuleStepContactOutput struct{ *pulumi.OutputState }

func (NotificationRuleStepContactOutput) ElementType 

func (NotificationRuleStepContactOutput) ElementType() reflect.Type

func (NotificationRuleStepContactOutput) Method 

func (o NotificationRuleStepContactOutput) Method() pulumi.StringOutput

Contact method. Possible values: `email`, `sms`, `voice`, `mobile`

func (NotificationRuleStepContactOutput) To 

func (o NotificationRuleStepContactOutput) To() pulumi.StringOutput

Address of a given method (eg. email address for `email`, phone number for `sms`/`voice` or mobile application name for `mobile`)

func (NotificationRuleStepContactOutput) ToNotificationRuleStepContactOutput 

func (o NotificationRuleStepContactOutput) ToNotificationRuleStepContactOutput() NotificationRuleStepContactOutput

func (NotificationRuleStepContactOutput) ToNotificationRuleStepContactOutputWithContext 

func (o NotificationRuleStepContactOutput) ToNotificationRuleStepContactOutputWithContext(ctx context.Context) NotificationRuleStepContactOutput

type NotificationRuleStepInput 

type NotificationRuleStepInput interface {
	pulumi.Input

	ToNotificationRuleStepOutput() NotificationRuleStepOutput
	ToNotificationRuleStepOutputWithContext(context.Context) NotificationRuleStepOutput
}

NotificationRuleStepInput is an input type that accepts NotificationRuleStepArgs and NotificationRuleStepOutput values. You can construct a concrete instance of `NotificationRuleStepInput` via: 

NotificationRuleStepArgs{...}

type NotificationRuleStepOutput 

type NotificationRuleStepOutput struct{ *pulumi.OutputState }

func (NotificationRuleStepOutput) Contacts 

func (o NotificationRuleStepOutput) Contacts() NotificationRuleStepContactArrayOutput

Defines the contact that notification will be sent to. This is a block, structure is documented below.

func (NotificationRuleStepOutput) ElementType 

func (NotificationRuleStepOutput) ElementType() reflect.Type

func (NotificationRuleStepOutput) Enabled 

func (o NotificationRuleStepOutput) Enabled() pulumi.BoolPtrOutput

Defined if this step is enabled. Default: `true`

func (NotificationRuleStepOutput) SendAfter 

func (o NotificationRuleStepOutput) SendAfter() pulumi.IntPtrOutput

Time period, in minutes, notification will be sent after.

func (NotificationRuleStepOutput) ToNotificationRuleStepOutput 

func (o NotificationRuleStepOutput) ToNotificationRuleStepOutput() NotificationRuleStepOutput

func (NotificationRuleStepOutput) ToNotificationRuleStepOutputWithContext 

func (o NotificationRuleStepOutput) ToNotificationRuleStepOutputWithContext(ctx context.Context) NotificationRuleStepOutput

type NotificationRuleTimeRestriction 

type NotificationRuleTimeRestriction struct {
	Restriction  []NotificationRuleTimeRestrictionRestriction `pulumi:"restriction"`
	Restrictions []NotificationRuleTimeRestrictionRestriction `pulumi:"restrictions"`
	Type         string                                       `pulumi:"type"`
}

type NotificationRuleTimeRestrictionArgs 

type NotificationRuleTimeRestrictionArgs struct {
	Restriction  NotificationRuleTimeRestrictionRestrictionArrayInput `pulumi:"restriction"`
	Restrictions NotificationRuleTimeRestrictionRestrictionArrayInput `pulumi:"restrictions"`
	Type         pulumi.StringInput                                   `pulumi:"type"`
}

func (NotificationRuleTimeRestrictionArgs) ElementType 

func (NotificationRuleTimeRestrictionArgs) ElementType() reflect.Type

func (NotificationRuleTimeRestrictionArgs) ToNotificationRuleTimeRestrictionOutput 

func (i NotificationRuleTimeRestrictionArgs) ToNotificationRuleTimeRestrictionOutput() NotificationRuleTimeRestrictionOutput

func (NotificationRuleTimeRestrictionArgs) ToNotificationRuleTimeRestrictionOutputWithContext 

func (i NotificationRuleTimeRestrictionArgs) ToNotificationRuleTimeRestrictionOutputWithContext(ctx context.Context) NotificationRuleTimeRestrictionOutput

type NotificationRuleTimeRestrictionArray 

type NotificationRuleTimeRestrictionArray []NotificationRuleTimeRestrictionInput

func (NotificationRuleTimeRestrictionArray) ElementType 

func (NotificationRuleTimeRestrictionArray) ElementType() reflect.Type

func (NotificationRuleTimeRestrictionArray) ToNotificationRuleTimeRestrictionArrayOutput 

func (i NotificationRuleTimeRestrictionArray) ToNotificationRuleTimeRestrictionArrayOutput() NotificationRuleTimeRestrictionArrayOutput

func (NotificationRuleTimeRestrictionArray) ToNotificationRuleTimeRestrictionArrayOutputWithContext 

func (i NotificationRuleTimeRestrictionArray) ToNotificationRuleTimeRestrictionArrayOutputWithContext(ctx context.Context) NotificationRuleTimeRestrictionArrayOutput

type NotificationRuleTimeRestrictionArrayInput 

type NotificationRuleTimeRestrictionArrayInput interface {
	pulumi.Input

	ToNotificationRuleTimeRestrictionArrayOutput() NotificationRuleTimeRestrictionArrayOutput
	ToNotificationRuleTimeRestrictionArrayOutputWithContext(context.Context) NotificationRuleTimeRestrictionArrayOutput
}

NotificationRuleTimeRestrictionArrayInput is an input type that accepts NotificationRuleTimeRestrictionArray and NotificationRuleTimeRestrictionArrayOutput values. You can construct a concrete instance of `NotificationRuleTimeRestrictionArrayInput` via: 

NotificationRuleTimeRestrictionArray{ NotificationRuleTimeRestrictionArgs{...} }

type NotificationRuleTimeRestrictionArrayOutput 

type NotificationRuleTimeRestrictionArrayOutput struct{ *pulumi.OutputState }

func (NotificationRuleTimeRestrictionArrayOutput) ElementType 

func (NotificationRuleTimeRestrictionArrayOutput) ElementType() reflect.Type

func (NotificationRuleTimeRestrictionArrayOutput) Index 

func (o NotificationRuleTimeRestrictionArrayOutput) Index(i pulumi.IntInput) NotificationRuleTimeRestrictionOutput

func (NotificationRuleTimeRestrictionArrayOutput) ToNotificationRuleTimeRestrictionArrayOutput 

func (o NotificationRuleTimeRestrictionArrayOutput) ToNotificationRuleTimeRestrictionArrayOutput() NotificationRuleTimeRestrictionArrayOutput

func (NotificationRuleTimeRestrictionArrayOutput) ToNotificationRuleTimeRestrictionArrayOutputWithContext 

func (o NotificationRuleTimeRestrictionArrayOutput) ToNotificationRuleTimeRestrictionArrayOutputWithContext(ctx context.Context) NotificationRuleTimeRestrictionArrayOutput

type NotificationRuleTimeRestrictionInput 

type NotificationRuleTimeRestrictionInput interface {
	pulumi.Input

	ToNotificationRuleTimeRestrictionOutput() NotificationRuleTimeRestrictionOutput
	ToNotificationRuleTimeRestrictionOutputWithContext(context.Context) NotificationRuleTimeRestrictionOutput
}

NotificationRuleTimeRestrictionInput is an input type that accepts NotificationRuleTimeRestrictionArgs and NotificationRuleTimeRestrictionOutput values. You can construct a concrete instance of `NotificationRuleTimeRestrictionInput` via: 

NotificationRuleTimeRestrictionArgs{...}

type NotificationRuleTimeRestrictionOutput 

type NotificationRuleTimeRestrictionOutput struct{ *pulumi.OutputState }

func (NotificationRuleTimeRestrictionOutput) ElementType 

func (NotificationRuleTimeRestrictionOutput) ElementType() reflect.Type

func (NotificationRuleTimeRestrictionOutput) Restriction added in v1.2.1 

func (o NotificationRuleTimeRestrictionOutput) Restriction() NotificationRuleTimeRestrictionRestrictionArrayOutput

func (NotificationRuleTimeRestrictionOutput) Restrictions 

func (o NotificationRuleTimeRestrictionOutput) Restrictions() NotificationRuleTimeRestrictionRestrictionArrayOutput

func (NotificationRuleTimeRestrictionOutput) ToNotificationRuleTimeRestrictionOutput 

func (o NotificationRuleTimeRestrictionOutput) ToNotificationRuleTimeRestrictionOutput() NotificationRuleTimeRestrictionOutput

func (NotificationRuleTimeRestrictionOutput) ToNotificationRuleTimeRestrictionOutputWithContext 

func (o NotificationRuleTimeRestrictionOutput) ToNotificationRuleTimeRestrictionOutputWithContext(ctx context.Context) NotificationRuleTimeRestrictionOutput

func (NotificationRuleTimeRestrictionOutput) Type 

func (o NotificationRuleTimeRestrictionOutput) Type() pulumi.StringOutput

type NotificationRuleTimeRestrictionRestriction 

type NotificationRuleTimeRestrictionRestriction struct {
	EndDay    string `pulumi:"endDay"`
	EndHour   int    `pulumi:"endHour"`
	EndMin    int    `pulumi:"endMin"`
	StartDay  string `pulumi:"startDay"`
	StartHour int    `pulumi:"startHour"`
	StartMin  int    `pulumi:"startMin"`
}

type NotificationRuleTimeRestrictionRestrictionArgs 

type NotificationRuleTimeRestrictionRestrictionArgs struct {
	EndDay    pulumi.StringInput `pulumi:"endDay"`
	EndHour   pulumi.IntInput    `pulumi:"endHour"`
	EndMin    pulumi.IntInput    `pulumi:"endMin"`
	StartDay  pulumi.StringInput `pulumi:"startDay"`
	StartHour pulumi.IntInput    `pulumi:"startHour"`
	StartMin  pulumi.IntInput    `pulumi:"startMin"`
}

func (NotificationRuleTimeRestrictionRestrictionArgs) ElementType 

func (NotificationRuleTimeRestrictionRestrictionArgs) ElementType() reflect.Type

func (NotificationRuleTimeRestrictionRestrictionArgs) ToNotificationRuleTimeRestrictionRestrictionOutput 

func (i NotificationRuleTimeRestrictionRestrictionArgs) ToNotificationRuleTimeRestrictionRestrictionOutput() NotificationRuleTimeRestrictionRestrictionOutput

func (NotificationRuleTimeRestrictionRestrictionArgs) ToNotificationRuleTimeRestrictionRestrictionOutputWithContext 

func (i NotificationRuleTimeRestrictionRestrictionArgs) ToNotificationRuleTimeRestrictionRestrictionOutputWithContext(ctx context.Context) NotificationRuleTimeRestrictionRestrictionOutput

type NotificationRuleTimeRestrictionRestrictionArray 

type NotificationRuleTimeRestrictionRestrictionArray []NotificationRuleTimeRestrictionRestrictionInput

func (NotificationRuleTimeRestrictionRestrictionArray) ElementType 

func (NotificationRuleTimeRestrictionRestrictionArray) ElementType() reflect.Type

func (NotificationRuleTimeRestrictionRestrictionArray) ToNotificationRuleTimeRestrictionRestrictionArrayOutput 

func (i NotificationRuleTimeRestrictionRestrictionArray) ToNotificationRuleTimeRestrictionRestrictionArrayOutput() NotificationRuleTimeRestrictionRestrictionArrayOutput

func (NotificationRuleTimeRestrictionRestrictionArray) ToNotificationRuleTimeRestrictionRestrictionArrayOutputWithContext 

func (i NotificationRuleTimeRestrictionRestrictionArray) ToNotificationRuleTimeRestrictionRestrictionArrayOutputWithContext(ctx context.Context) NotificationRuleTimeRestrictionRestrictionArrayOutput

type NotificationRuleTimeRestrictionRestrictionArrayInput 

type NotificationRuleTimeRestrictionRestrictionArrayInput interface {
	pulumi.Input

	ToNotificationRuleTimeRestrictionRestrictionArrayOutput() NotificationRuleTimeRestrictionRestrictionArrayOutput
	ToNotificationRuleTimeRestrictionRestrictionArrayOutputWithContext(context.Context) NotificationRuleTimeRestrictionRestrictionArrayOutput
}

NotificationRuleTimeRestrictionRestrictionArrayInput is an input type that accepts NotificationRuleTimeRestrictionRestrictionArray and NotificationRuleTimeRestrictionRestrictionArrayOutput values. You can construct a concrete instance of `NotificationRuleTimeRestrictionRestrictionArrayInput` via: 

NotificationRuleTimeRestrictionRestrictionArray{ NotificationRuleTimeRestrictionRestrictionArgs{...} }

type NotificationRuleTimeRestrictionRestrictionArrayOutput 

type NotificationRuleTimeRestrictionRestrictionArrayOutput struct{ *pulumi.OutputState }

func (NotificationRuleTimeRestrictionRestrictionArrayOutput) ElementType 

func (NotificationRuleTimeRestrictionRestrictionArrayOutput) ElementType() reflect.Type

func (NotificationRuleTimeRestrictionRestrictionArrayOutput) Index 

func (o NotificationRuleTimeRestrictionRestrictionArrayOutput) Index(i pulumi.IntInput) NotificationRuleTimeRestrictionRestrictionOutput

func (NotificationRuleTimeRestrictionRestrictionArrayOutput) ToNotificationRuleTimeRestrictionRestrictionArrayOutput 

func (o NotificationRuleTimeRestrictionRestrictionArrayOutput) ToNotificationRuleTimeRestrictionRestrictionArrayOutput() NotificationRuleTimeRestrictionRestrictionArrayOutput

func (NotificationRuleTimeRestrictionRestrictionArrayOutput) ToNotificationRuleTimeRestrictionRestrictionArrayOutputWithContext 

func (o NotificationRuleTimeRestrictionRestrictionArrayOutput) ToNotificationRuleTimeRestrictionRestrictionArrayOutputWithContext(ctx context.Context) NotificationRuleTimeRestrictionRestrictionArrayOutput

type NotificationRuleTimeRestrictionRestrictionInput 

type NotificationRuleTimeRestrictionRestrictionInput interface {
	pulumi.Input

	ToNotificationRuleTimeRestrictionRestrictionOutput() NotificationRuleTimeRestrictionRestrictionOutput
	ToNotificationRuleTimeRestrictionRestrictionOutputWithContext(context.Context) NotificationRuleTimeRestrictionRestrictionOutput
}

NotificationRuleTimeRestrictionRestrictionInput is an input type that accepts NotificationRuleTimeRestrictionRestrictionArgs and NotificationRuleTimeRestrictionRestrictionOutput values. You can construct a concrete instance of `NotificationRuleTimeRestrictionRestrictionInput` via: 

NotificationRuleTimeRestrictionRestrictionArgs{...}

type NotificationRuleTimeRestrictionRestrictionOutput 

type NotificationRuleTimeRestrictionRestrictionOutput struct{ *pulumi.OutputState }

func (NotificationRuleTimeRestrictionRestrictionOutput) ElementType 

func (NotificationRuleTimeRestrictionRestrictionOutput) ElementType() reflect.Type

func (NotificationRuleTimeRestrictionRestrictionOutput) EndDay 

func (o NotificationRuleTimeRestrictionRestrictionOutput) EndDay() pulumi.StringOutput

func (NotificationRuleTimeRestrictionRestrictionOutput) EndHour 

func (o NotificationRuleTimeRestrictionRestrictionOutput) EndHour() pulumi.IntOutput

func (NotificationRuleTimeRestrictionRestrictionOutput) EndMin 

func (o NotificationRuleTimeRestrictionRestrictionOutput) EndMin() pulumi.IntOutput

func (NotificationRuleTimeRestrictionRestrictionOutput) StartDay 

func (o NotificationRuleTimeRestrictionRestrictionOutput) StartDay() pulumi.StringOutput

func (NotificationRuleTimeRestrictionRestrictionOutput) StartHour 

func (o NotificationRuleTimeRestrictionRestrictionOutput) StartHour() pulumi.IntOutput

func (NotificationRuleTimeRestrictionRestrictionOutput) StartMin 

func (o NotificationRuleTimeRestrictionRestrictionOutput) StartMin() pulumi.IntOutput

func (NotificationRuleTimeRestrictionRestrictionOutput) ToNotificationRuleTimeRestrictionRestrictionOutput 

func (o NotificationRuleTimeRestrictionRestrictionOutput) ToNotificationRuleTimeRestrictionRestrictionOutput() NotificationRuleTimeRestrictionRestrictionOutput

func (NotificationRuleTimeRestrictionRestrictionOutput) ToNotificationRuleTimeRestrictionRestrictionOutputWithContext 

func (o NotificationRuleTimeRestrictionRestrictionOutput) ToNotificationRuleTimeRestrictionRestrictionOutputWithContext(ctx context.Context) NotificationRuleTimeRestrictionRestrictionOutput

type Provider 

type Provider struct {
	pulumi.ProviderResourceState

	ApiKey pulumi.StringOutput    `pulumi:"apiKey"`
	ApiUrl pulumi.StringPtrOutput `pulumi:"apiUrl"`
}

The provider type for the opsgenie package. By default, resources use package-wide configuration settings, however an explicit `Provider` instance may be created and passed during resource construction to achieve fine-grained programmatic control over provider settings. See the [documentation](https://www.pulumi.com/docs/reference/programming-model/#providers) for more information.

func NewProvider 

func NewProvider(ctx *pulumi.Context,
	name string, args *ProviderArgs, opts ...pulumi.ResourceOption) (*Provider, error)

NewProvider registers a new resource with the given unique name, arguments, and options.

func (*Provider) ElementType 

func (*Provider) ElementType() reflect.Type

func (*Provider) ToProviderOutput 

func (i *Provider) ToProviderOutput() ProviderOutput

func (*Provider) ToProviderOutputWithContext 

func (i *Provider) ToProviderOutputWithContext(ctx context.Context) ProviderOutput

type ProviderArgs 

type ProviderArgs struct {
	ApiKey pulumi.StringInput
	ApiUrl pulumi.StringPtrInput
}

The set of arguments for constructing a Provider resource.

func (ProviderArgs) ElementType 

func (ProviderArgs) ElementType() reflect.Type

type ProviderInput 

type ProviderInput interface {
	pulumi.Input

	ToProviderOutput() ProviderOutput
	ToProviderOutputWithContext(ctx context.Context) ProviderOutput
}

type ProviderOutput 

type ProviderOutput struct{ *pulumi.OutputState }

func (ProviderOutput) ApiKey added in v1.1.9 

func (o ProviderOutput) ApiKey() pulumi.StringOutput

func (ProviderOutput) ApiUrl added in v1.1.9 

func (o ProviderOutput) ApiUrl() pulumi.StringPtrOutput

func (ProviderOutput) ElementType 

func (ProviderOutput) ElementType() reflect.Type

func (ProviderOutput) ToProviderOutput 

func (o ProviderOutput) ToProviderOutput() ProviderOutput

func (ProviderOutput) ToProviderOutputWithContext 

func (o ProviderOutput) ToProviderOutputWithContext(ctx context.Context) ProviderOutput

type Schedule 

type Schedule struct {
	pulumi.CustomResourceState

	// The description of schedule.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Enable/disable state of schedule
	Enabled pulumi.BoolPtrOutput `pulumi:"enabled"`
	// Name of the schedule.
	Name pulumi.StringOutput `pulumi:"name"`
	// Owner team id of the schedule.
	OwnerTeamId pulumi.StringPtrOutput `pulumi:"ownerTeamId"`
	// Timezone of schedule. Please look at [Supported Timezone Ids](https://docs.opsgenie.com/docs/supported-timezone-ids) for available timezones - Default: `America/New_York`.
	Timezone pulumi.StringPtrOutput `pulumi:"timezone"`
}

Manages a Schedule within Opsgenie.

## Import

Schedule can be imported using the `schedule_id`, e.g.

```sh $ pulumi import opsgenie:index/schedule:Schedule test schedule_id` ```

func GetSchedule 

func GetSchedule(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ScheduleState, opts ...pulumi.ResourceOption) (*Schedule, error)

GetSchedule gets an existing Schedule resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewSchedule 

func NewSchedule(ctx *pulumi.Context,
	name string, args *ScheduleArgs, opts ...pulumi.ResourceOption) (*Schedule, error)

NewSchedule registers a new resource with the given unique name, arguments, and options.

func (*Schedule) ElementType 

func (*Schedule) ElementType() reflect.Type

func (*Schedule) ToScheduleOutput 

func (i *Schedule) ToScheduleOutput() ScheduleOutput

func (*Schedule) ToScheduleOutputWithContext 

func (i *Schedule) ToScheduleOutputWithContext(ctx context.Context) ScheduleOutput

type ScheduleArgs 

type ScheduleArgs struct {
	// The description of schedule.
	Description pulumi.StringPtrInput
	// Enable/disable state of schedule
	Enabled pulumi.BoolPtrInput
	// Name of the schedule.
	Name pulumi.StringPtrInput
	// Owner team id of the schedule.
	OwnerTeamId pulumi.StringPtrInput
	// Timezone of schedule. Please look at [Supported Timezone Ids](https://docs.opsgenie.com/docs/supported-timezone-ids) for available timezones - Default: `America/New_York`.
	Timezone pulumi.StringPtrInput
}

The set of arguments for constructing a Schedule resource.

func (ScheduleArgs) ElementType 

func (ScheduleArgs) ElementType() reflect.Type

type ScheduleArray added in v0.1.3 

type ScheduleArray []ScheduleInput

func (ScheduleArray) ElementType added in v0.1.3 

func (ScheduleArray) ElementType() reflect.Type

func (ScheduleArray) ToScheduleArrayOutput added in v0.1.3 

func (i ScheduleArray) ToScheduleArrayOutput() ScheduleArrayOutput

func (ScheduleArray) ToScheduleArrayOutputWithContext added in v0.1.3 

func (i ScheduleArray) ToScheduleArrayOutputWithContext(ctx context.Context) ScheduleArrayOutput

type ScheduleArrayInput added in v0.1.3 

type ScheduleArrayInput interface {
	pulumi.Input

	ToScheduleArrayOutput() ScheduleArrayOutput
	ToScheduleArrayOutputWithContext(context.Context) ScheduleArrayOutput
}

ScheduleArrayInput is an input type that accepts ScheduleArray and ScheduleArrayOutput values. You can construct a concrete instance of `ScheduleArrayInput` via: 

ScheduleArray{ ScheduleArgs{...} }

type ScheduleArrayOutput added in v0.1.3 

type ScheduleArrayOutput struct{ *pulumi.OutputState }

func (ScheduleArrayOutput) ElementType added in v0.1.3 

func (ScheduleArrayOutput) ElementType() reflect.Type

func (ScheduleArrayOutput) Index added in v0.1.3 

func (o ScheduleArrayOutput) Index(i pulumi.IntInput) ScheduleOutput

func (ScheduleArrayOutput) ToScheduleArrayOutput added in v0.1.3 

func (o ScheduleArrayOutput) ToScheduleArrayOutput() ScheduleArrayOutput

func (ScheduleArrayOutput) ToScheduleArrayOutputWithContext added in v0.1.3 

func (o ScheduleArrayOutput) ToScheduleArrayOutputWithContext(ctx context.Context) ScheduleArrayOutput

type ScheduleInput 

type ScheduleInput interface {
	pulumi.Input

	ToScheduleOutput() ScheduleOutput
	ToScheduleOutputWithContext(ctx context.Context) ScheduleOutput
}

type ScheduleMap added in v0.1.3 

type ScheduleMap map[string]ScheduleInput

func (ScheduleMap) ElementType added in v0.1.3 

func (ScheduleMap) ElementType() reflect.Type

func (ScheduleMap) ToScheduleMapOutput added in v0.1.3 

func (i ScheduleMap) ToScheduleMapOutput() ScheduleMapOutput

func (ScheduleMap) ToScheduleMapOutputWithContext added in v0.1.3 

func (i ScheduleMap) ToScheduleMapOutputWithContext(ctx context.Context) ScheduleMapOutput

type ScheduleMapInput added in v0.1.3 

type ScheduleMapInput interface {
	pulumi.Input

	ToScheduleMapOutput() ScheduleMapOutput
	ToScheduleMapOutputWithContext(context.Context) ScheduleMapOutput
}

ScheduleMapInput is an input type that accepts ScheduleMap and ScheduleMapOutput values. You can construct a concrete instance of `ScheduleMapInput` via: 

ScheduleMap{ "key": ScheduleArgs{...} }

type ScheduleMapOutput added in v0.1.3 

type ScheduleMapOutput struct{ *pulumi.OutputState }

func (ScheduleMapOutput) ElementType added in v0.1.3 

func (ScheduleMapOutput) ElementType() reflect.Type

func (ScheduleMapOutput) MapIndex added in v0.1.3 

func (o ScheduleMapOutput) MapIndex(k pulumi.StringInput) ScheduleOutput

func (ScheduleMapOutput) ToScheduleMapOutput added in v0.1.3 

func (o ScheduleMapOutput) ToScheduleMapOutput() ScheduleMapOutput

func (ScheduleMapOutput) ToScheduleMapOutputWithContext added in v0.1.3 

func (o ScheduleMapOutput) ToScheduleMapOutputWithContext(ctx context.Context) ScheduleMapOutput

type ScheduleOutput 

type ScheduleOutput struct{ *pulumi.OutputState }

func (ScheduleOutput) Description added in v1.1.9 

func (o ScheduleOutput) Description() pulumi.StringPtrOutput

The description of schedule.

func (ScheduleOutput) ElementType 

func (ScheduleOutput) ElementType() reflect.Type

func (ScheduleOutput) Enabled added in v1.1.9 

func (o ScheduleOutput) Enabled() pulumi.BoolPtrOutput

Enable/disable state of schedule

func (ScheduleOutput) Name added in v1.1.9 

func (o ScheduleOutput) Name() pulumi.StringOutput

Name of the schedule.

func (ScheduleOutput) OwnerTeamId added in v1.1.9 

func (o ScheduleOutput) OwnerTeamId() pulumi.StringPtrOutput

Owner team id of the schedule.

func (ScheduleOutput) Timezone added in v1.1.9 

func (o ScheduleOutput) Timezone() pulumi.StringPtrOutput

Timezone of schedule. Please look at [Supported Timezone Ids](https://docs.opsgenie.com/docs/supported-timezone-ids) for available timezones - Default: `America/New_York`.

func (ScheduleOutput) ToScheduleOutput 

func (o ScheduleOutput) ToScheduleOutput() ScheduleOutput

func (ScheduleOutput) ToScheduleOutputWithContext 

func (o ScheduleOutput) ToScheduleOutputWithContext(ctx context.Context) ScheduleOutput

type ScheduleRotation 

type ScheduleRotation struct {
	pulumi.CustomResourceState

	// This parameter takes a date format as (yyyy-MM-dd'T'HH:mm:ssZ) (e.g. 2019-06-11T08:00:00+02:00). Minutes may take 0 or 30 as value. Otherwise they will be converted to nearest 0 or 30 automatically
	EndDate pulumi.StringPtrOutput `pulumi:"endDate"`
	// Length of the rotation with default value 1.
	Length pulumi.IntPtrOutput `pulumi:"length"`
	// Name of rotation.
	Name pulumi.StringOutput `pulumi:"name"`
	// List of escalations, teams, users or the reserved word none which will be used in schedule. Each of them can be used multiple times and will be rotated in the order they given. "user,escalation,team,none"
	Participants ScheduleRotationParticipantArrayOutput `pulumi:"participants"`
	// Identifier of the schedule.
	ScheduleId pulumi.StringOutput `pulumi:"scheduleId"`
	// This parameter takes a date format as (yyyy-MM-dd'T'HH:mm:ssZ) (e.g. 2019-06-11T08:00:00+02:00). Minutes may take 0 or 30 as value. Otherwise they will be converted to nearest 0 or 30 automatically
	StartDate        pulumi.StringOutput                        `pulumi:"startDate"`
	TimeRestrictions ScheduleRotationTimeRestrictionArrayOutput `pulumi:"timeRestrictions"`
	// Type of rotation. May be one of daily, weekly and hourly.
	Type pulumi.StringOutput `pulumi:"type"`
}

Manages a Schedule Rotation within Opsgenie.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opsgenie.NewScheduleRotation(ctx, "test", &opsgenie.ScheduleRotationArgs{
			ScheduleId: pulumi.Any(testOpsgenieSchedule.Id),
			Name:       pulumi.String("test"),
			StartDate:  pulumi.String("2019-06-18T17:00:00Z"),
			EndDate:    pulumi.String("2019-06-20T17:30:00Z"),
			Type:       pulumi.String("hourly"),
			Length:     pulumi.Int(6),
			Participants: opsgenie.ScheduleRotationParticipantArray{
				&opsgenie.ScheduleRotationParticipantArgs{
					Type: pulumi.String("user"),
					Id:   pulumi.Any(testOpsgenieUser.Id),
				},
			},
			TimeRestrictions: opsgenie.ScheduleRotationTimeRestrictionArray{
				&opsgenie.ScheduleRotationTimeRestrictionArgs{
					Type: pulumi.String("time-of-day"),
					Restriction: opsgenie.ScheduleRotationTimeRestrictionRestrictionArray{
						&opsgenie.ScheduleRotationTimeRestrictionRestrictionArgs{
							StartHour: pulumi.Int(1),
							StartMin:  pulumi.Int(1),
							EndHour:   pulumi.Int(10),
							EndMin:    pulumi.Int(1),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Schedule Rotations can be imported using the `schedule_id/rotation_id`, e.g.

```sh $ pulumi import opsgenie:index/scheduleRotation:ScheduleRotation * `opsgenie_schedule_rotation.test schedule_id/rotation_id` ```

func GetScheduleRotation 

func GetScheduleRotation(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ScheduleRotationState, opts ...pulumi.ResourceOption) (*ScheduleRotation, error)

GetScheduleRotation gets an existing ScheduleRotation resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewScheduleRotation 

func NewScheduleRotation(ctx *pulumi.Context,
	name string, args *ScheduleRotationArgs, opts ...pulumi.ResourceOption) (*ScheduleRotation, error)

NewScheduleRotation registers a new resource with the given unique name, arguments, and options.

func (*ScheduleRotation) ElementType 

func (*ScheduleRotation) ElementType() reflect.Type

func (*ScheduleRotation) ToScheduleRotationOutput 

func (i *ScheduleRotation) ToScheduleRotationOutput() ScheduleRotationOutput

func (*ScheduleRotation) ToScheduleRotationOutputWithContext 

func (i *ScheduleRotation) ToScheduleRotationOutputWithContext(ctx context.Context) ScheduleRotationOutput

type ScheduleRotationArgs 

type ScheduleRotationArgs struct {
	// This parameter takes a date format as (yyyy-MM-dd'T'HH:mm:ssZ) (e.g. 2019-06-11T08:00:00+02:00). Minutes may take 0 or 30 as value. Otherwise they will be converted to nearest 0 or 30 automatically
	EndDate pulumi.StringPtrInput
	// Length of the rotation with default value 1.
	Length pulumi.IntPtrInput
	// Name of rotation.
	Name pulumi.StringPtrInput
	// List of escalations, teams, users or the reserved word none which will be used in schedule. Each of them can be used multiple times and will be rotated in the order they given. "user,escalation,team,none"
	Participants ScheduleRotationParticipantArrayInput
	// Identifier of the schedule.
	ScheduleId pulumi.StringInput
	// This parameter takes a date format as (yyyy-MM-dd'T'HH:mm:ssZ) (e.g. 2019-06-11T08:00:00+02:00). Minutes may take 0 or 30 as value. Otherwise they will be converted to nearest 0 or 30 automatically
	StartDate        pulumi.StringInput
	TimeRestrictions ScheduleRotationTimeRestrictionArrayInput
	// Type of rotation. May be one of daily, weekly and hourly.
	Type pulumi.StringInput
}

The set of arguments for constructing a ScheduleRotation resource.

func (ScheduleRotationArgs) ElementType 

func (ScheduleRotationArgs) ElementType() reflect.Type

type ScheduleRotationArray added in v0.1.3 

type ScheduleRotationArray []ScheduleRotationInput

func (ScheduleRotationArray) ElementType added in v0.1.3 

func (ScheduleRotationArray) ElementType() reflect.Type

func (ScheduleRotationArray) ToScheduleRotationArrayOutput added in v0.1.3 

func (i ScheduleRotationArray) ToScheduleRotationArrayOutput() ScheduleRotationArrayOutput

func (ScheduleRotationArray) ToScheduleRotationArrayOutputWithContext added in v0.1.3 

func (i ScheduleRotationArray) ToScheduleRotationArrayOutputWithContext(ctx context.Context) ScheduleRotationArrayOutput

type ScheduleRotationArrayInput added in v0.1.3 

type ScheduleRotationArrayInput interface {
	pulumi.Input

	ToScheduleRotationArrayOutput() ScheduleRotationArrayOutput
	ToScheduleRotationArrayOutputWithContext(context.Context) ScheduleRotationArrayOutput
}

ScheduleRotationArrayInput is an input type that accepts ScheduleRotationArray and ScheduleRotationArrayOutput values. You can construct a concrete instance of `ScheduleRotationArrayInput` via: 

ScheduleRotationArray{ ScheduleRotationArgs{...} }

type ScheduleRotationArrayOutput added in v0.1.3 

type ScheduleRotationArrayOutput struct{ *pulumi.OutputState }

func (ScheduleRotationArrayOutput) ElementType added in v0.1.3 

func (ScheduleRotationArrayOutput) ElementType() reflect.Type

func (ScheduleRotationArrayOutput) Index added in v0.1.3 

func (o ScheduleRotationArrayOutput) Index(i pulumi.IntInput) ScheduleRotationOutput

func (ScheduleRotationArrayOutput) ToScheduleRotationArrayOutput added in v0.1.3 

func (o ScheduleRotationArrayOutput) ToScheduleRotationArrayOutput() ScheduleRotationArrayOutput

func (ScheduleRotationArrayOutput) ToScheduleRotationArrayOutputWithContext added in v0.1.3 

func (o ScheduleRotationArrayOutput) ToScheduleRotationArrayOutputWithContext(ctx context.Context) ScheduleRotationArrayOutput

type ScheduleRotationInput 

type ScheduleRotationInput interface {
	pulumi.Input

	ToScheduleRotationOutput() ScheduleRotationOutput
	ToScheduleRotationOutputWithContext(ctx context.Context) ScheduleRotationOutput
}

type ScheduleRotationMap added in v0.1.3 

type ScheduleRotationMap map[string]ScheduleRotationInput

func (ScheduleRotationMap) ElementType added in v0.1.3 

func (ScheduleRotationMap) ElementType() reflect.Type

func (ScheduleRotationMap) ToScheduleRotationMapOutput added in v0.1.3 

func (i ScheduleRotationMap) ToScheduleRotationMapOutput() ScheduleRotationMapOutput

func (ScheduleRotationMap) ToScheduleRotationMapOutputWithContext added in v0.1.3 

func (i ScheduleRotationMap) ToScheduleRotationMapOutputWithContext(ctx context.Context) ScheduleRotationMapOutput

type ScheduleRotationMapInput added in v0.1.3 

type ScheduleRotationMapInput interface {
	pulumi.Input

	ToScheduleRotationMapOutput() ScheduleRotationMapOutput
	ToScheduleRotationMapOutputWithContext(context.Context) ScheduleRotationMapOutput
}

ScheduleRotationMapInput is an input type that accepts ScheduleRotationMap and ScheduleRotationMapOutput values. You can construct a concrete instance of `ScheduleRotationMapInput` via: 

ScheduleRotationMap{ "key": ScheduleRotationArgs{...} }

type ScheduleRotationMapOutput added in v0.1.3 

type ScheduleRotationMapOutput struct{ *pulumi.OutputState }

func (ScheduleRotationMapOutput) ElementType added in v0.1.3 

func (ScheduleRotationMapOutput) ElementType() reflect.Type

func (ScheduleRotationMapOutput) MapIndex added in v0.1.3 

func (o ScheduleRotationMapOutput) MapIndex(k pulumi.StringInput) ScheduleRotationOutput

func (ScheduleRotationMapOutput) ToScheduleRotationMapOutput added in v0.1.3 

func (o ScheduleRotationMapOutput) ToScheduleRotationMapOutput() ScheduleRotationMapOutput

func (ScheduleRotationMapOutput) ToScheduleRotationMapOutputWithContext added in v0.1.3 

func (o ScheduleRotationMapOutput) ToScheduleRotationMapOutputWithContext(ctx context.Context) ScheduleRotationMapOutput

type ScheduleRotationOutput 

type ScheduleRotationOutput struct{ *pulumi.OutputState }

func (ScheduleRotationOutput) ElementType 

func (ScheduleRotationOutput) ElementType() reflect.Type

func (ScheduleRotationOutput) EndDate added in v1.1.9 

func (o ScheduleRotationOutput) EndDate() pulumi.StringPtrOutput

This parameter takes a date format as (yyyy-MM-dd'T'HH:mm:ssZ) (e.g. 2019-06-11T08:00:00+02:00). Minutes may take 0 or 30 as value. Otherwise they will be converted to nearest 0 or 30 automatically

func (ScheduleRotationOutput) Length added in v1.1.9 

func (o ScheduleRotationOutput) Length() pulumi.IntPtrOutput

Length of the rotation with default value 1.

func (ScheduleRotationOutput) Name added in v1.1.9 

func (o ScheduleRotationOutput) Name() pulumi.StringOutput

Name of rotation.

func (ScheduleRotationOutput) Participants added in v1.1.9 

func (o ScheduleRotationOutput) Participants() ScheduleRotationParticipantArrayOutput

List of escalations, teams, users or the reserved word none which will be used in schedule. Each of them can be used multiple times and will be rotated in the order they given. "user,escalation,team,none"

func (ScheduleRotationOutput) ScheduleId added in v1.1.9 

func (o ScheduleRotationOutput) ScheduleId() pulumi.StringOutput

Identifier of the schedule.

func (ScheduleRotationOutput) StartDate added in v1.1.9 

func (o ScheduleRotationOutput) StartDate() pulumi.StringOutput

This parameter takes a date format as (yyyy-MM-dd'T'HH:mm:ssZ) (e.g. 2019-06-11T08:00:00+02:00). Minutes may take 0 or 30 as value. Otherwise they will be converted to nearest 0 or 30 automatically

func (ScheduleRotationOutput) TimeRestrictions added in v1.1.9 

func (o ScheduleRotationOutput) TimeRestrictions() ScheduleRotationTimeRestrictionArrayOutput

func (ScheduleRotationOutput) ToScheduleRotationOutput 

func (o ScheduleRotationOutput) ToScheduleRotationOutput() ScheduleRotationOutput

func (ScheduleRotationOutput) ToScheduleRotationOutputWithContext 

func (o ScheduleRotationOutput) ToScheduleRotationOutputWithContext(ctx context.Context) ScheduleRotationOutput

func (ScheduleRotationOutput) Type added in v1.1.9 

func (o ScheduleRotationOutput) Type() pulumi.StringOutput

Type of rotation. May be one of daily, weekly and hourly.

type ScheduleRotationParticipant 

type ScheduleRotationParticipant struct {
	// The id of the responder.
	Id *string `pulumi:"id"`
	// The responder type.
	Type string `pulumi:"type"`
}

type ScheduleRotationParticipantArgs 

type ScheduleRotationParticipantArgs struct {
	// The id of the responder.
	Id pulumi.StringPtrInput `pulumi:"id"`
	// The responder type.
	Type pulumi.StringInput `pulumi:"type"`
}

func (ScheduleRotationParticipantArgs) ElementType 

func (ScheduleRotationParticipantArgs) ElementType() reflect.Type

func (ScheduleRotationParticipantArgs) ToScheduleRotationParticipantOutput 

func (i ScheduleRotationParticipantArgs) ToScheduleRotationParticipantOutput() ScheduleRotationParticipantOutput

func (ScheduleRotationParticipantArgs) ToScheduleRotationParticipantOutputWithContext 

func (i ScheduleRotationParticipantArgs) ToScheduleRotationParticipantOutputWithContext(ctx context.Context) ScheduleRotationParticipantOutput

type ScheduleRotationParticipantArray 

type ScheduleRotationParticipantArray []ScheduleRotationParticipantInput

func (ScheduleRotationParticipantArray) ElementType 

func (ScheduleRotationParticipantArray) ElementType() reflect.Type

func (ScheduleRotationParticipantArray) ToScheduleRotationParticipantArrayOutput 

func (i ScheduleRotationParticipantArray) ToScheduleRotationParticipantArrayOutput() ScheduleRotationParticipantArrayOutput

func (ScheduleRotationParticipantArray) ToScheduleRotationParticipantArrayOutputWithContext 

func (i ScheduleRotationParticipantArray) ToScheduleRotationParticipantArrayOutputWithContext(ctx context.Context) ScheduleRotationParticipantArrayOutput

type ScheduleRotationParticipantArrayInput 

type ScheduleRotationParticipantArrayInput interface {
	pulumi.Input

	ToScheduleRotationParticipantArrayOutput() ScheduleRotationParticipantArrayOutput
	ToScheduleRotationParticipantArrayOutputWithContext(context.Context) ScheduleRotationParticipantArrayOutput
}

ScheduleRotationParticipantArrayInput is an input type that accepts ScheduleRotationParticipantArray and ScheduleRotationParticipantArrayOutput values. You can construct a concrete instance of `ScheduleRotationParticipantArrayInput` via: 

ScheduleRotationParticipantArray{ ScheduleRotationParticipantArgs{...} }

type ScheduleRotationParticipantArrayOutput 

type ScheduleRotationParticipantArrayOutput struct{ *pulumi.OutputState }

func (ScheduleRotationParticipantArrayOutput) ElementType 

func (ScheduleRotationParticipantArrayOutput) ElementType() reflect.Type

func (ScheduleRotationParticipantArrayOutput) Index 

func (o ScheduleRotationParticipantArrayOutput) Index(i pulumi.IntInput) ScheduleRotationParticipantOutput

func (ScheduleRotationParticipantArrayOutput) ToScheduleRotationParticipantArrayOutput 

func (o ScheduleRotationParticipantArrayOutput) ToScheduleRotationParticipantArrayOutput() ScheduleRotationParticipantArrayOutput

func (ScheduleRotationParticipantArrayOutput) ToScheduleRotationParticipantArrayOutputWithContext 

func (o ScheduleRotationParticipantArrayOutput) ToScheduleRotationParticipantArrayOutputWithContext(ctx context.Context) ScheduleRotationParticipantArrayOutput

type ScheduleRotationParticipantInput 

type ScheduleRotationParticipantInput interface {
	pulumi.Input

	ToScheduleRotationParticipantOutput() ScheduleRotationParticipantOutput
	ToScheduleRotationParticipantOutputWithContext(context.Context) ScheduleRotationParticipantOutput
}

ScheduleRotationParticipantInput is an input type that accepts ScheduleRotationParticipantArgs and ScheduleRotationParticipantOutput values. You can construct a concrete instance of `ScheduleRotationParticipantInput` via: 

ScheduleRotationParticipantArgs{...}

type ScheduleRotationParticipantOutput 

type ScheduleRotationParticipantOutput struct{ *pulumi.OutputState }

func (ScheduleRotationParticipantOutput) ElementType 

func (ScheduleRotationParticipantOutput) ElementType() reflect.Type

func (ScheduleRotationParticipantOutput) Id 

func (o ScheduleRotationParticipantOutput) Id() pulumi.StringPtrOutput

The id of the responder.

func (ScheduleRotationParticipantOutput) ToScheduleRotationParticipantOutput 

func (o ScheduleRotationParticipantOutput) ToScheduleRotationParticipantOutput() ScheduleRotationParticipantOutput

func (ScheduleRotationParticipantOutput) ToScheduleRotationParticipantOutputWithContext 

func (o ScheduleRotationParticipantOutput) ToScheduleRotationParticipantOutputWithContext(ctx context.Context) ScheduleRotationParticipantOutput

func (ScheduleRotationParticipantOutput) Type 

func (o ScheduleRotationParticipantOutput) Type() pulumi.StringOutput

The responder type.

type ScheduleRotationState 

type ScheduleRotationState struct {
	// This parameter takes a date format as (yyyy-MM-dd'T'HH:mm:ssZ) (e.g. 2019-06-11T08:00:00+02:00). Minutes may take 0 or 30 as value. Otherwise they will be converted to nearest 0 or 30 automatically
	EndDate pulumi.StringPtrInput
	// Length of the rotation with default value 1.
	Length pulumi.IntPtrInput
	// Name of rotation.
	Name pulumi.StringPtrInput
	// List of escalations, teams, users or the reserved word none which will be used in schedule. Each of them can be used multiple times and will be rotated in the order they given. "user,escalation,team,none"
	Participants ScheduleRotationParticipantArrayInput
	// Identifier of the schedule.
	ScheduleId pulumi.StringPtrInput
	// This parameter takes a date format as (yyyy-MM-dd'T'HH:mm:ssZ) (e.g. 2019-06-11T08:00:00+02:00). Minutes may take 0 or 30 as value. Otherwise they will be converted to nearest 0 or 30 automatically
	StartDate        pulumi.StringPtrInput
	TimeRestrictions ScheduleRotationTimeRestrictionArrayInput
	// Type of rotation. May be one of daily, weekly and hourly.
	Type pulumi.StringPtrInput
}

func (ScheduleRotationState) ElementType 

func (ScheduleRotationState) ElementType() reflect.Type

type ScheduleRotationTimeRestriction 

type ScheduleRotationTimeRestriction struct {
	// It is a restriction object which is described below. In this case startDay/endDay fields are not supported. This can be used only if time restriction type is `time-of-day`.
	Restriction     []ScheduleRotationTimeRestrictionRestriction     `pulumi:"restriction"`
	RestrictionList []ScheduleRotationTimeRestrictionRestrictionList `pulumi:"restrictionList"`
	// This parameter should be set to `time-of-day` or `weekday-and-time-of-day`.
	Type string `pulumi:"type"`
}

type ScheduleRotationTimeRestrictionArgs 

type ScheduleRotationTimeRestrictionArgs struct {
	// It is a restriction object which is described below. In this case startDay/endDay fields are not supported. This can be used only if time restriction type is `time-of-day`.
	Restriction     ScheduleRotationTimeRestrictionRestrictionArrayInput     `pulumi:"restriction"`
	RestrictionList ScheduleRotationTimeRestrictionRestrictionListArrayInput `pulumi:"restrictionList"`
	// This parameter should be set to `time-of-day` or `weekday-and-time-of-day`.
	Type pulumi.StringInput `pulumi:"type"`
}

func (ScheduleRotationTimeRestrictionArgs) ElementType 

func (ScheduleRotationTimeRestrictionArgs) ElementType() reflect.Type

func (ScheduleRotationTimeRestrictionArgs) ToScheduleRotationTimeRestrictionOutput 

func (i ScheduleRotationTimeRestrictionArgs) ToScheduleRotationTimeRestrictionOutput() ScheduleRotationTimeRestrictionOutput

func (ScheduleRotationTimeRestrictionArgs) ToScheduleRotationTimeRestrictionOutputWithContext 

func (i ScheduleRotationTimeRestrictionArgs) ToScheduleRotationTimeRestrictionOutputWithContext(ctx context.Context) ScheduleRotationTimeRestrictionOutput

type ScheduleRotationTimeRestrictionArray 

type ScheduleRotationTimeRestrictionArray []ScheduleRotationTimeRestrictionInput

func (ScheduleRotationTimeRestrictionArray) ElementType 

func (ScheduleRotationTimeRestrictionArray) ElementType() reflect.Type

func (ScheduleRotationTimeRestrictionArray) ToScheduleRotationTimeRestrictionArrayOutput 

func (i ScheduleRotationTimeRestrictionArray) ToScheduleRotationTimeRestrictionArrayOutput() ScheduleRotationTimeRestrictionArrayOutput

func (ScheduleRotationTimeRestrictionArray) ToScheduleRotationTimeRestrictionArrayOutputWithContext 

func (i ScheduleRotationTimeRestrictionArray) ToScheduleRotationTimeRestrictionArrayOutputWithContext(ctx context.Context) ScheduleRotationTimeRestrictionArrayOutput

type ScheduleRotationTimeRestrictionArrayInput 

type ScheduleRotationTimeRestrictionArrayInput interface {
	pulumi.Input

	ToScheduleRotationTimeRestrictionArrayOutput() ScheduleRotationTimeRestrictionArrayOutput
	ToScheduleRotationTimeRestrictionArrayOutputWithContext(context.Context) ScheduleRotationTimeRestrictionArrayOutput
}

ScheduleRotationTimeRestrictionArrayInput is an input type that accepts ScheduleRotationTimeRestrictionArray and ScheduleRotationTimeRestrictionArrayOutput values. You can construct a concrete instance of `ScheduleRotationTimeRestrictionArrayInput` via: 

ScheduleRotationTimeRestrictionArray{ ScheduleRotationTimeRestrictionArgs{...} }

type ScheduleRotationTimeRestrictionArrayOutput 

type ScheduleRotationTimeRestrictionArrayOutput struct{ *pulumi.OutputState }

func (ScheduleRotationTimeRestrictionArrayOutput) ElementType 

func (ScheduleRotationTimeRestrictionArrayOutput) ElementType() reflect.Type

func (ScheduleRotationTimeRestrictionArrayOutput) Index 

func (o ScheduleRotationTimeRestrictionArrayOutput) Index(i pulumi.IntInput) ScheduleRotationTimeRestrictionOutput

func (ScheduleRotationTimeRestrictionArrayOutput) ToScheduleRotationTimeRestrictionArrayOutput 

func (o ScheduleRotationTimeRestrictionArrayOutput) ToScheduleRotationTimeRestrictionArrayOutput() ScheduleRotationTimeRestrictionArrayOutput

func (ScheduleRotationTimeRestrictionArrayOutput) ToScheduleRotationTimeRestrictionArrayOutputWithContext 

func (o ScheduleRotationTimeRestrictionArrayOutput) ToScheduleRotationTimeRestrictionArrayOutputWithContext(ctx context.Context) ScheduleRotationTimeRestrictionArrayOutput

type ScheduleRotationTimeRestrictionInput 

type ScheduleRotationTimeRestrictionInput interface {
	pulumi.Input

	ToScheduleRotationTimeRestrictionOutput() ScheduleRotationTimeRestrictionOutput
	ToScheduleRotationTimeRestrictionOutputWithContext(context.Context) ScheduleRotationTimeRestrictionOutput
}

ScheduleRotationTimeRestrictionInput is an input type that accepts ScheduleRotationTimeRestrictionArgs and ScheduleRotationTimeRestrictionOutput values. You can construct a concrete instance of `ScheduleRotationTimeRestrictionInput` via: 

ScheduleRotationTimeRestrictionArgs{...}

type ScheduleRotationTimeRestrictionOutput 

type ScheduleRotationTimeRestrictionOutput struct{ *pulumi.OutputState }

func (ScheduleRotationTimeRestrictionOutput) ElementType 

func (ScheduleRotationTimeRestrictionOutput) ElementType() reflect.Type

func (ScheduleRotationTimeRestrictionOutput) Restriction added in v1.0.2 

func (o ScheduleRotationTimeRestrictionOutput) Restriction() ScheduleRotationTimeRestrictionRestrictionArrayOutput

It is a restriction object which is described below. In this case startDay/endDay fields are not supported. This can be used only if time restriction type is `time-of-day`.

func (ScheduleRotationTimeRestrictionOutput) RestrictionList added in v1.1.7 

func (o ScheduleRotationTimeRestrictionOutput) RestrictionList() ScheduleRotationTimeRestrictionRestrictionListArrayOutput

func (ScheduleRotationTimeRestrictionOutput) ToScheduleRotationTimeRestrictionOutput 

func (o ScheduleRotationTimeRestrictionOutput) ToScheduleRotationTimeRestrictionOutput() ScheduleRotationTimeRestrictionOutput

func (ScheduleRotationTimeRestrictionOutput) ToScheduleRotationTimeRestrictionOutputWithContext 

func (o ScheduleRotationTimeRestrictionOutput) ToScheduleRotationTimeRestrictionOutputWithContext(ctx context.Context) ScheduleRotationTimeRestrictionOutput

func (ScheduleRotationTimeRestrictionOutput) Type 

func (o ScheduleRotationTimeRestrictionOutput) Type() pulumi.StringOutput

This parameter should be set to `time-of-day` or `weekday-and-time-of-day`.

type ScheduleRotationTimeRestrictionRestriction 

type ScheduleRotationTimeRestrictionRestriction struct {
	EndHour   int `pulumi:"endHour"`
	EndMin    int `pulumi:"endMin"`
	StartHour int `pulumi:"startHour"`
	StartMin  int `pulumi:"startMin"`
}

type ScheduleRotationTimeRestrictionRestrictionArgs 

type ScheduleRotationTimeRestrictionRestrictionArgs struct {
	EndHour   pulumi.IntInput `pulumi:"endHour"`
	EndMin    pulumi.IntInput `pulumi:"endMin"`
	StartHour pulumi.IntInput `pulumi:"startHour"`
	StartMin  pulumi.IntInput `pulumi:"startMin"`
}

func (ScheduleRotationTimeRestrictionRestrictionArgs) ElementType 

func (ScheduleRotationTimeRestrictionRestrictionArgs) ElementType() reflect.Type

func (ScheduleRotationTimeRestrictionRestrictionArgs) ToScheduleRotationTimeRestrictionRestrictionOutput 

func (i ScheduleRotationTimeRestrictionRestrictionArgs) ToScheduleRotationTimeRestrictionRestrictionOutput() ScheduleRotationTimeRestrictionRestrictionOutput

func (ScheduleRotationTimeRestrictionRestrictionArgs) ToScheduleRotationTimeRestrictionRestrictionOutputWithContext 

func (i ScheduleRotationTimeRestrictionRestrictionArgs) ToScheduleRotationTimeRestrictionRestrictionOutputWithContext(ctx context.Context) ScheduleRotationTimeRestrictionRestrictionOutput

type ScheduleRotationTimeRestrictionRestrictionArray 

type ScheduleRotationTimeRestrictionRestrictionArray []ScheduleRotationTimeRestrictionRestrictionInput

func (ScheduleRotationTimeRestrictionRestrictionArray) ElementType 

func (ScheduleRotationTimeRestrictionRestrictionArray) ElementType() reflect.Type

func (ScheduleRotationTimeRestrictionRestrictionArray) ToScheduleRotationTimeRestrictionRestrictionArrayOutput 

func (i ScheduleRotationTimeRestrictionRestrictionArray) ToScheduleRotationTimeRestrictionRestrictionArrayOutput() ScheduleRotationTimeRestrictionRestrictionArrayOutput

func (ScheduleRotationTimeRestrictionRestrictionArray) ToScheduleRotationTimeRestrictionRestrictionArrayOutputWithContext 

func (i ScheduleRotationTimeRestrictionRestrictionArray) ToScheduleRotationTimeRestrictionRestrictionArrayOutputWithContext(ctx context.Context) ScheduleRotationTimeRestrictionRestrictionArrayOutput

type ScheduleRotationTimeRestrictionRestrictionArrayInput 

type ScheduleRotationTimeRestrictionRestrictionArrayInput interface {
	pulumi.Input

	ToScheduleRotationTimeRestrictionRestrictionArrayOutput() ScheduleRotationTimeRestrictionRestrictionArrayOutput
	ToScheduleRotationTimeRestrictionRestrictionArrayOutputWithContext(context.Context) ScheduleRotationTimeRestrictionRestrictionArrayOutput
}

ScheduleRotationTimeRestrictionRestrictionArrayInput is an input type that accepts ScheduleRotationTimeRestrictionRestrictionArray and ScheduleRotationTimeRestrictionRestrictionArrayOutput values. You can construct a concrete instance of `ScheduleRotationTimeRestrictionRestrictionArrayInput` via: 

ScheduleRotationTimeRestrictionRestrictionArray{ ScheduleRotationTimeRestrictionRestrictionArgs{...} }

type ScheduleRotationTimeRestrictionRestrictionArrayOutput 

type ScheduleRotationTimeRestrictionRestrictionArrayOutput struct{ *pulumi.OutputState }

func (ScheduleRotationTimeRestrictionRestrictionArrayOutput) ElementType 

func (ScheduleRotationTimeRestrictionRestrictionArrayOutput) ElementType() reflect.Type

func (ScheduleRotationTimeRestrictionRestrictionArrayOutput) Index 

func (o ScheduleRotationTimeRestrictionRestrictionArrayOutput) Index(i pulumi.IntInput) ScheduleRotationTimeRestrictionRestrictionOutput

func (ScheduleRotationTimeRestrictionRestrictionArrayOutput) ToScheduleRotationTimeRestrictionRestrictionArrayOutput 

func (o ScheduleRotationTimeRestrictionRestrictionArrayOutput) ToScheduleRotationTimeRestrictionRestrictionArrayOutput() ScheduleRotationTimeRestrictionRestrictionArrayOutput

func (ScheduleRotationTimeRestrictionRestrictionArrayOutput) ToScheduleRotationTimeRestrictionRestrictionArrayOutputWithContext 

func (o ScheduleRotationTimeRestrictionRestrictionArrayOutput) ToScheduleRotationTimeRestrictionRestrictionArrayOutputWithContext(ctx context.Context) ScheduleRotationTimeRestrictionRestrictionArrayOutput

type ScheduleRotationTimeRestrictionRestrictionInput 

type ScheduleRotationTimeRestrictionRestrictionInput interface {
	pulumi.Input

	ToScheduleRotationTimeRestrictionRestrictionOutput() ScheduleRotationTimeRestrictionRestrictionOutput
	ToScheduleRotationTimeRestrictionRestrictionOutputWithContext(context.Context) ScheduleRotationTimeRestrictionRestrictionOutput
}

ScheduleRotationTimeRestrictionRestrictionInput is an input type that accepts ScheduleRotationTimeRestrictionRestrictionArgs and ScheduleRotationTimeRestrictionRestrictionOutput values. You can construct a concrete instance of `ScheduleRotationTimeRestrictionRestrictionInput` via: 

ScheduleRotationTimeRestrictionRestrictionArgs{...}

type ScheduleRotationTimeRestrictionRestrictionList added in v1.1.7 

type ScheduleRotationTimeRestrictionRestrictionList struct {
	EndDay    string `pulumi:"endDay"`
	EndHour   int    `pulumi:"endHour"`
	EndMin    int    `pulumi:"endMin"`
	StartDay  string `pulumi:"startDay"`
	StartHour int    `pulumi:"startHour"`
	StartMin  int    `pulumi:"startMin"`
}

type ScheduleRotationTimeRestrictionRestrictionListArgs added in v1.1.7 

type ScheduleRotationTimeRestrictionRestrictionListArgs struct {
	EndDay    pulumi.StringInput `pulumi:"endDay"`
	EndHour   pulumi.IntInput    `pulumi:"endHour"`
	EndMin    pulumi.IntInput    `pulumi:"endMin"`
	StartDay  pulumi.StringInput `pulumi:"startDay"`
	StartHour pulumi.IntInput    `pulumi:"startHour"`
	StartMin  pulumi.IntInput    `pulumi:"startMin"`
}

func (ScheduleRotationTimeRestrictionRestrictionListArgs) ElementType added in v1.1.7 

func (ScheduleRotationTimeRestrictionRestrictionListArgs) ElementType() reflect.Type

func (ScheduleRotationTimeRestrictionRestrictionListArgs) ToScheduleRotationTimeRestrictionRestrictionListOutput added in v1.1.7 

func (i ScheduleRotationTimeRestrictionRestrictionListArgs) ToScheduleRotationTimeRestrictionRestrictionListOutput() ScheduleRotationTimeRestrictionRestrictionListOutput

func (ScheduleRotationTimeRestrictionRestrictionListArgs) ToScheduleRotationTimeRestrictionRestrictionListOutputWithContext added in v1.1.7 

func (i ScheduleRotationTimeRestrictionRestrictionListArgs) ToScheduleRotationTimeRestrictionRestrictionListOutputWithContext(ctx context.Context) ScheduleRotationTimeRestrictionRestrictionListOutput

type ScheduleRotationTimeRestrictionRestrictionListArray added in v1.1.7 

type ScheduleRotationTimeRestrictionRestrictionListArray []ScheduleRotationTimeRestrictionRestrictionListInput

func (ScheduleRotationTimeRestrictionRestrictionListArray) ElementType added in v1.1.7 

func (ScheduleRotationTimeRestrictionRestrictionListArray) ElementType() reflect.Type

func (ScheduleRotationTimeRestrictionRestrictionListArray) ToScheduleRotationTimeRestrictionRestrictionListArrayOutput added in v1.1.7 

func (i ScheduleRotationTimeRestrictionRestrictionListArray) ToScheduleRotationTimeRestrictionRestrictionListArrayOutput() ScheduleRotationTimeRestrictionRestrictionListArrayOutput

func (ScheduleRotationTimeRestrictionRestrictionListArray) ToScheduleRotationTimeRestrictionRestrictionListArrayOutputWithContext added in v1.1.7 

func (i ScheduleRotationTimeRestrictionRestrictionListArray) ToScheduleRotationTimeRestrictionRestrictionListArrayOutputWithContext(ctx context.Context) ScheduleRotationTimeRestrictionRestrictionListArrayOutput

type ScheduleRotationTimeRestrictionRestrictionListArrayInput added in v1.1.7 

type ScheduleRotationTimeRestrictionRestrictionListArrayInput interface {
	pulumi.Input

	ToScheduleRotationTimeRestrictionRestrictionListArrayOutput() ScheduleRotationTimeRestrictionRestrictionListArrayOutput
	ToScheduleRotationTimeRestrictionRestrictionListArrayOutputWithContext(context.Context) ScheduleRotationTimeRestrictionRestrictionListArrayOutput
}

ScheduleRotationTimeRestrictionRestrictionListArrayInput is an input type that accepts ScheduleRotationTimeRestrictionRestrictionListArray and ScheduleRotationTimeRestrictionRestrictionListArrayOutput values. You can construct a concrete instance of `ScheduleRotationTimeRestrictionRestrictionListArrayInput` via: 

ScheduleRotationTimeRestrictionRestrictionListArray{ ScheduleRotationTimeRestrictionRestrictionListArgs{...} }

type ScheduleRotationTimeRestrictionRestrictionListArrayOutput added in v1.1.7 

type ScheduleRotationTimeRestrictionRestrictionListArrayOutput struct{ *pulumi.OutputState }

func (ScheduleRotationTimeRestrictionRestrictionListArrayOutput) ElementType added in v1.1.7 

func (ScheduleRotationTimeRestrictionRestrictionListArrayOutput) ElementType() reflect.Type

func (ScheduleRotationTimeRestrictionRestrictionListArrayOutput) Index added in v1.1.7 

func (o ScheduleRotationTimeRestrictionRestrictionListArrayOutput) Index(i pulumi.IntInput) ScheduleRotationTimeRestrictionRestrictionListOutput

func (ScheduleRotationTimeRestrictionRestrictionListArrayOutput) ToScheduleRotationTimeRestrictionRestrictionListArrayOutput added in v1.1.7 

func (o ScheduleRotationTimeRestrictionRestrictionListArrayOutput) ToScheduleRotationTimeRestrictionRestrictionListArrayOutput() ScheduleRotationTimeRestrictionRestrictionListArrayOutput

func (ScheduleRotationTimeRestrictionRestrictionListArrayOutput) ToScheduleRotationTimeRestrictionRestrictionListArrayOutputWithContext added in v1.1.7 

func (o ScheduleRotationTimeRestrictionRestrictionListArrayOutput) ToScheduleRotationTimeRestrictionRestrictionListArrayOutputWithContext(ctx context.Context) ScheduleRotationTimeRestrictionRestrictionListArrayOutput

type ScheduleRotationTimeRestrictionRestrictionListInput added in v1.1.7 

type ScheduleRotationTimeRestrictionRestrictionListInput interface {
	pulumi.Input

	ToScheduleRotationTimeRestrictionRestrictionListOutput() ScheduleRotationTimeRestrictionRestrictionListOutput
	ToScheduleRotationTimeRestrictionRestrictionListOutputWithContext(context.Context) ScheduleRotationTimeRestrictionRestrictionListOutput
}

ScheduleRotationTimeRestrictionRestrictionListInput is an input type that accepts ScheduleRotationTimeRestrictionRestrictionListArgs and ScheduleRotationTimeRestrictionRestrictionListOutput values. You can construct a concrete instance of `ScheduleRotationTimeRestrictionRestrictionListInput` via: 

ScheduleRotationTimeRestrictionRestrictionListArgs{...}

type ScheduleRotationTimeRestrictionRestrictionListOutput added in v1.1.7 

type ScheduleRotationTimeRestrictionRestrictionListOutput struct{ *pulumi.OutputState }

func (ScheduleRotationTimeRestrictionRestrictionListOutput) ElementType added in v1.1.7 

func (ScheduleRotationTimeRestrictionRestrictionListOutput) ElementType() reflect.Type

func (ScheduleRotationTimeRestrictionRestrictionListOutput) EndDay added in v1.1.7 

func (o ScheduleRotationTimeRestrictionRestrictionListOutput) EndDay() pulumi.StringOutput

func (ScheduleRotationTimeRestrictionRestrictionListOutput) EndHour added in v1.1.7 

func (o ScheduleRotationTimeRestrictionRestrictionListOutput) EndHour() pulumi.IntOutput

func (ScheduleRotationTimeRestrictionRestrictionListOutput) EndMin added in v1.1.7 

func (o ScheduleRotationTimeRestrictionRestrictionListOutput) EndMin() pulumi.IntOutput

func (ScheduleRotationTimeRestrictionRestrictionListOutput) StartDay added in v1.1.7 

func (o ScheduleRotationTimeRestrictionRestrictionListOutput) StartDay() pulumi.StringOutput

func (ScheduleRotationTimeRestrictionRestrictionListOutput) StartHour added in v1.1.7 

func (o ScheduleRotationTimeRestrictionRestrictionListOutput) StartHour() pulumi.IntOutput

func (ScheduleRotationTimeRestrictionRestrictionListOutput) StartMin added in v1.1.7 

func (o ScheduleRotationTimeRestrictionRestrictionListOutput) StartMin() pulumi.IntOutput

func (ScheduleRotationTimeRestrictionRestrictionListOutput) ToScheduleRotationTimeRestrictionRestrictionListOutput added in v1.1.7 

func (o ScheduleRotationTimeRestrictionRestrictionListOutput) ToScheduleRotationTimeRestrictionRestrictionListOutput() ScheduleRotationTimeRestrictionRestrictionListOutput

func (ScheduleRotationTimeRestrictionRestrictionListOutput) ToScheduleRotationTimeRestrictionRestrictionListOutputWithContext added in v1.1.7 

func (o ScheduleRotationTimeRestrictionRestrictionListOutput) ToScheduleRotationTimeRestrictionRestrictionListOutputWithContext(ctx context.Context) ScheduleRotationTimeRestrictionRestrictionListOutput

type ScheduleRotationTimeRestrictionRestrictionOutput 

type ScheduleRotationTimeRestrictionRestrictionOutput struct{ *pulumi.OutputState }

func (ScheduleRotationTimeRestrictionRestrictionOutput) ElementType 

func (ScheduleRotationTimeRestrictionRestrictionOutput) ElementType() reflect.Type

func (ScheduleRotationTimeRestrictionRestrictionOutput) EndHour 

func (o ScheduleRotationTimeRestrictionRestrictionOutput) EndHour() pulumi.IntOutput

func (ScheduleRotationTimeRestrictionRestrictionOutput) EndMin 

func (o ScheduleRotationTimeRestrictionRestrictionOutput) EndMin() pulumi.IntOutput

func (ScheduleRotationTimeRestrictionRestrictionOutput) StartHour 

func (o ScheduleRotationTimeRestrictionRestrictionOutput) StartHour() pulumi.IntOutput

func (ScheduleRotationTimeRestrictionRestrictionOutput) StartMin 

func (o ScheduleRotationTimeRestrictionRestrictionOutput) StartMin() pulumi.IntOutput

func (ScheduleRotationTimeRestrictionRestrictionOutput) ToScheduleRotationTimeRestrictionRestrictionOutput 

func (o ScheduleRotationTimeRestrictionRestrictionOutput) ToScheduleRotationTimeRestrictionRestrictionOutput() ScheduleRotationTimeRestrictionRestrictionOutput

func (ScheduleRotationTimeRestrictionRestrictionOutput) ToScheduleRotationTimeRestrictionRestrictionOutputWithContext 

func (o ScheduleRotationTimeRestrictionRestrictionOutput) ToScheduleRotationTimeRestrictionRestrictionOutputWithContext(ctx context.Context) ScheduleRotationTimeRestrictionRestrictionOutput

type ScheduleState 

type ScheduleState struct {
	// The description of schedule.
	Description pulumi.StringPtrInput
	// Enable/disable state of schedule
	Enabled pulumi.BoolPtrInput
	// Name of the schedule.
	Name pulumi.StringPtrInput
	// Owner team id of the schedule.
	OwnerTeamId pulumi.StringPtrInput
	// Timezone of schedule. Please look at [Supported Timezone Ids](https://docs.opsgenie.com/docs/supported-timezone-ids) for available timezones - Default: `America/New_York`.
	Timezone pulumi.StringPtrInput
}

func (ScheduleState) ElementType 

func (ScheduleState) ElementType() reflect.Type

type Service 

type Service struct {
	pulumi.CustomResourceState

	// Description field of the service that is generally used to provide a detailed information about the service.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Name of the service. This field must not be longer than 100 characters.
	Name pulumi.StringOutput `pulumi:"name"`
	// Tags for the service, with a maximum of 20 tags per service.
	Tags pulumi.StringArrayOutput `pulumi:"tags"`
	// Team id of the service. This field must not be longer than 512 characters.
	TeamId pulumi.StringOutput `pulumi:"teamId"`
}

Manages a Service within Opsgenie.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opsgenie.NewTeam(ctx, "payment", &opsgenie.TeamArgs{
			Name:        pulumi.String("example"),
			Description: pulumi.String("This team deals with all the things"),
		})
		if err != nil {
			return err
		}
		_, err = opsgenie.NewService(ctx, "this", &opsgenie.ServiceArgs{
			Name:   pulumi.String("Payment"),
			TeamId: pulumi.String("$opsgenie_team.payment.id"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Teams can be imported using the `service_id`, e.g.

```sh $ pulumi import opsgenie:index/service:Service this service_id` ```

func GetService 

func GetService(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ServiceState, opts ...pulumi.ResourceOption) (*Service, error)

GetService gets an existing Service resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewService 

func NewService(ctx *pulumi.Context,
	name string, args *ServiceArgs, opts ...pulumi.ResourceOption) (*Service, error)

NewService registers a new resource with the given unique name, arguments, and options.

func (*Service) ElementType 

func (*Service) ElementType() reflect.Type

func (*Service) ToServiceOutput 

func (i *Service) ToServiceOutput() ServiceOutput

func (*Service) ToServiceOutputWithContext 

func (i *Service) ToServiceOutputWithContext(ctx context.Context) ServiceOutput

type ServiceArgs 

type ServiceArgs struct {
	// Description field of the service that is generally used to provide a detailed information about the service.
	Description pulumi.StringPtrInput
	// Name of the service. This field must not be longer than 100 characters.
	Name pulumi.StringPtrInput
	// Tags for the service, with a maximum of 20 tags per service.
	Tags pulumi.StringArrayInput
	// Team id of the service. This field must not be longer than 512 characters.
	TeamId pulumi.StringInput
}

The set of arguments for constructing a Service resource.

func (ServiceArgs) ElementType 

func (ServiceArgs) ElementType() reflect.Type

type ServiceArray added in v0.1.3 

type ServiceArray []ServiceInput

func (ServiceArray) ElementType added in v0.1.3 

func (ServiceArray) ElementType() reflect.Type

func (ServiceArray) ToServiceArrayOutput added in v0.1.3 

func (i ServiceArray) ToServiceArrayOutput() ServiceArrayOutput

func (ServiceArray) ToServiceArrayOutputWithContext added in v0.1.3 

func (i ServiceArray) ToServiceArrayOutputWithContext(ctx context.Context) ServiceArrayOutput

type ServiceArrayInput added in v0.1.3 

type ServiceArrayInput interface {
	pulumi.Input

	ToServiceArrayOutput() ServiceArrayOutput
	ToServiceArrayOutputWithContext(context.Context) ServiceArrayOutput
}

ServiceArrayInput is an input type that accepts ServiceArray and ServiceArrayOutput values. You can construct a concrete instance of `ServiceArrayInput` via: 

ServiceArray{ ServiceArgs{...} }

type ServiceArrayOutput added in v0.1.3 

type ServiceArrayOutput struct{ *pulumi.OutputState }

func (ServiceArrayOutput) ElementType added in v0.1.3 

func (ServiceArrayOutput) ElementType() reflect.Type

func (ServiceArrayOutput) Index added in v0.1.3 

func (o ServiceArrayOutput) Index(i pulumi.IntInput) ServiceOutput

func (ServiceArrayOutput) ToServiceArrayOutput added in v0.1.3 

func (o ServiceArrayOutput) ToServiceArrayOutput() ServiceArrayOutput

func (ServiceArrayOutput) ToServiceArrayOutputWithContext added in v0.1.3 

func (o ServiceArrayOutput) ToServiceArrayOutputWithContext(ctx context.Context) ServiceArrayOutput

type ServiceIncidentRule 

type ServiceIncidentRule struct {
	pulumi.CustomResourceState

	// This is the rule configuration for this incident rule. This is a block, structure is documented below.
	IncidentRules ServiceIncidentRuleIncidentRuleArrayOutput `pulumi:"incidentRules"`
	// ID of the service associated
	ServiceId pulumi.StringOutput `pulumi:"serviceId"`
}

Manages a Service Incident Rule within Opsgenie.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		test, err := opsgenie.NewTeam(ctx, "test", &opsgenie.TeamArgs{
			Name:        pulumi.String("example-team"),
			Description: pulumi.String("This team deals with all the things"),
		})
		if err != nil {
			return err
		}
		testService, err := opsgenie.NewService(ctx, "test", &opsgenie.ServiceArgs{
			Name:   pulumi.String("example-service"),
			TeamId: test.ID(),
		})
		if err != nil {
			return err
		}
		_, err = opsgenie.NewServiceIncidentRule(ctx, "test", &opsgenie.ServiceIncidentRuleArgs{
			ServiceId: testService.ID(),
			IncidentRules: opsgenie.ServiceIncidentRuleIncidentRuleArray{
				&opsgenie.ServiceIncidentRuleIncidentRuleArgs{
					ConditionMatchType: pulumi.String("match-any-condition"),
					Conditions: opsgenie.ServiceIncidentRuleIncidentRuleConditionArray{
						&opsgenie.ServiceIncidentRuleIncidentRuleConditionArgs{
							Field:         pulumi.String("message"),
							Not:           pulumi.Bool(false),
							Operation:     pulumi.String("contains"),
							ExpectedValue: pulumi.String("expected1"),
						},
						&opsgenie.ServiceIncidentRuleIncidentRuleConditionArgs{
							Field:         pulumi.String("message"),
							Not:           pulumi.Bool(false),
							Operation:     pulumi.String("contains"),
							ExpectedValue: pulumi.String("expected2"),
						},
					},
					IncidentProperties: opsgenie.ServiceIncidentRuleIncidentRuleIncidentPropertyArray{
						&opsgenie.ServiceIncidentRuleIncidentRuleIncidentPropertyArgs{
							Message:  pulumi.String("This is a test message"),
							Priority: pulumi.String("P3"),
							StakeholderProperties: opsgenie.ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArray{
								&opsgenie.ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArgs{
									Message: pulumi.String("Message for stakeholders"),
									Enable:  pulumi.Bool(true),
								},
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Service Incident Rule can be imported using the `service_id/service_incident_rule_id`, e.g.

```sh $ pulumi import opsgenie:index/serviceIncidentRule:ServiceIncidentRule this service_id/service_incident_rule_id` ```

func GetServiceIncidentRule 

func GetServiceIncidentRule(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ServiceIncidentRuleState, opts ...pulumi.ResourceOption) (*ServiceIncidentRule, error)

GetServiceIncidentRule gets an existing ServiceIncidentRule resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewServiceIncidentRule 

func NewServiceIncidentRule(ctx *pulumi.Context,
	name string, args *ServiceIncidentRuleArgs, opts ...pulumi.ResourceOption) (*ServiceIncidentRule, error)

NewServiceIncidentRule registers a new resource with the given unique name, arguments, and options.

func (*ServiceIncidentRule) ElementType 

func (*ServiceIncidentRule) ElementType() reflect.Type

func (*ServiceIncidentRule) ToServiceIncidentRuleOutput 

func (i *ServiceIncidentRule) ToServiceIncidentRuleOutput() ServiceIncidentRuleOutput

func (*ServiceIncidentRule) ToServiceIncidentRuleOutputWithContext 

func (i *ServiceIncidentRule) ToServiceIncidentRuleOutputWithContext(ctx context.Context) ServiceIncidentRuleOutput

type ServiceIncidentRuleArgs 

type ServiceIncidentRuleArgs struct {
	// This is the rule configuration for this incident rule. This is a block, structure is documented below.
	IncidentRules ServiceIncidentRuleIncidentRuleArrayInput
	// ID of the service associated
	ServiceId pulumi.StringInput
}

The set of arguments for constructing a ServiceIncidentRule resource.

func (ServiceIncidentRuleArgs) ElementType 

func (ServiceIncidentRuleArgs) ElementType() reflect.Type

type ServiceIncidentRuleArray added in v0.1.3 

type ServiceIncidentRuleArray []ServiceIncidentRuleInput

func (ServiceIncidentRuleArray) ElementType added in v0.1.3 

func (ServiceIncidentRuleArray) ElementType() reflect.Type

func (ServiceIncidentRuleArray) ToServiceIncidentRuleArrayOutput added in v0.1.3 

func (i ServiceIncidentRuleArray) ToServiceIncidentRuleArrayOutput() ServiceIncidentRuleArrayOutput

func (ServiceIncidentRuleArray) ToServiceIncidentRuleArrayOutputWithContext added in v0.1.3 

func (i ServiceIncidentRuleArray) ToServiceIncidentRuleArrayOutputWithContext(ctx context.Context) ServiceIncidentRuleArrayOutput

type ServiceIncidentRuleArrayInput added in v0.1.3 

type ServiceIncidentRuleArrayInput interface {
	pulumi.Input

	ToServiceIncidentRuleArrayOutput() ServiceIncidentRuleArrayOutput
	ToServiceIncidentRuleArrayOutputWithContext(context.Context) ServiceIncidentRuleArrayOutput
}

ServiceIncidentRuleArrayInput is an input type that accepts ServiceIncidentRuleArray and ServiceIncidentRuleArrayOutput values. You can construct a concrete instance of `ServiceIncidentRuleArrayInput` via: 

ServiceIncidentRuleArray{ ServiceIncidentRuleArgs{...} }

type ServiceIncidentRuleArrayOutput added in v0.1.3 

type ServiceIncidentRuleArrayOutput struct{ *pulumi.OutputState }

func (ServiceIncidentRuleArrayOutput) ElementType added in v0.1.3 

func (ServiceIncidentRuleArrayOutput) ElementType() reflect.Type

func (ServiceIncidentRuleArrayOutput) Index added in v0.1.3 

func (o ServiceIncidentRuleArrayOutput) Index(i pulumi.IntInput) ServiceIncidentRuleOutput

func (ServiceIncidentRuleArrayOutput) ToServiceIncidentRuleArrayOutput added in v0.1.3 

func (o ServiceIncidentRuleArrayOutput) ToServiceIncidentRuleArrayOutput() ServiceIncidentRuleArrayOutput

func (ServiceIncidentRuleArrayOutput) ToServiceIncidentRuleArrayOutputWithContext added in v0.1.3 

func (o ServiceIncidentRuleArrayOutput) ToServiceIncidentRuleArrayOutputWithContext(ctx context.Context) ServiceIncidentRuleArrayOutput

type ServiceIncidentRuleIncidentRule 

type ServiceIncidentRuleIncidentRule struct {
	// A Condition type, supported types are: `match-all`, `match-any-condition`, `match-all-conditions`. Default: `match-all`
	ConditionMatchType *string `pulumi:"conditionMatchType"`
	// Conditions applied to incident. This is a block, structure is documented below.
	Conditions []ServiceIncidentRuleIncidentRuleCondition `pulumi:"conditions"`
	// Properties for incident rule. This is a block, structure is documented below.
	IncidentProperties []ServiceIncidentRuleIncidentRuleIncidentProperty `pulumi:"incidentProperties"`
}

type ServiceIncidentRuleIncidentRuleArgs 

type ServiceIncidentRuleIncidentRuleArgs struct {
	// A Condition type, supported types are: `match-all`, `match-any-condition`, `match-all-conditions`. Default: `match-all`
	ConditionMatchType pulumi.StringPtrInput `pulumi:"conditionMatchType"`
	// Conditions applied to incident. This is a block, structure is documented below.
	Conditions ServiceIncidentRuleIncidentRuleConditionArrayInput `pulumi:"conditions"`
	// Properties for incident rule. This is a block, structure is documented below.
	IncidentProperties ServiceIncidentRuleIncidentRuleIncidentPropertyArrayInput `pulumi:"incidentProperties"`
}

func (ServiceIncidentRuleIncidentRuleArgs) ElementType 

func (ServiceIncidentRuleIncidentRuleArgs) ElementType() reflect.Type

func (ServiceIncidentRuleIncidentRuleArgs) ToServiceIncidentRuleIncidentRuleOutput 

func (i ServiceIncidentRuleIncidentRuleArgs) ToServiceIncidentRuleIncidentRuleOutput() ServiceIncidentRuleIncidentRuleOutput

func (ServiceIncidentRuleIncidentRuleArgs) ToServiceIncidentRuleIncidentRuleOutputWithContext 

func (i ServiceIncidentRuleIncidentRuleArgs) ToServiceIncidentRuleIncidentRuleOutputWithContext(ctx context.Context) ServiceIncidentRuleIncidentRuleOutput

type ServiceIncidentRuleIncidentRuleArray 

type ServiceIncidentRuleIncidentRuleArray []ServiceIncidentRuleIncidentRuleInput

func (ServiceIncidentRuleIncidentRuleArray) ElementType 

func (ServiceIncidentRuleIncidentRuleArray) ElementType() reflect.Type

func (ServiceIncidentRuleIncidentRuleArray) ToServiceIncidentRuleIncidentRuleArrayOutput 

func (i ServiceIncidentRuleIncidentRuleArray) ToServiceIncidentRuleIncidentRuleArrayOutput() ServiceIncidentRuleIncidentRuleArrayOutput

func (ServiceIncidentRuleIncidentRuleArray) ToServiceIncidentRuleIncidentRuleArrayOutputWithContext 

func (i ServiceIncidentRuleIncidentRuleArray) ToServiceIncidentRuleIncidentRuleArrayOutputWithContext(ctx context.Context) ServiceIncidentRuleIncidentRuleArrayOutput

type ServiceIncidentRuleIncidentRuleArrayInput 

type ServiceIncidentRuleIncidentRuleArrayInput interface {
	pulumi.Input

	ToServiceIncidentRuleIncidentRuleArrayOutput() ServiceIncidentRuleIncidentRuleArrayOutput
	ToServiceIncidentRuleIncidentRuleArrayOutputWithContext(context.Context) ServiceIncidentRuleIncidentRuleArrayOutput
}

ServiceIncidentRuleIncidentRuleArrayInput is an input type that accepts ServiceIncidentRuleIncidentRuleArray and ServiceIncidentRuleIncidentRuleArrayOutput values. You can construct a concrete instance of `ServiceIncidentRuleIncidentRuleArrayInput` via: 

ServiceIncidentRuleIncidentRuleArray{ ServiceIncidentRuleIncidentRuleArgs{...} }

type ServiceIncidentRuleIncidentRuleArrayOutput 

type ServiceIncidentRuleIncidentRuleArrayOutput struct{ *pulumi.OutputState }

func (ServiceIncidentRuleIncidentRuleArrayOutput) ElementType 

func (ServiceIncidentRuleIncidentRuleArrayOutput) ElementType() reflect.Type

func (ServiceIncidentRuleIncidentRuleArrayOutput) Index 

func (o ServiceIncidentRuleIncidentRuleArrayOutput) Index(i pulumi.IntInput) ServiceIncidentRuleIncidentRuleOutput

func (ServiceIncidentRuleIncidentRuleArrayOutput) ToServiceIncidentRuleIncidentRuleArrayOutput 

func (o ServiceIncidentRuleIncidentRuleArrayOutput) ToServiceIncidentRuleIncidentRuleArrayOutput() ServiceIncidentRuleIncidentRuleArrayOutput

func (ServiceIncidentRuleIncidentRuleArrayOutput) ToServiceIncidentRuleIncidentRuleArrayOutputWithContext 

func (o ServiceIncidentRuleIncidentRuleArrayOutput) ToServiceIncidentRuleIncidentRuleArrayOutputWithContext(ctx context.Context) ServiceIncidentRuleIncidentRuleArrayOutput

type ServiceIncidentRuleIncidentRuleCondition 

type ServiceIncidentRuleIncidentRuleCondition struct {
	// User defined value that will be compared with alert field according to the operation. Default: empty string
	ExpectedValue *string `pulumi:"expectedValue"`
	// Specifies which alert field will be used in condition. Possible values are `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `recipients`, `teams`, `priority`
	Field string `pulumi:"field"`
	// If 'field' is set as 'extra-properties', key could be used for key-value pair
	Key *string `pulumi:"key"`
	// Indicates behaviour of the given operation. Default: false
	Not *bool `pulumi:"not"`
	// It is the operation that will be executed for the given field and key. Possible operations are `matches`, `contains`, `starts-with`, `ends-with`, `equals`, `contains-key`, `contains-value`, `greater-than`, `less-than`, `is-empty`, `equals-ignore-whitespace`.
	Operation string `pulumi:"operation"`
}

type ServiceIncidentRuleIncidentRuleConditionArgs 

type ServiceIncidentRuleIncidentRuleConditionArgs struct {
	// User defined value that will be compared with alert field according to the operation. Default: empty string
	ExpectedValue pulumi.StringPtrInput `pulumi:"expectedValue"`
	// Specifies which alert field will be used in condition. Possible values are `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `recipients`, `teams`, `priority`
	Field pulumi.StringInput `pulumi:"field"`
	// If 'field' is set as 'extra-properties', key could be used for key-value pair
	Key pulumi.StringPtrInput `pulumi:"key"`
	// Indicates behaviour of the given operation. Default: false
	Not pulumi.BoolPtrInput `pulumi:"not"`
	// It is the operation that will be executed for the given field and key. Possible operations are `matches`, `contains`, `starts-with`, `ends-with`, `equals`, `contains-key`, `contains-value`, `greater-than`, `less-than`, `is-empty`, `equals-ignore-whitespace`.
	Operation pulumi.StringInput `pulumi:"operation"`
}

func (ServiceIncidentRuleIncidentRuleConditionArgs) ElementType 

func (ServiceIncidentRuleIncidentRuleConditionArgs) ElementType() reflect.Type

func (ServiceIncidentRuleIncidentRuleConditionArgs) ToServiceIncidentRuleIncidentRuleConditionOutput 

func (i ServiceIncidentRuleIncidentRuleConditionArgs) ToServiceIncidentRuleIncidentRuleConditionOutput() ServiceIncidentRuleIncidentRuleConditionOutput

func (ServiceIncidentRuleIncidentRuleConditionArgs) ToServiceIncidentRuleIncidentRuleConditionOutputWithContext 

func (i ServiceIncidentRuleIncidentRuleConditionArgs) ToServiceIncidentRuleIncidentRuleConditionOutputWithContext(ctx context.Context) ServiceIncidentRuleIncidentRuleConditionOutput

type ServiceIncidentRuleIncidentRuleConditionArray 

type ServiceIncidentRuleIncidentRuleConditionArray []ServiceIncidentRuleIncidentRuleConditionInput

func (ServiceIncidentRuleIncidentRuleConditionArray) ElementType 

func (ServiceIncidentRuleIncidentRuleConditionArray) ElementType() reflect.Type

func (ServiceIncidentRuleIncidentRuleConditionArray) ToServiceIncidentRuleIncidentRuleConditionArrayOutput 

func (i ServiceIncidentRuleIncidentRuleConditionArray) ToServiceIncidentRuleIncidentRuleConditionArrayOutput() ServiceIncidentRuleIncidentRuleConditionArrayOutput

func (ServiceIncidentRuleIncidentRuleConditionArray) ToServiceIncidentRuleIncidentRuleConditionArrayOutputWithContext 

func (i ServiceIncidentRuleIncidentRuleConditionArray) ToServiceIncidentRuleIncidentRuleConditionArrayOutputWithContext(ctx context.Context) ServiceIncidentRuleIncidentRuleConditionArrayOutput

type ServiceIncidentRuleIncidentRuleConditionArrayInput 

type ServiceIncidentRuleIncidentRuleConditionArrayInput interface {
	pulumi.Input

	ToServiceIncidentRuleIncidentRuleConditionArrayOutput() ServiceIncidentRuleIncidentRuleConditionArrayOutput
	ToServiceIncidentRuleIncidentRuleConditionArrayOutputWithContext(context.Context) ServiceIncidentRuleIncidentRuleConditionArrayOutput
}

ServiceIncidentRuleIncidentRuleConditionArrayInput is an input type that accepts ServiceIncidentRuleIncidentRuleConditionArray and ServiceIncidentRuleIncidentRuleConditionArrayOutput values. You can construct a concrete instance of `ServiceIncidentRuleIncidentRuleConditionArrayInput` via: 

ServiceIncidentRuleIncidentRuleConditionArray{ ServiceIncidentRuleIncidentRuleConditionArgs{...} }

type ServiceIncidentRuleIncidentRuleConditionArrayOutput 

type ServiceIncidentRuleIncidentRuleConditionArrayOutput struct{ *pulumi.OutputState }

func (ServiceIncidentRuleIncidentRuleConditionArrayOutput) ElementType 

func (ServiceIncidentRuleIncidentRuleConditionArrayOutput) ElementType() reflect.Type

func (ServiceIncidentRuleIncidentRuleConditionArrayOutput) Index 

func (o ServiceIncidentRuleIncidentRuleConditionArrayOutput) Index(i pulumi.IntInput) ServiceIncidentRuleIncidentRuleConditionOutput

func (ServiceIncidentRuleIncidentRuleConditionArrayOutput) ToServiceIncidentRuleIncidentRuleConditionArrayOutput 

func (o ServiceIncidentRuleIncidentRuleConditionArrayOutput) ToServiceIncidentRuleIncidentRuleConditionArrayOutput() ServiceIncidentRuleIncidentRuleConditionArrayOutput

func (ServiceIncidentRuleIncidentRuleConditionArrayOutput) ToServiceIncidentRuleIncidentRuleConditionArrayOutputWithContext 

func (o ServiceIncidentRuleIncidentRuleConditionArrayOutput) ToServiceIncidentRuleIncidentRuleConditionArrayOutputWithContext(ctx context.Context) ServiceIncidentRuleIncidentRuleConditionArrayOutput

type ServiceIncidentRuleIncidentRuleConditionInput 

type ServiceIncidentRuleIncidentRuleConditionInput interface {
	pulumi.Input

	ToServiceIncidentRuleIncidentRuleConditionOutput() ServiceIncidentRuleIncidentRuleConditionOutput
	ToServiceIncidentRuleIncidentRuleConditionOutputWithContext(context.Context) ServiceIncidentRuleIncidentRuleConditionOutput
}

ServiceIncidentRuleIncidentRuleConditionInput is an input type that accepts ServiceIncidentRuleIncidentRuleConditionArgs and ServiceIncidentRuleIncidentRuleConditionOutput values. You can construct a concrete instance of `ServiceIncidentRuleIncidentRuleConditionInput` via: 

ServiceIncidentRuleIncidentRuleConditionArgs{...}

type ServiceIncidentRuleIncidentRuleConditionOutput 

type ServiceIncidentRuleIncidentRuleConditionOutput struct{ *pulumi.OutputState }

func (ServiceIncidentRuleIncidentRuleConditionOutput) ElementType 

func (ServiceIncidentRuleIncidentRuleConditionOutput) ElementType() reflect.Type

func (ServiceIncidentRuleIncidentRuleConditionOutput) ExpectedValue 

func (o ServiceIncidentRuleIncidentRuleConditionOutput) ExpectedValue() pulumi.StringPtrOutput

User defined value that will be compared with alert field according to the operation. Default: empty string

func (ServiceIncidentRuleIncidentRuleConditionOutput) Field 

func (o ServiceIncidentRuleIncidentRuleConditionOutput) Field() pulumi.StringOutput

Specifies which alert field will be used in condition. Possible values are `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `details`, `extra-properties`, `recipients`, `teams`, `priority`

func (ServiceIncidentRuleIncidentRuleConditionOutput) Key 

func (o ServiceIncidentRuleIncidentRuleConditionOutput) Key() pulumi.StringPtrOutput

If 'field' is set as 'extra-properties', key could be used for key-value pair

func (ServiceIncidentRuleIncidentRuleConditionOutput) Not 

func (o ServiceIncidentRuleIncidentRuleConditionOutput) Not() pulumi.BoolPtrOutput

Indicates behaviour of the given operation. Default: false

func (ServiceIncidentRuleIncidentRuleConditionOutput) Operation 

func (o ServiceIncidentRuleIncidentRuleConditionOutput) Operation() pulumi.StringOutput

It is the operation that will be executed for the given field and key. Possible operations are `matches`, `contains`, `starts-with`, `ends-with`, `equals`, `contains-key`, `contains-value`, `greater-than`, `less-than`, `is-empty`, `equals-ignore-whitespace`.

func (ServiceIncidentRuleIncidentRuleConditionOutput) ToServiceIncidentRuleIncidentRuleConditionOutput 

func (o ServiceIncidentRuleIncidentRuleConditionOutput) ToServiceIncidentRuleIncidentRuleConditionOutput() ServiceIncidentRuleIncidentRuleConditionOutput

func (ServiceIncidentRuleIncidentRuleConditionOutput) ToServiceIncidentRuleIncidentRuleConditionOutputWithContext 

func (o ServiceIncidentRuleIncidentRuleConditionOutput) ToServiceIncidentRuleIncidentRuleConditionOutputWithContext(ctx context.Context) ServiceIncidentRuleIncidentRuleConditionOutput

type ServiceIncidentRuleIncidentRuleIncidentProperty 

type ServiceIncidentRuleIncidentRuleIncidentProperty struct {
	// Description field of the incident rule.
	Description *string `pulumi:"description"`
	// Map of key-value pairs to use as custom properties of the alert.
	Details map[string]string `pulumi:"details"`
	// Message of the related incident rule.
	Message string `pulumi:"message"`
	// Priority level of the alert. Possible values are `P1`, `P2`, `P3`, `P4` and `P5`
	Priority string `pulumi:"priority"`
	// DEtails about stakeholders for this rule. This is a block, structure is documented below.
	StakeholderProperties []ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderProperty `pulumi:"stakeholderProperties"`
	// Tags of the alert.
	Tags []string `pulumi:"tags"`
}

type ServiceIncidentRuleIncidentRuleIncidentPropertyArgs 

type ServiceIncidentRuleIncidentRuleIncidentPropertyArgs struct {
	// Description field of the incident rule.
	Description pulumi.StringPtrInput `pulumi:"description"`
	// Map of key-value pairs to use as custom properties of the alert.
	Details pulumi.StringMapInput `pulumi:"details"`
	// Message of the related incident rule.
	Message pulumi.StringInput `pulumi:"message"`
	// Priority level of the alert. Possible values are `P1`, `P2`, `P3`, `P4` and `P5`
	Priority pulumi.StringInput `pulumi:"priority"`
	// DEtails about stakeholders for this rule. This is a block, structure is documented below.
	StakeholderProperties ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayInput `pulumi:"stakeholderProperties"`
	// Tags of the alert.
	Tags pulumi.StringArrayInput `pulumi:"tags"`
}

func (ServiceIncidentRuleIncidentRuleIncidentPropertyArgs) ElementType 

func (ServiceIncidentRuleIncidentRuleIncidentPropertyArgs) ElementType() reflect.Type

func (ServiceIncidentRuleIncidentRuleIncidentPropertyArgs) ToServiceIncidentRuleIncidentRuleIncidentPropertyOutput 

func (i ServiceIncidentRuleIncidentRuleIncidentPropertyArgs) ToServiceIncidentRuleIncidentRuleIncidentPropertyOutput() ServiceIncidentRuleIncidentRuleIncidentPropertyOutput

func (ServiceIncidentRuleIncidentRuleIncidentPropertyArgs) ToServiceIncidentRuleIncidentRuleIncidentPropertyOutputWithContext 

func (i ServiceIncidentRuleIncidentRuleIncidentPropertyArgs) ToServiceIncidentRuleIncidentRuleIncidentPropertyOutputWithContext(ctx context.Context) ServiceIncidentRuleIncidentRuleIncidentPropertyOutput

type ServiceIncidentRuleIncidentRuleIncidentPropertyArray 

type ServiceIncidentRuleIncidentRuleIncidentPropertyArray []ServiceIncidentRuleIncidentRuleIncidentPropertyInput

func (ServiceIncidentRuleIncidentRuleIncidentPropertyArray) ElementType 

func (ServiceIncidentRuleIncidentRuleIncidentPropertyArray) ElementType() reflect.Type

func (ServiceIncidentRuleIncidentRuleIncidentPropertyArray) ToServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutput 

func (i ServiceIncidentRuleIncidentRuleIncidentPropertyArray) ToServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutput() ServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutput

func (ServiceIncidentRuleIncidentRuleIncidentPropertyArray) ToServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutputWithContext 

func (i ServiceIncidentRuleIncidentRuleIncidentPropertyArray) ToServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutputWithContext(ctx context.Context) ServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutput

type ServiceIncidentRuleIncidentRuleIncidentPropertyArrayInput 

type ServiceIncidentRuleIncidentRuleIncidentPropertyArrayInput interface {
	pulumi.Input

	ToServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutput() ServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutput
	ToServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutputWithContext(context.Context) ServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutput
}

ServiceIncidentRuleIncidentRuleIncidentPropertyArrayInput is an input type that accepts ServiceIncidentRuleIncidentRuleIncidentPropertyArray and ServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutput values. You can construct a concrete instance of `ServiceIncidentRuleIncidentRuleIncidentPropertyArrayInput` via: 

ServiceIncidentRuleIncidentRuleIncidentPropertyArray{ ServiceIncidentRuleIncidentRuleIncidentPropertyArgs{...} }

type ServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutput 

type ServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutput struct{ *pulumi.OutputState }

func (ServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutput) ElementType 

func (ServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutput) ElementType() reflect.Type

func (ServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutput) Index 

func (o ServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutput) Index(i pulumi.IntInput) ServiceIncidentRuleIncidentRuleIncidentPropertyOutput

func (ServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutput) ToServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutput 

func (o ServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutput) ToServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutput() ServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutput

func (ServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutput) ToServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutputWithContext 

func (o ServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutput) ToServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutputWithContext(ctx context.Context) ServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutput

type ServiceIncidentRuleIncidentRuleIncidentPropertyInput 

type ServiceIncidentRuleIncidentRuleIncidentPropertyInput interface {
	pulumi.Input

	ToServiceIncidentRuleIncidentRuleIncidentPropertyOutput() ServiceIncidentRuleIncidentRuleIncidentPropertyOutput
	ToServiceIncidentRuleIncidentRuleIncidentPropertyOutputWithContext(context.Context) ServiceIncidentRuleIncidentRuleIncidentPropertyOutput
}

ServiceIncidentRuleIncidentRuleIncidentPropertyInput is an input type that accepts ServiceIncidentRuleIncidentRuleIncidentPropertyArgs and ServiceIncidentRuleIncidentRuleIncidentPropertyOutput values. You can construct a concrete instance of `ServiceIncidentRuleIncidentRuleIncidentPropertyInput` via: 

ServiceIncidentRuleIncidentRuleIncidentPropertyArgs{...}

type ServiceIncidentRuleIncidentRuleIncidentPropertyOutput 

type ServiceIncidentRuleIncidentRuleIncidentPropertyOutput struct{ *pulumi.OutputState }

func (ServiceIncidentRuleIncidentRuleIncidentPropertyOutput) Description 

func (o ServiceIncidentRuleIncidentRuleIncidentPropertyOutput) Description() pulumi.StringPtrOutput

Description field of the incident rule.

func (ServiceIncidentRuleIncidentRuleIncidentPropertyOutput) Details 

func (o ServiceIncidentRuleIncidentRuleIncidentPropertyOutput) Details() pulumi.StringMapOutput

Map of key-value pairs to use as custom properties of the alert.

func (ServiceIncidentRuleIncidentRuleIncidentPropertyOutput) ElementType 

func (ServiceIncidentRuleIncidentRuleIncidentPropertyOutput) ElementType() reflect.Type

func (ServiceIncidentRuleIncidentRuleIncidentPropertyOutput) Message 

func (o ServiceIncidentRuleIncidentRuleIncidentPropertyOutput) Message() pulumi.StringOutput

Message of the related incident rule.

func (ServiceIncidentRuleIncidentRuleIncidentPropertyOutput) Priority 

func (o ServiceIncidentRuleIncidentRuleIncidentPropertyOutput) Priority() pulumi.StringOutput

Priority level of the alert. Possible values are `P1`, `P2`, `P3`, `P4` and `P5`

func (ServiceIncidentRuleIncidentRuleIncidentPropertyOutput) StakeholderProperties 

func (o ServiceIncidentRuleIncidentRuleIncidentPropertyOutput) StakeholderProperties() ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutput

DEtails about stakeholders for this rule. This is a block, structure is documented below.

func (ServiceIncidentRuleIncidentRuleIncidentPropertyOutput) Tags 

func (o ServiceIncidentRuleIncidentRuleIncidentPropertyOutput) Tags() pulumi.StringArrayOutput

Tags of the alert.

func (ServiceIncidentRuleIncidentRuleIncidentPropertyOutput) ToServiceIncidentRuleIncidentRuleIncidentPropertyOutput 

func (o ServiceIncidentRuleIncidentRuleIncidentPropertyOutput) ToServiceIncidentRuleIncidentRuleIncidentPropertyOutput() ServiceIncidentRuleIncidentRuleIncidentPropertyOutput

func (ServiceIncidentRuleIncidentRuleIncidentPropertyOutput) ToServiceIncidentRuleIncidentRuleIncidentPropertyOutputWithContext 

func (o ServiceIncidentRuleIncidentRuleIncidentPropertyOutput) ToServiceIncidentRuleIncidentRuleIncidentPropertyOutputWithContext(ctx context.Context) ServiceIncidentRuleIncidentRuleIncidentPropertyOutput

type ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderProperty 

type ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderProperty struct {
	// Description that is generally used to provide a detailed information about the alert.
	Description *string `pulumi:"description"`
	// Option to enable stakeholder notifications.Default value is true.
	Enable *bool `pulumi:"enable"`
	// Message that is to be passed to audience that is generally used to provide a content information about the alert.
	Message string `pulumi:"message"`
}

type ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArgs 

type ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArgs struct {
	// Description that is generally used to provide a detailed information about the alert.
	Description pulumi.StringPtrInput `pulumi:"description"`
	// Option to enable stakeholder notifications.Default value is true.
	Enable pulumi.BoolPtrInput `pulumi:"enable"`
	// Message that is to be passed to audience that is generally used to provide a content information about the alert.
	Message pulumi.StringInput `pulumi:"message"`
}

func (ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArgs) ElementType 

func (ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArgs) ElementType() reflect.Type

func (ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArgs) ToServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput 

func (i ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArgs) ToServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput() ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput

func (ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArgs) ToServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutputWithContext 

func (i ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArgs) ToServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutputWithContext(ctx context.Context) ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput

type ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArray 

type ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArray []ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyInput

func (ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArray) ElementType 

func (ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArray) ElementType() reflect.Type

func (ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArray) ToServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutput 

func (i ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArray) ToServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutput() ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutput

func (ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArray) ToServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutputWithContext 

func (i ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArray) ToServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutputWithContext(ctx context.Context) ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutput

type ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayInput 

type ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayInput interface {
	pulumi.Input

	ToServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutput() ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutput
	ToServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutputWithContext(context.Context) ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutput
}

ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayInput is an input type that accepts ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArray and ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutput values. You can construct a concrete instance of `ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayInput` via: 

ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArray{ ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArgs{...} }

type ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutput 

type ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutput struct{ *pulumi.OutputState }

func (ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutput) ElementType 

func (ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutput) ElementType() reflect.Type

func (ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutput) Index 

func (o ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutput) Index(i pulumi.IntInput) ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput

func (ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutput) ToServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutput 

func (o ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutput) ToServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutput() ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutput

func (ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutput) ToServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutputWithContext 

func (o ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutput) ToServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutputWithContext(ctx context.Context) ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArrayOutput

type ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyInput 

type ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyInput interface {
	pulumi.Input

	ToServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput() ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput
	ToServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutputWithContext(context.Context) ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput
}

ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyInput is an input type that accepts ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArgs and ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput values. You can construct a concrete instance of `ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyInput` via: 

ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyArgs{...}

type ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput 

type ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput struct{ *pulumi.OutputState }

func (ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput) Description 

func (o ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput) Description() pulumi.StringPtrOutput

Description that is generally used to provide a detailed information about the alert.

func (ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput) ElementType 

func (ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput) ElementType() reflect.Type

func (ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput) Enable 

func (o ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput) Enable() pulumi.BoolPtrOutput

Option to enable stakeholder notifications.Default value is true.

func (ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput) Message 

func (o ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput) Message() pulumi.StringOutput

Message that is to be passed to audience that is generally used to provide a content information about the alert.

func (ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput) ToServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput 

func (o ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput) ToServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput() ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput

func (ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput) ToServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutputWithContext 

func (o ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput) ToServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutputWithContext(ctx context.Context) ServiceIncidentRuleIncidentRuleIncidentPropertyStakeholderPropertyOutput

type ServiceIncidentRuleIncidentRuleInput 

type ServiceIncidentRuleIncidentRuleInput interface {
	pulumi.Input

	ToServiceIncidentRuleIncidentRuleOutput() ServiceIncidentRuleIncidentRuleOutput
	ToServiceIncidentRuleIncidentRuleOutputWithContext(context.Context) ServiceIncidentRuleIncidentRuleOutput
}

ServiceIncidentRuleIncidentRuleInput is an input type that accepts ServiceIncidentRuleIncidentRuleArgs and ServiceIncidentRuleIncidentRuleOutput values. You can construct a concrete instance of `ServiceIncidentRuleIncidentRuleInput` via: 

ServiceIncidentRuleIncidentRuleArgs{...}

type ServiceIncidentRuleIncidentRuleOutput 

type ServiceIncidentRuleIncidentRuleOutput struct{ *pulumi.OutputState }

func (ServiceIncidentRuleIncidentRuleOutput) ConditionMatchType 

func (o ServiceIncidentRuleIncidentRuleOutput) ConditionMatchType() pulumi.StringPtrOutput

A Condition type, supported types are: `match-all`, `match-any-condition`, `match-all-conditions`. Default: `match-all`

func (ServiceIncidentRuleIncidentRuleOutput) Conditions 

func (o ServiceIncidentRuleIncidentRuleOutput) Conditions() ServiceIncidentRuleIncidentRuleConditionArrayOutput

Conditions applied to incident. This is a block, structure is documented below.

func (ServiceIncidentRuleIncidentRuleOutput) ElementType 

func (ServiceIncidentRuleIncidentRuleOutput) ElementType() reflect.Type

func (ServiceIncidentRuleIncidentRuleOutput) IncidentProperties 

func (o ServiceIncidentRuleIncidentRuleOutput) IncidentProperties() ServiceIncidentRuleIncidentRuleIncidentPropertyArrayOutput

Properties for incident rule. This is a block, structure is documented below.

func (ServiceIncidentRuleIncidentRuleOutput) ToServiceIncidentRuleIncidentRuleOutput 

func (o ServiceIncidentRuleIncidentRuleOutput) ToServiceIncidentRuleIncidentRuleOutput() ServiceIncidentRuleIncidentRuleOutput

func (ServiceIncidentRuleIncidentRuleOutput) ToServiceIncidentRuleIncidentRuleOutputWithContext 

func (o ServiceIncidentRuleIncidentRuleOutput) ToServiceIncidentRuleIncidentRuleOutputWithContext(ctx context.Context) ServiceIncidentRuleIncidentRuleOutput

type ServiceIncidentRuleInput 

type ServiceIncidentRuleInput interface {
	pulumi.Input

	ToServiceIncidentRuleOutput() ServiceIncidentRuleOutput
	ToServiceIncidentRuleOutputWithContext(ctx context.Context) ServiceIncidentRuleOutput
}

type ServiceIncidentRuleMap added in v0.1.3 

type ServiceIncidentRuleMap map[string]ServiceIncidentRuleInput

func (ServiceIncidentRuleMap) ElementType added in v0.1.3 

func (ServiceIncidentRuleMap) ElementType() reflect.Type

func (ServiceIncidentRuleMap) ToServiceIncidentRuleMapOutput added in v0.1.3 

func (i ServiceIncidentRuleMap) ToServiceIncidentRuleMapOutput() ServiceIncidentRuleMapOutput

func (ServiceIncidentRuleMap) ToServiceIncidentRuleMapOutputWithContext added in v0.1.3 

func (i ServiceIncidentRuleMap) ToServiceIncidentRuleMapOutputWithContext(ctx context.Context) ServiceIncidentRuleMapOutput

type ServiceIncidentRuleMapInput added in v0.1.3 

type ServiceIncidentRuleMapInput interface {
	pulumi.Input

	ToServiceIncidentRuleMapOutput() ServiceIncidentRuleMapOutput
	ToServiceIncidentRuleMapOutputWithContext(context.Context) ServiceIncidentRuleMapOutput
}

ServiceIncidentRuleMapInput is an input type that accepts ServiceIncidentRuleMap and ServiceIncidentRuleMapOutput values. You can construct a concrete instance of `ServiceIncidentRuleMapInput` via: 

ServiceIncidentRuleMap{ "key": ServiceIncidentRuleArgs{...} }

type ServiceIncidentRuleMapOutput added in v0.1.3 

type ServiceIncidentRuleMapOutput struct{ *pulumi.OutputState }

func (ServiceIncidentRuleMapOutput) ElementType added in v0.1.3 

func (ServiceIncidentRuleMapOutput) ElementType() reflect.Type

func (ServiceIncidentRuleMapOutput) MapIndex added in v0.1.3 

func (o ServiceIncidentRuleMapOutput) MapIndex(k pulumi.StringInput) ServiceIncidentRuleOutput

func (ServiceIncidentRuleMapOutput) ToServiceIncidentRuleMapOutput added in v0.1.3 

func (o ServiceIncidentRuleMapOutput) ToServiceIncidentRuleMapOutput() ServiceIncidentRuleMapOutput

func (ServiceIncidentRuleMapOutput) ToServiceIncidentRuleMapOutputWithContext added in v0.1.3 

func (o ServiceIncidentRuleMapOutput) ToServiceIncidentRuleMapOutputWithContext(ctx context.Context) ServiceIncidentRuleMapOutput

type ServiceIncidentRuleOutput 

type ServiceIncidentRuleOutput struct{ *pulumi.OutputState }

func (ServiceIncidentRuleOutput) ElementType 

func (ServiceIncidentRuleOutput) ElementType() reflect.Type

func (ServiceIncidentRuleOutput) IncidentRules added in v1.1.9 

func (o ServiceIncidentRuleOutput) IncidentRules() ServiceIncidentRuleIncidentRuleArrayOutput

This is the rule configuration for this incident rule. This is a block, structure is documented below.

func (ServiceIncidentRuleOutput) ServiceId added in v1.1.9 

func (o ServiceIncidentRuleOutput) ServiceId() pulumi.StringOutput

ID of the service associated

func (ServiceIncidentRuleOutput) ToServiceIncidentRuleOutput 

func (o ServiceIncidentRuleOutput) ToServiceIncidentRuleOutput() ServiceIncidentRuleOutput

func (ServiceIncidentRuleOutput) ToServiceIncidentRuleOutputWithContext 

func (o ServiceIncidentRuleOutput) ToServiceIncidentRuleOutputWithContext(ctx context.Context) ServiceIncidentRuleOutput

type ServiceIncidentRuleState 

type ServiceIncidentRuleState struct {
	// This is the rule configuration for this incident rule. This is a block, structure is documented below.
	IncidentRules ServiceIncidentRuleIncidentRuleArrayInput
	// ID of the service associated
	ServiceId pulumi.StringPtrInput
}

func (ServiceIncidentRuleState) ElementType 

func (ServiceIncidentRuleState) ElementType() reflect.Type

type ServiceInput 

type ServiceInput interface {
	pulumi.Input

	ToServiceOutput() ServiceOutput
	ToServiceOutputWithContext(ctx context.Context) ServiceOutput
}

type ServiceMap added in v0.1.3 

type ServiceMap map[string]ServiceInput

func (ServiceMap) ElementType added in v0.1.3 

func (ServiceMap) ElementType() reflect.Type

func (ServiceMap) ToServiceMapOutput added in v0.1.3 

func (i ServiceMap) ToServiceMapOutput() ServiceMapOutput

func (ServiceMap) ToServiceMapOutputWithContext added in v0.1.3 

func (i ServiceMap) ToServiceMapOutputWithContext(ctx context.Context) ServiceMapOutput

type ServiceMapInput added in v0.1.3 

type ServiceMapInput interface {
	pulumi.Input

	ToServiceMapOutput() ServiceMapOutput
	ToServiceMapOutputWithContext(context.Context) ServiceMapOutput
}

ServiceMapInput is an input type that accepts ServiceMap and ServiceMapOutput values. You can construct a concrete instance of `ServiceMapInput` via: 

ServiceMap{ "key": ServiceArgs{...} }

type ServiceMapOutput added in v0.1.3 

type ServiceMapOutput struct{ *pulumi.OutputState }

func (ServiceMapOutput) ElementType added in v0.1.3 

func (ServiceMapOutput) ElementType() reflect.Type

func (ServiceMapOutput) MapIndex added in v0.1.3 

func (o ServiceMapOutput) MapIndex(k pulumi.StringInput) ServiceOutput

func (ServiceMapOutput) ToServiceMapOutput added in v0.1.3 

func (o ServiceMapOutput) ToServiceMapOutput() ServiceMapOutput

func (ServiceMapOutput) ToServiceMapOutputWithContext added in v0.1.3 

func (o ServiceMapOutput) ToServiceMapOutputWithContext(ctx context.Context) ServiceMapOutput

type ServiceOutput 

type ServiceOutput struct{ *pulumi.OutputState }

func (ServiceOutput) Description added in v1.1.9 

func (o ServiceOutput) Description() pulumi.StringPtrOutput

Description field of the service that is generally used to provide a detailed information about the service.

func (ServiceOutput) ElementType 

func (ServiceOutput) ElementType() reflect.Type

func (ServiceOutput) Name added in v1.1.9 

func (o ServiceOutput) Name() pulumi.StringOutput

Name of the service. This field must not be longer than 100 characters.

func (ServiceOutput) Tags added in v1.3.1 

func (o ServiceOutput) Tags() pulumi.StringArrayOutput

Tags for the service, with a maximum of 20 tags per service.

func (ServiceOutput) TeamId added in v1.1.9 

func (o ServiceOutput) TeamId() pulumi.StringOutput

Team id of the service. This field must not be longer than 512 characters.

func (ServiceOutput) ToServiceOutput 

func (o ServiceOutput) ToServiceOutput() ServiceOutput

func (ServiceOutput) ToServiceOutputWithContext 

func (o ServiceOutput) ToServiceOutputWithContext(ctx context.Context) ServiceOutput

type ServiceState 

type ServiceState struct {
	// Description field of the service that is generally used to provide a detailed information about the service.
	Description pulumi.StringPtrInput
	// Name of the service. This field must not be longer than 100 characters.
	Name pulumi.StringPtrInput
	// Tags for the service, with a maximum of 20 tags per service.
	Tags pulumi.StringArrayInput
	// Team id of the service. This field must not be longer than 512 characters.
	TeamId pulumi.StringPtrInput
}

func (ServiceState) ElementType 

func (ServiceState) ElementType() reflect.Type

type Team 

type Team struct {
	pulumi.CustomResourceState

	// Set to true to remove default escalation and schedule for newly created team. **Be careful its also changes that team routing rule to None. That means you have to define routing rule as well**
	DeleteDefaultResources pulumi.BoolPtrOutput `pulumi:"deleteDefaultResources"`
	// A description for this team.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Set to true to ignore any configured member blocks and any team member added/updated/removed via OpsGenie web UI. Use this option e.g. to maintain membership via web UI only and use it only for new teams. Changing the value for existing teams might lead to strange behaviour. Default: `false`.
	IgnoreMembers pulumi.BoolPtrOutput `pulumi:"ignoreMembers"`
	// A Member block as documented below.
	Members TeamMemberArrayOutput `pulumi:"members"`
	// The name associated with this team. Opsgenie defines that this must not be longer than 100 characters.
	Name pulumi.StringOutput `pulumi:"name"`
}

Manages a Team within Opsgenie.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		first, err := opsgenie.NewUser(ctx, "first", &opsgenie.UserArgs{
			Username: pulumi.String("user@domain.com"),
			FullName: pulumi.String("name "),
			Role:     pulumi.String("User"),
		})
		if err != nil {
			return err
		}
		second, err := opsgenie.NewUser(ctx, "second", &opsgenie.UserArgs{
			Username: pulumi.String("test@domain.com"),
			FullName: pulumi.String("name "),
			Role:     pulumi.String("User"),
		})
		if err != nil {
			return err
		}
		_, err = opsgenie.NewTeam(ctx, "test", &opsgenie.TeamArgs{
			Name:        pulumi.String("example"),
			Description: pulumi.String("This team deals with all the things"),
			Members: opsgenie.TeamMemberArray{
				&opsgenie.TeamMemberArgs{
					Id:   first.ID(),
					Role: pulumi.String("admin"),
				},
				&opsgenie.TeamMemberArgs{
					Id:   second.ID(),
					Role: pulumi.String("user"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = opsgenie.NewTeam(ctx, "self-service", &opsgenie.TeamArgs{
			Name:                   pulumi.String("Self Service"),
			Description:            pulumi.String("Membership in this team is managed via OpsGenie web UI only"),
			IgnoreMembers:          pulumi.Bool(true),
			DeleteDefaultResources: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Teams can be imported using the `team_id`, e.g.

```sh $ pulumi import opsgenie:index/team:Team team1 team_id` ```

func GetTeam 

func GetTeam(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *TeamState, opts ...pulumi.ResourceOption) (*Team, error)

GetTeam gets an existing Team resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewTeam 

func NewTeam(ctx *pulumi.Context,
	name string, args *TeamArgs, opts ...pulumi.ResourceOption) (*Team, error)

NewTeam registers a new resource with the given unique name, arguments, and options.

func (*Team) ElementType 

func (*Team) ElementType() reflect.Type

func (*Team) ToTeamOutput 

func (i *Team) ToTeamOutput() TeamOutput

func (*Team) ToTeamOutputWithContext 

func (i *Team) ToTeamOutputWithContext(ctx context.Context) TeamOutput

type TeamArgs 

type TeamArgs struct {
	// Set to true to remove default escalation and schedule for newly created team. **Be careful its also changes that team routing rule to None. That means you have to define routing rule as well**
	DeleteDefaultResources pulumi.BoolPtrInput
	// A description for this team.
	Description pulumi.StringPtrInput
	// Set to true to ignore any configured member blocks and any team member added/updated/removed via OpsGenie web UI. Use this option e.g. to maintain membership via web UI only and use it only for new teams. Changing the value for existing teams might lead to strange behaviour. Default: `false`.
	IgnoreMembers pulumi.BoolPtrInput
	// A Member block as documented below.
	Members TeamMemberArrayInput
	// The name associated with this team. Opsgenie defines that this must not be longer than 100 characters.
	Name pulumi.StringPtrInput
}

The set of arguments for constructing a Team resource.

func (TeamArgs) ElementType 

func (TeamArgs) ElementType() reflect.Type

type TeamArray added in v0.1.3 

type TeamArray []TeamInput

func (TeamArray) ElementType added in v0.1.3 

func (TeamArray) ElementType() reflect.Type

func (TeamArray) ToTeamArrayOutput added in v0.1.3 

func (i TeamArray) ToTeamArrayOutput() TeamArrayOutput

func (TeamArray) ToTeamArrayOutputWithContext added in v0.1.3 

func (i TeamArray) ToTeamArrayOutputWithContext(ctx context.Context) TeamArrayOutput

type TeamArrayInput added in v0.1.3 

type TeamArrayInput interface {
	pulumi.Input

	ToTeamArrayOutput() TeamArrayOutput
	ToTeamArrayOutputWithContext(context.Context) TeamArrayOutput
}

TeamArrayInput is an input type that accepts TeamArray and TeamArrayOutput values. You can construct a concrete instance of `TeamArrayInput` via: 

TeamArray{ TeamArgs{...} }

type TeamArrayOutput added in v0.1.3 

type TeamArrayOutput struct{ *pulumi.OutputState }

func (TeamArrayOutput) ElementType added in v0.1.3 

func (TeamArrayOutput) ElementType() reflect.Type

func (TeamArrayOutput) Index added in v0.1.3 

func (o TeamArrayOutput) Index(i pulumi.IntInput) TeamOutput

func (TeamArrayOutput) ToTeamArrayOutput added in v0.1.3 

func (o TeamArrayOutput) ToTeamArrayOutput() TeamArrayOutput

func (TeamArrayOutput) ToTeamArrayOutputWithContext added in v0.1.3 

func (o TeamArrayOutput) ToTeamArrayOutputWithContext(ctx context.Context) TeamArrayOutput

type TeamInput 

type TeamInput interface {
	pulumi.Input

	ToTeamOutput() TeamOutput
	ToTeamOutputWithContext(ctx context.Context) TeamOutput
}

type TeamMap added in v0.1.3 

type TeamMap map[string]TeamInput

func (TeamMap) ElementType added in v0.1.3 

func (TeamMap) ElementType() reflect.Type

func (TeamMap) ToTeamMapOutput added in v0.1.3 

func (i TeamMap) ToTeamMapOutput() TeamMapOutput

func (TeamMap) ToTeamMapOutputWithContext added in v0.1.3 

func (i TeamMap) ToTeamMapOutputWithContext(ctx context.Context) TeamMapOutput

type TeamMapInput added in v0.1.3 

type TeamMapInput interface {
	pulumi.Input

	ToTeamMapOutput() TeamMapOutput
	ToTeamMapOutputWithContext(context.Context) TeamMapOutput
}

TeamMapInput is an input type that accepts TeamMap and TeamMapOutput values. You can construct a concrete instance of `TeamMapInput` via: 

TeamMap{ "key": TeamArgs{...} }

type TeamMapOutput added in v0.1.3 

type TeamMapOutput struct{ *pulumi.OutputState }

func (TeamMapOutput) ElementType added in v0.1.3 

func (TeamMapOutput) ElementType() reflect.Type

func (TeamMapOutput) MapIndex added in v0.1.3 

func (o TeamMapOutput) MapIndex(k pulumi.StringInput) TeamOutput

func (TeamMapOutput) ToTeamMapOutput added in v0.1.3 

func (o TeamMapOutput) ToTeamMapOutput() TeamMapOutput

func (TeamMapOutput) ToTeamMapOutputWithContext added in v0.1.3 

func (o TeamMapOutput) ToTeamMapOutputWithContext(ctx context.Context) TeamMapOutput

type TeamMember 

type TeamMember struct {
	// The UUID for the member to add to this Team.
	Id string `pulumi:"id"`
	// The role for the user within the Team - can be either `admin` or `user`. Default: `user`.
	Role     *string `pulumi:"role"`
	Username *string `pulumi:"username"`
}

type TeamMemberArgs 

type TeamMemberArgs struct {
	// The UUID for the member to add to this Team.
	Id pulumi.StringInput `pulumi:"id"`
	// The role for the user within the Team - can be either `admin` or `user`. Default: `user`.
	Role     pulumi.StringPtrInput `pulumi:"role"`
	Username pulumi.StringPtrInput `pulumi:"username"`
}

func (TeamMemberArgs) ElementType 

func (TeamMemberArgs) ElementType() reflect.Type

func (TeamMemberArgs) ToTeamMemberOutput 

func (i TeamMemberArgs) ToTeamMemberOutput() TeamMemberOutput

func (TeamMemberArgs) ToTeamMemberOutputWithContext 

func (i TeamMemberArgs) ToTeamMemberOutputWithContext(ctx context.Context) TeamMemberOutput

type TeamMemberArray 

type TeamMemberArray []TeamMemberInput

func (TeamMemberArray) ElementType 

func (TeamMemberArray) ElementType() reflect.Type

func (TeamMemberArray) ToTeamMemberArrayOutput 

func (i TeamMemberArray) ToTeamMemberArrayOutput() TeamMemberArrayOutput

func (TeamMemberArray) ToTeamMemberArrayOutputWithContext 

func (i TeamMemberArray) ToTeamMemberArrayOutputWithContext(ctx context.Context) TeamMemberArrayOutput

type TeamMemberArrayInput 

type TeamMemberArrayInput interface {
	pulumi.Input

	ToTeamMemberArrayOutput() TeamMemberArrayOutput
	ToTeamMemberArrayOutputWithContext(context.Context) TeamMemberArrayOutput
}

TeamMemberArrayInput is an input type that accepts TeamMemberArray and TeamMemberArrayOutput values. You can construct a concrete instance of `TeamMemberArrayInput` via: 

TeamMemberArray{ TeamMemberArgs{...} }

type TeamMemberArrayOutput 

type TeamMemberArrayOutput struct{ *pulumi.OutputState }

func (TeamMemberArrayOutput) ElementType 

func (TeamMemberArrayOutput) ElementType() reflect.Type

func (TeamMemberArrayOutput) Index 

func (o TeamMemberArrayOutput) Index(i pulumi.IntInput) TeamMemberOutput

func (TeamMemberArrayOutput) ToTeamMemberArrayOutput 

func (o TeamMemberArrayOutput) ToTeamMemberArrayOutput() TeamMemberArrayOutput

func (TeamMemberArrayOutput) ToTeamMemberArrayOutputWithContext 

func (o TeamMemberArrayOutput) ToTeamMemberArrayOutputWithContext(ctx context.Context) TeamMemberArrayOutput

type TeamMemberInput 

type TeamMemberInput interface {
	pulumi.Input

	ToTeamMemberOutput() TeamMemberOutput
	ToTeamMemberOutputWithContext(context.Context) TeamMemberOutput
}

TeamMemberInput is an input type that accepts TeamMemberArgs and TeamMemberOutput values. You can construct a concrete instance of `TeamMemberInput` via: 

TeamMemberArgs{...}

type TeamMemberOutput 

type TeamMemberOutput struct{ *pulumi.OutputState }

func (TeamMemberOutput) ElementType 

func (TeamMemberOutput) ElementType() reflect.Type

func (TeamMemberOutput) Id 

func (o TeamMemberOutput) Id() pulumi.StringOutput

The UUID for the member to add to this Team.

func (TeamMemberOutput) Role 

func (o TeamMemberOutput) Role() pulumi.StringPtrOutput

The role for the user within the Team - can be either `admin` or `user`. Default: `user`.

func (TeamMemberOutput) ToTeamMemberOutput 

func (o TeamMemberOutput) ToTeamMemberOutput() TeamMemberOutput

func (TeamMemberOutput) ToTeamMemberOutputWithContext 

func (o TeamMemberOutput) ToTeamMemberOutputWithContext(ctx context.Context) TeamMemberOutput

func (TeamMemberOutput) Username added in v1.3.1 

func (o TeamMemberOutput) Username() pulumi.StringPtrOutput

type TeamOutput 

type TeamOutput struct{ *pulumi.OutputState }

func (TeamOutput) DeleteDefaultResources added in v1.1.9 

func (o TeamOutput) DeleteDefaultResources() pulumi.BoolPtrOutput

Set to true to remove default escalation and schedule for newly created team. **Be careful its also changes that team routing rule to None. That means you have to define routing rule as well**

func (TeamOutput) Description added in v1.1.9 

func (o TeamOutput) Description() pulumi.StringPtrOutput

A description for this team.

func (TeamOutput) ElementType 

func (TeamOutput) ElementType() reflect.Type

func (TeamOutput) IgnoreMembers added in v1.1.9 

func (o TeamOutput) IgnoreMembers() pulumi.BoolPtrOutput

Set to true to ignore any configured member blocks and any team member added/updated/removed via OpsGenie web UI. Use this option e.g. to maintain membership via web UI only and use it only for new teams. Changing the value for existing teams might lead to strange behaviour. Default: `false`.

func (TeamOutput) Members added in v1.1.9 

func (o TeamOutput) Members() TeamMemberArrayOutput

A Member block as documented below.

func (TeamOutput) Name added in v1.1.9 

func (o TeamOutput) Name() pulumi.StringOutput

The name associated with this team. Opsgenie defines that this must not be longer than 100 characters.

func (TeamOutput) ToTeamOutput 

func (o TeamOutput) ToTeamOutput() TeamOutput

func (TeamOutput) ToTeamOutputWithContext 

func (o TeamOutput) ToTeamOutputWithContext(ctx context.Context) TeamOutput

type TeamRoutingRule 

type TeamRoutingRule struct {
	pulumi.CustomResourceState

	// You can refer Criteria for detailed information about criteria and its fields
	Criterias TeamRoutingRuleCriteriaArrayOutput `pulumi:"criterias"`
	// Only use when importing default routing rule
	IsDefault pulumi.BoolPtrOutput `pulumi:"isDefault"`
	// Name of the team routing rule
	Name pulumi.StringOutput `pulumi:"name"`
	// Target entity of schedule, escalation, or the reserved word none which will be notified in routing rule. The possible values are: `schedule`, `escalation`, `none`
	Notifies TeamRoutingRuleNotifyArrayOutput `pulumi:"notifies"`
	// The order of the team routing rule within the rules. order value is actually the index of the team routing rule whose minimum value is 0 and whose maximum value is n-1 (number of team routing rules is n)
	Order pulumi.IntPtrOutput `pulumi:"order"`
	// Id of the team owning the routing rule
	TeamId pulumi.StringOutput `pulumi:"teamId"`
	// You can refer Time Restriction for detailed information about time restriction and its fields.
	TimeRestrictions TeamRoutingRuleTimeRestrictionArrayOutput `pulumi:"timeRestrictions"`
	// Timezone of team routing rule. If timezone field is not given, account timezone is used as default.You can refer to Supported Locale IDs for available timezones
	Timezone pulumi.StringPtrOutput `pulumi:"timezone"`
}

Manages a Team Routing Rule within Opsgenie.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		test, err := opsgenie.NewSchedule(ctx, "test", &opsgenie.ScheduleArgs{
			Name:        pulumi.String("genieschedule"),
			Description: pulumi.String("schedule test"),
			Timezone:    pulumi.String("Europe/Rome"),
			Enabled:     pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		testTeam, err := opsgenie.NewTeam(ctx, "test", &opsgenie.TeamArgs{
			Name:        pulumi.String("example team"),
			Description: pulumi.String("This team deals with all the things"),
		})
		if err != nil {
			return err
		}
		_, err = opsgenie.NewTeamRoutingRule(ctx, "test", &opsgenie.TeamRoutingRuleArgs{
			Name:     pulumi.String("routing rule example"),
			TeamId:   testTeam.ID(),
			Order:    pulumi.Int(0),
			Timezone: pulumi.String("America/Los_Angeles"),
			Criterias: opsgenie.TeamRoutingRuleCriteriaArray{
				&opsgenie.TeamRoutingRuleCriteriaArgs{
					Type: pulumi.String("match-any-condition"),
					Conditions: opsgenie.TeamRoutingRuleCriteriaConditionArray{
						&opsgenie.TeamRoutingRuleCriteriaConditionArgs{
							Field:         pulumi.String("message"),
							Operation:     pulumi.String("contains"),
							ExpectedValue: pulumi.String("expected1"),
							Not:           pulumi.Bool(false),
						},
					},
				},
			},
			TimeRestrictions: opsgenie.TeamRoutingRuleTimeRestrictionArray{
				&opsgenie.TeamRoutingRuleTimeRestrictionArgs{
					Type: pulumi.String("weekday-and-time-of-day"),
					RestrictionList: opsgenie.TeamRoutingRuleTimeRestrictionRestrictionListArray{
						&opsgenie.TeamRoutingRuleTimeRestrictionRestrictionListArgs{
							StartDay:  pulumi.String("monday"),
							StartHour: pulumi.Int(8),
							StartMin:  pulumi.Int(0),
							EndDay:    pulumi.String("tuesday"),
							EndHour:   pulumi.Int(18),
							EndMin:    pulumi.Int(30),
						},
					},
				},
			},
			Notifies: opsgenie.TeamRoutingRuleNotifyArray{
				&opsgenie.TeamRoutingRuleNotifyArgs{
					Name: test.Name,
					Type: pulumi.String("schedule"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Team Routing Rules can be imported using the `team_id/routing_rule_id`, e.g.

```sh $ pulumi import opsgenie:index/teamRoutingRule:TeamRoutingRule ruletest team_id/routing_rule_id` ```

func GetTeamRoutingRule 

func GetTeamRoutingRule(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *TeamRoutingRuleState, opts ...pulumi.ResourceOption) (*TeamRoutingRule, error)

GetTeamRoutingRule gets an existing TeamRoutingRule resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewTeamRoutingRule 

func NewTeamRoutingRule(ctx *pulumi.Context,
	name string, args *TeamRoutingRuleArgs, opts ...pulumi.ResourceOption) (*TeamRoutingRule, error)

NewTeamRoutingRule registers a new resource with the given unique name, arguments, and options.

func (*TeamRoutingRule) ElementType 

func (*TeamRoutingRule) ElementType() reflect.Type

func (*TeamRoutingRule) ToTeamRoutingRuleOutput 

func (i *TeamRoutingRule) ToTeamRoutingRuleOutput() TeamRoutingRuleOutput

func (*TeamRoutingRule) ToTeamRoutingRuleOutputWithContext 

func (i *TeamRoutingRule) ToTeamRoutingRuleOutputWithContext(ctx context.Context) TeamRoutingRuleOutput

type TeamRoutingRuleArgs 

type TeamRoutingRuleArgs struct {
	// You can refer Criteria for detailed information about criteria and its fields
	Criterias TeamRoutingRuleCriteriaArrayInput
	// Only use when importing default routing rule
	IsDefault pulumi.BoolPtrInput
	// Name of the team routing rule
	Name pulumi.StringPtrInput
	// Target entity of schedule, escalation, or the reserved word none which will be notified in routing rule. The possible values are: `schedule`, `escalation`, `none`
	Notifies TeamRoutingRuleNotifyArrayInput
	// The order of the team routing rule within the rules. order value is actually the index of the team routing rule whose minimum value is 0 and whose maximum value is n-1 (number of team routing rules is n)
	Order pulumi.IntPtrInput
	// Id of the team owning the routing rule
	TeamId pulumi.StringInput
	// You can refer Time Restriction for detailed information about time restriction and its fields.
	TimeRestrictions TeamRoutingRuleTimeRestrictionArrayInput
	// Timezone of team routing rule. If timezone field is not given, account timezone is used as default.You can refer to Supported Locale IDs for available timezones
	Timezone pulumi.StringPtrInput
}

The set of arguments for constructing a TeamRoutingRule resource.

func (TeamRoutingRuleArgs) ElementType 

func (TeamRoutingRuleArgs) ElementType() reflect.Type

type TeamRoutingRuleArray added in v0.1.3 

type TeamRoutingRuleArray []TeamRoutingRuleInput

func (TeamRoutingRuleArray) ElementType added in v0.1.3 

func (TeamRoutingRuleArray) ElementType() reflect.Type

func (TeamRoutingRuleArray) ToTeamRoutingRuleArrayOutput added in v0.1.3 

func (i TeamRoutingRuleArray) ToTeamRoutingRuleArrayOutput() TeamRoutingRuleArrayOutput

func (TeamRoutingRuleArray) ToTeamRoutingRuleArrayOutputWithContext added in v0.1.3 

func (i TeamRoutingRuleArray) ToTeamRoutingRuleArrayOutputWithContext(ctx context.Context) TeamRoutingRuleArrayOutput

type TeamRoutingRuleArrayInput added in v0.1.3 

type TeamRoutingRuleArrayInput interface {
	pulumi.Input

	ToTeamRoutingRuleArrayOutput() TeamRoutingRuleArrayOutput
	ToTeamRoutingRuleArrayOutputWithContext(context.Context) TeamRoutingRuleArrayOutput
}

TeamRoutingRuleArrayInput is an input type that accepts TeamRoutingRuleArray and TeamRoutingRuleArrayOutput values. You can construct a concrete instance of `TeamRoutingRuleArrayInput` via: 

TeamRoutingRuleArray{ TeamRoutingRuleArgs{...} }

type TeamRoutingRuleArrayOutput added in v0.1.3 

type TeamRoutingRuleArrayOutput struct{ *pulumi.OutputState }

func (TeamRoutingRuleArrayOutput) ElementType added in v0.1.3 

func (TeamRoutingRuleArrayOutput) ElementType() reflect.Type

func (TeamRoutingRuleArrayOutput) Index added in v0.1.3 

func (o TeamRoutingRuleArrayOutput) Index(i pulumi.IntInput) TeamRoutingRuleOutput

func (TeamRoutingRuleArrayOutput) ToTeamRoutingRuleArrayOutput added in v0.1.3 

func (o TeamRoutingRuleArrayOutput) ToTeamRoutingRuleArrayOutput() TeamRoutingRuleArrayOutput

func (TeamRoutingRuleArrayOutput) ToTeamRoutingRuleArrayOutputWithContext added in v0.1.3 

func (o TeamRoutingRuleArrayOutput) ToTeamRoutingRuleArrayOutputWithContext(ctx context.Context) TeamRoutingRuleArrayOutput

type TeamRoutingRuleCriteria 

type TeamRoutingRuleCriteria struct {
	// List of conditions will be checked before applying team routing rule. This field declaration should be omitted if the criteria type is set to match-all.
	Conditions []TeamRoutingRuleCriteriaCondition `pulumi:"conditions"`
	// Type of the operation will be applied on conditions. Should be one of `match-all`, `match-any-condition` or `match-all-conditions`.
	Type string `pulumi:"type"`
}

type TeamRoutingRuleCriteriaArgs 

type TeamRoutingRuleCriteriaArgs struct {
	// List of conditions will be checked before applying team routing rule. This field declaration should be omitted if the criteria type is set to match-all.
	Conditions TeamRoutingRuleCriteriaConditionArrayInput `pulumi:"conditions"`
	// Type of the operation will be applied on conditions. Should be one of `match-all`, `match-any-condition` or `match-all-conditions`.
	Type pulumi.StringInput `pulumi:"type"`
}

func (TeamRoutingRuleCriteriaArgs) ElementType 

func (TeamRoutingRuleCriteriaArgs) ElementType() reflect.Type

func (TeamRoutingRuleCriteriaArgs) ToTeamRoutingRuleCriteriaOutput 

func (i TeamRoutingRuleCriteriaArgs) ToTeamRoutingRuleCriteriaOutput() TeamRoutingRuleCriteriaOutput

func (TeamRoutingRuleCriteriaArgs) ToTeamRoutingRuleCriteriaOutputWithContext 

func (i TeamRoutingRuleCriteriaArgs) ToTeamRoutingRuleCriteriaOutputWithContext(ctx context.Context) TeamRoutingRuleCriteriaOutput

type TeamRoutingRuleCriteriaArray 

type TeamRoutingRuleCriteriaArray []TeamRoutingRuleCriteriaInput

func (TeamRoutingRuleCriteriaArray) ElementType 

func (TeamRoutingRuleCriteriaArray) ElementType() reflect.Type

func (TeamRoutingRuleCriteriaArray) ToTeamRoutingRuleCriteriaArrayOutput 

func (i TeamRoutingRuleCriteriaArray) ToTeamRoutingRuleCriteriaArrayOutput() TeamRoutingRuleCriteriaArrayOutput

func (TeamRoutingRuleCriteriaArray) ToTeamRoutingRuleCriteriaArrayOutputWithContext 

func (i TeamRoutingRuleCriteriaArray) ToTeamRoutingRuleCriteriaArrayOutputWithContext(ctx context.Context) TeamRoutingRuleCriteriaArrayOutput

type TeamRoutingRuleCriteriaArrayInput 

type TeamRoutingRuleCriteriaArrayInput interface {
	pulumi.Input

	ToTeamRoutingRuleCriteriaArrayOutput() TeamRoutingRuleCriteriaArrayOutput
	ToTeamRoutingRuleCriteriaArrayOutputWithContext(context.Context) TeamRoutingRuleCriteriaArrayOutput
}

TeamRoutingRuleCriteriaArrayInput is an input type that accepts TeamRoutingRuleCriteriaArray and TeamRoutingRuleCriteriaArrayOutput values. You can construct a concrete instance of `TeamRoutingRuleCriteriaArrayInput` via: 

TeamRoutingRuleCriteriaArray{ TeamRoutingRuleCriteriaArgs{...} }

type TeamRoutingRuleCriteriaArrayOutput 

type TeamRoutingRuleCriteriaArrayOutput struct{ *pulumi.OutputState }

func (TeamRoutingRuleCriteriaArrayOutput) ElementType 

func (TeamRoutingRuleCriteriaArrayOutput) ElementType() reflect.Type

func (TeamRoutingRuleCriteriaArrayOutput) Index 

func (o TeamRoutingRuleCriteriaArrayOutput) Index(i pulumi.IntInput) TeamRoutingRuleCriteriaOutput

func (TeamRoutingRuleCriteriaArrayOutput) ToTeamRoutingRuleCriteriaArrayOutput 

func (o TeamRoutingRuleCriteriaArrayOutput) ToTeamRoutingRuleCriteriaArrayOutput() TeamRoutingRuleCriteriaArrayOutput

func (TeamRoutingRuleCriteriaArrayOutput) ToTeamRoutingRuleCriteriaArrayOutputWithContext 

func (o TeamRoutingRuleCriteriaArrayOutput) ToTeamRoutingRuleCriteriaArrayOutputWithContext(ctx context.Context) TeamRoutingRuleCriteriaArrayOutput

type TeamRoutingRuleCriteriaCondition 

type TeamRoutingRuleCriteriaCondition struct {
	ExpectedValue *string `pulumi:"expectedValue"`
	// Specifies which alert field will be used in condition. Possible values are `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `extra-properties`, `recipients`, `teams` or `priority`.
	Field string `pulumi:"field"`
	// If field is set as extra-properties, key could be used for key-value pair.
	Key *string `pulumi:"key"`
	// Indicates behaviour of the given operation. Default value is false.
	Not *bool `pulumi:"not"`
	// It is the operation that will be executed for the given field and key. Possible operations are `matches`, `contains`, `starts-with`, `ends-with`, `equals`, `contains-key`, `contains-value`, `greater-than`, `less-than`, `is-empty` and `equals-ignore-whitespace`.
	Operation string `pulumi:"operation"`
	// Order of the condition in conditions list.
	Order *int `pulumi:"order"`
}

type TeamRoutingRuleCriteriaConditionArgs 

type TeamRoutingRuleCriteriaConditionArgs struct {
	ExpectedValue pulumi.StringPtrInput `pulumi:"expectedValue"`
	// Specifies which alert field will be used in condition. Possible values are `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `extra-properties`, `recipients`, `teams` or `priority`.
	Field pulumi.StringInput `pulumi:"field"`
	// If field is set as extra-properties, key could be used for key-value pair.
	Key pulumi.StringPtrInput `pulumi:"key"`
	// Indicates behaviour of the given operation. Default value is false.
	Not pulumi.BoolPtrInput `pulumi:"not"`
	// It is the operation that will be executed for the given field and key. Possible operations are `matches`, `contains`, `starts-with`, `ends-with`, `equals`, `contains-key`, `contains-value`, `greater-than`, `less-than`, `is-empty` and `equals-ignore-whitespace`.
	Operation pulumi.StringInput `pulumi:"operation"`
	// Order of the condition in conditions list.
	Order pulumi.IntPtrInput `pulumi:"order"`
}

func (TeamRoutingRuleCriteriaConditionArgs) ElementType 

func (TeamRoutingRuleCriteriaConditionArgs) ElementType() reflect.Type

func (TeamRoutingRuleCriteriaConditionArgs) ToTeamRoutingRuleCriteriaConditionOutput 

func (i TeamRoutingRuleCriteriaConditionArgs) ToTeamRoutingRuleCriteriaConditionOutput() TeamRoutingRuleCriteriaConditionOutput

func (TeamRoutingRuleCriteriaConditionArgs) ToTeamRoutingRuleCriteriaConditionOutputWithContext 

func (i TeamRoutingRuleCriteriaConditionArgs) ToTeamRoutingRuleCriteriaConditionOutputWithContext(ctx context.Context) TeamRoutingRuleCriteriaConditionOutput

type TeamRoutingRuleCriteriaConditionArray 

type TeamRoutingRuleCriteriaConditionArray []TeamRoutingRuleCriteriaConditionInput

func (TeamRoutingRuleCriteriaConditionArray) ElementType 

func (TeamRoutingRuleCriteriaConditionArray) ElementType() reflect.Type

func (TeamRoutingRuleCriteriaConditionArray) ToTeamRoutingRuleCriteriaConditionArrayOutput 

func (i TeamRoutingRuleCriteriaConditionArray) ToTeamRoutingRuleCriteriaConditionArrayOutput() TeamRoutingRuleCriteriaConditionArrayOutput

func (TeamRoutingRuleCriteriaConditionArray) ToTeamRoutingRuleCriteriaConditionArrayOutputWithContext 

func (i TeamRoutingRuleCriteriaConditionArray) ToTeamRoutingRuleCriteriaConditionArrayOutputWithContext(ctx context.Context) TeamRoutingRuleCriteriaConditionArrayOutput

type TeamRoutingRuleCriteriaConditionArrayInput 

type TeamRoutingRuleCriteriaConditionArrayInput interface {
	pulumi.Input

	ToTeamRoutingRuleCriteriaConditionArrayOutput() TeamRoutingRuleCriteriaConditionArrayOutput
	ToTeamRoutingRuleCriteriaConditionArrayOutputWithContext(context.Context) TeamRoutingRuleCriteriaConditionArrayOutput
}

TeamRoutingRuleCriteriaConditionArrayInput is an input type that accepts TeamRoutingRuleCriteriaConditionArray and TeamRoutingRuleCriteriaConditionArrayOutput values. You can construct a concrete instance of `TeamRoutingRuleCriteriaConditionArrayInput` via: 

TeamRoutingRuleCriteriaConditionArray{ TeamRoutingRuleCriteriaConditionArgs{...} }

type TeamRoutingRuleCriteriaConditionArrayOutput 

type TeamRoutingRuleCriteriaConditionArrayOutput struct{ *pulumi.OutputState }

func (TeamRoutingRuleCriteriaConditionArrayOutput) ElementType 

func (TeamRoutingRuleCriteriaConditionArrayOutput) ElementType() reflect.Type

func (TeamRoutingRuleCriteriaConditionArrayOutput) Index 

func (o TeamRoutingRuleCriteriaConditionArrayOutput) Index(i pulumi.IntInput) TeamRoutingRuleCriteriaConditionOutput

func (TeamRoutingRuleCriteriaConditionArrayOutput) ToTeamRoutingRuleCriteriaConditionArrayOutput 

func (o TeamRoutingRuleCriteriaConditionArrayOutput) ToTeamRoutingRuleCriteriaConditionArrayOutput() TeamRoutingRuleCriteriaConditionArrayOutput

func (TeamRoutingRuleCriteriaConditionArrayOutput) ToTeamRoutingRuleCriteriaConditionArrayOutputWithContext 

func (o TeamRoutingRuleCriteriaConditionArrayOutput) ToTeamRoutingRuleCriteriaConditionArrayOutputWithContext(ctx context.Context) TeamRoutingRuleCriteriaConditionArrayOutput

type TeamRoutingRuleCriteriaConditionInput 

type TeamRoutingRuleCriteriaConditionInput interface {
	pulumi.Input

	ToTeamRoutingRuleCriteriaConditionOutput() TeamRoutingRuleCriteriaConditionOutput
	ToTeamRoutingRuleCriteriaConditionOutputWithContext(context.Context) TeamRoutingRuleCriteriaConditionOutput
}

TeamRoutingRuleCriteriaConditionInput is an input type that accepts TeamRoutingRuleCriteriaConditionArgs and TeamRoutingRuleCriteriaConditionOutput values. You can construct a concrete instance of `TeamRoutingRuleCriteriaConditionInput` via: 

TeamRoutingRuleCriteriaConditionArgs{...}

type TeamRoutingRuleCriteriaConditionOutput 

type TeamRoutingRuleCriteriaConditionOutput struct{ *pulumi.OutputState }

func (TeamRoutingRuleCriteriaConditionOutput) ElementType 

func (TeamRoutingRuleCriteriaConditionOutput) ElementType() reflect.Type

func (TeamRoutingRuleCriteriaConditionOutput) ExpectedValue 

func (o TeamRoutingRuleCriteriaConditionOutput) ExpectedValue() pulumi.StringPtrOutput

func (TeamRoutingRuleCriteriaConditionOutput) Field 

func (o TeamRoutingRuleCriteriaConditionOutput) Field() pulumi.StringOutput

Specifies which alert field will be used in condition. Possible values are `message`, `alias`, `description`, `source`, `entity`, `tags`, `actions`, `extra-properties`, `recipients`, `teams` or `priority`.

func (TeamRoutingRuleCriteriaConditionOutput) Key 

func (o TeamRoutingRuleCriteriaConditionOutput) Key() pulumi.StringPtrOutput

If field is set as extra-properties, key could be used for key-value pair.

func (TeamRoutingRuleCriteriaConditionOutput) Not 

func (o TeamRoutingRuleCriteriaConditionOutput) Not() pulumi.BoolPtrOutput

Indicates behaviour of the given operation. Default value is false.

func (TeamRoutingRuleCriteriaConditionOutput) Operation 

func (o TeamRoutingRuleCriteriaConditionOutput) Operation() pulumi.StringOutput

It is the operation that will be executed for the given field and key. Possible operations are `matches`, `contains`, `starts-with`, `ends-with`, `equals`, `contains-key`, `contains-value`, `greater-than`, `less-than`, `is-empty` and `equals-ignore-whitespace`.

func (TeamRoutingRuleCriteriaConditionOutput) Order 

func (o TeamRoutingRuleCriteriaConditionOutput) Order() pulumi.IntPtrOutput

Order of the condition in conditions list.

func (TeamRoutingRuleCriteriaConditionOutput) ToTeamRoutingRuleCriteriaConditionOutput 

func (o TeamRoutingRuleCriteriaConditionOutput) ToTeamRoutingRuleCriteriaConditionOutput() TeamRoutingRuleCriteriaConditionOutput

func (TeamRoutingRuleCriteriaConditionOutput) ToTeamRoutingRuleCriteriaConditionOutputWithContext 

func (o TeamRoutingRuleCriteriaConditionOutput) ToTeamRoutingRuleCriteriaConditionOutputWithContext(ctx context.Context) TeamRoutingRuleCriteriaConditionOutput

type TeamRoutingRuleCriteriaInput 

type TeamRoutingRuleCriteriaInput interface {
	pulumi.Input

	ToTeamRoutingRuleCriteriaOutput() TeamRoutingRuleCriteriaOutput
	ToTeamRoutingRuleCriteriaOutputWithContext(context.Context) TeamRoutingRuleCriteriaOutput
}

TeamRoutingRuleCriteriaInput is an input type that accepts TeamRoutingRuleCriteriaArgs and TeamRoutingRuleCriteriaOutput values. You can construct a concrete instance of `TeamRoutingRuleCriteriaInput` via: 

TeamRoutingRuleCriteriaArgs{...}

type TeamRoutingRuleCriteriaOutput 

type TeamRoutingRuleCriteriaOutput struct{ *pulumi.OutputState }

func (TeamRoutingRuleCriteriaOutput) Conditions 

func (o TeamRoutingRuleCriteriaOutput) Conditions() TeamRoutingRuleCriteriaConditionArrayOutput

List of conditions will be checked before applying team routing rule. This field declaration should be omitted if the criteria type is set to match-all.

func (TeamRoutingRuleCriteriaOutput) ElementType 

func (TeamRoutingRuleCriteriaOutput) ElementType() reflect.Type

func (TeamRoutingRuleCriteriaOutput) ToTeamRoutingRuleCriteriaOutput 

func (o TeamRoutingRuleCriteriaOutput) ToTeamRoutingRuleCriteriaOutput() TeamRoutingRuleCriteriaOutput

func (TeamRoutingRuleCriteriaOutput) ToTeamRoutingRuleCriteriaOutputWithContext 

func (o TeamRoutingRuleCriteriaOutput) ToTeamRoutingRuleCriteriaOutputWithContext(ctx context.Context) TeamRoutingRuleCriteriaOutput

func (TeamRoutingRuleCriteriaOutput) Type 

func (o TeamRoutingRuleCriteriaOutput) Type() pulumi.StringOutput

Type of the operation will be applied on conditions. Should be one of `match-all`, `match-any-condition` or `match-all-conditions`.

type TeamRoutingRuleInput 

type TeamRoutingRuleInput interface {
	pulumi.Input

	ToTeamRoutingRuleOutput() TeamRoutingRuleOutput
	ToTeamRoutingRuleOutputWithContext(ctx context.Context) TeamRoutingRuleOutput
}

type TeamRoutingRuleMap added in v0.1.3 

type TeamRoutingRuleMap map[string]TeamRoutingRuleInput

func (TeamRoutingRuleMap) ElementType added in v0.1.3 

func (TeamRoutingRuleMap) ElementType() reflect.Type

func (TeamRoutingRuleMap) ToTeamRoutingRuleMapOutput added in v0.1.3 

func (i TeamRoutingRuleMap) ToTeamRoutingRuleMapOutput() TeamRoutingRuleMapOutput

func (TeamRoutingRuleMap) ToTeamRoutingRuleMapOutputWithContext added in v0.1.3 

func (i TeamRoutingRuleMap) ToTeamRoutingRuleMapOutputWithContext(ctx context.Context) TeamRoutingRuleMapOutput

type TeamRoutingRuleMapInput added in v0.1.3 

type TeamRoutingRuleMapInput interface {
	pulumi.Input

	ToTeamRoutingRuleMapOutput() TeamRoutingRuleMapOutput
	ToTeamRoutingRuleMapOutputWithContext(context.Context) TeamRoutingRuleMapOutput
}

TeamRoutingRuleMapInput is an input type that accepts TeamRoutingRuleMap and TeamRoutingRuleMapOutput values. You can construct a concrete instance of `TeamRoutingRuleMapInput` via: 

TeamRoutingRuleMap{ "key": TeamRoutingRuleArgs{...} }

type TeamRoutingRuleMapOutput added in v0.1.3 

type TeamRoutingRuleMapOutput struct{ *pulumi.OutputState }

func (TeamRoutingRuleMapOutput) ElementType added in v0.1.3 

func (TeamRoutingRuleMapOutput) ElementType() reflect.Type

func (TeamRoutingRuleMapOutput) MapIndex added in v0.1.3 

func (o TeamRoutingRuleMapOutput) MapIndex(k pulumi.StringInput) TeamRoutingRuleOutput

func (TeamRoutingRuleMapOutput) ToTeamRoutingRuleMapOutput added in v0.1.3 

func (o TeamRoutingRuleMapOutput) ToTeamRoutingRuleMapOutput() TeamRoutingRuleMapOutput

func (TeamRoutingRuleMapOutput) ToTeamRoutingRuleMapOutputWithContext added in v0.1.3 

func (o TeamRoutingRuleMapOutput) ToTeamRoutingRuleMapOutputWithContext(ctx context.Context) TeamRoutingRuleMapOutput

type TeamRoutingRuleNotify 

type TeamRoutingRuleNotify struct {
	Id   *string `pulumi:"id"`
	Name *string `pulumi:"name"`
	Type string  `pulumi:"type"`
}

type TeamRoutingRuleNotifyArgs 

type TeamRoutingRuleNotifyArgs struct {
	Id   pulumi.StringPtrInput `pulumi:"id"`
	Name pulumi.StringPtrInput `pulumi:"name"`
	Type pulumi.StringInput    `pulumi:"type"`
}

func (TeamRoutingRuleNotifyArgs) ElementType 

func (TeamRoutingRuleNotifyArgs) ElementType() reflect.Type

func (TeamRoutingRuleNotifyArgs) ToTeamRoutingRuleNotifyOutput 

func (i TeamRoutingRuleNotifyArgs) ToTeamRoutingRuleNotifyOutput() TeamRoutingRuleNotifyOutput

func (TeamRoutingRuleNotifyArgs) ToTeamRoutingRuleNotifyOutputWithContext 

func (i TeamRoutingRuleNotifyArgs) ToTeamRoutingRuleNotifyOutputWithContext(ctx context.Context) TeamRoutingRuleNotifyOutput

type TeamRoutingRuleNotifyArray 

type TeamRoutingRuleNotifyArray []TeamRoutingRuleNotifyInput

func (TeamRoutingRuleNotifyArray) ElementType 

func (TeamRoutingRuleNotifyArray) ElementType() reflect.Type

func (TeamRoutingRuleNotifyArray) ToTeamRoutingRuleNotifyArrayOutput 

func (i TeamRoutingRuleNotifyArray) ToTeamRoutingRuleNotifyArrayOutput() TeamRoutingRuleNotifyArrayOutput

func (TeamRoutingRuleNotifyArray) ToTeamRoutingRuleNotifyArrayOutputWithContext 

func (i TeamRoutingRuleNotifyArray) ToTeamRoutingRuleNotifyArrayOutputWithContext(ctx context.Context) TeamRoutingRuleNotifyArrayOutput

type TeamRoutingRuleNotifyArrayInput 

type TeamRoutingRuleNotifyArrayInput interface {
	pulumi.Input

	ToTeamRoutingRuleNotifyArrayOutput() TeamRoutingRuleNotifyArrayOutput
	ToTeamRoutingRuleNotifyArrayOutputWithContext(context.Context) TeamRoutingRuleNotifyArrayOutput
}

TeamRoutingRuleNotifyArrayInput is an input type that accepts TeamRoutingRuleNotifyArray and TeamRoutingRuleNotifyArrayOutput values. You can construct a concrete instance of `TeamRoutingRuleNotifyArrayInput` via: 

TeamRoutingRuleNotifyArray{ TeamRoutingRuleNotifyArgs{...} }

type TeamRoutingRuleNotifyArrayOutput 

type TeamRoutingRuleNotifyArrayOutput struct{ *pulumi.OutputState }

func (TeamRoutingRuleNotifyArrayOutput) ElementType 

func (TeamRoutingRuleNotifyArrayOutput) ElementType() reflect.Type

func (TeamRoutingRuleNotifyArrayOutput) Index 

func (o TeamRoutingRuleNotifyArrayOutput) Index(i pulumi.IntInput) TeamRoutingRuleNotifyOutput

func (TeamRoutingRuleNotifyArrayOutput) ToTeamRoutingRuleNotifyArrayOutput 

func (o TeamRoutingRuleNotifyArrayOutput) ToTeamRoutingRuleNotifyArrayOutput() TeamRoutingRuleNotifyArrayOutput

func (TeamRoutingRuleNotifyArrayOutput) ToTeamRoutingRuleNotifyArrayOutputWithContext 

func (o TeamRoutingRuleNotifyArrayOutput) ToTeamRoutingRuleNotifyArrayOutputWithContext(ctx context.Context) TeamRoutingRuleNotifyArrayOutput

type TeamRoutingRuleNotifyInput 

type TeamRoutingRuleNotifyInput interface {
	pulumi.Input

	ToTeamRoutingRuleNotifyOutput() TeamRoutingRuleNotifyOutput
	ToTeamRoutingRuleNotifyOutputWithContext(context.Context) TeamRoutingRuleNotifyOutput
}

TeamRoutingRuleNotifyInput is an input type that accepts TeamRoutingRuleNotifyArgs and TeamRoutingRuleNotifyOutput values. You can construct a concrete instance of `TeamRoutingRuleNotifyInput` via: 

TeamRoutingRuleNotifyArgs{...}

type TeamRoutingRuleNotifyOutput 

type TeamRoutingRuleNotifyOutput struct{ *pulumi.OutputState }

func (TeamRoutingRuleNotifyOutput) ElementType 

func (TeamRoutingRuleNotifyOutput) ElementType() reflect.Type

func (TeamRoutingRuleNotifyOutput) Id 

func (o TeamRoutingRuleNotifyOutput) Id() pulumi.StringPtrOutput

func (TeamRoutingRuleNotifyOutput) Name 

func (o TeamRoutingRuleNotifyOutput) Name() pulumi.StringPtrOutput

func (TeamRoutingRuleNotifyOutput) ToTeamRoutingRuleNotifyOutput 

func (o TeamRoutingRuleNotifyOutput) ToTeamRoutingRuleNotifyOutput() TeamRoutingRuleNotifyOutput

func (TeamRoutingRuleNotifyOutput) ToTeamRoutingRuleNotifyOutputWithContext 

func (o TeamRoutingRuleNotifyOutput) ToTeamRoutingRuleNotifyOutputWithContext(ctx context.Context) TeamRoutingRuleNotifyOutput

func (TeamRoutingRuleNotifyOutput) Type 

func (o TeamRoutingRuleNotifyOutput) Type() pulumi.StringOutput

type TeamRoutingRuleOutput 

type TeamRoutingRuleOutput struct{ *pulumi.OutputState }

func (TeamRoutingRuleOutput) Criterias added in v1.1.9 

func (o TeamRoutingRuleOutput) Criterias() TeamRoutingRuleCriteriaArrayOutput

You can refer Criteria for detailed information about criteria and its fields

func (TeamRoutingRuleOutput) ElementType 

func (TeamRoutingRuleOutput) ElementType() reflect.Type

func (TeamRoutingRuleOutput) IsDefault added in v1.1.9 

func (o TeamRoutingRuleOutput) IsDefault() pulumi.BoolPtrOutput

Only use when importing default routing rule

func (TeamRoutingRuleOutput) Name added in v1.1.9 

func (o TeamRoutingRuleOutput) Name() pulumi.StringOutput

Name of the team routing rule

func (TeamRoutingRuleOutput) Notifies added in v1.1.9 

func (o TeamRoutingRuleOutput) Notifies() TeamRoutingRuleNotifyArrayOutput

Target entity of schedule, escalation, or the reserved word none which will be notified in routing rule. The possible values are: `schedule`, `escalation`, `none`

func (TeamRoutingRuleOutput) Order added in v1.1.9 

func (o TeamRoutingRuleOutput) Order() pulumi.IntPtrOutput

The order of the team routing rule within the rules. order value is actually the index of the team routing rule whose minimum value is 0 and whose maximum value is n-1 (number of team routing rules is n)

func (TeamRoutingRuleOutput) TeamId added in v1.1.9 

func (o TeamRoutingRuleOutput) TeamId() pulumi.StringOutput

Id of the team owning the routing rule

func (TeamRoutingRuleOutput) TimeRestrictions added in v1.1.9 

func (o TeamRoutingRuleOutput) TimeRestrictions() TeamRoutingRuleTimeRestrictionArrayOutput

You can refer Time Restriction for detailed information about time restriction and its fields.

func (TeamRoutingRuleOutput) Timezone added in v1.1.9 

func (o TeamRoutingRuleOutput) Timezone() pulumi.StringPtrOutput

Timezone of team routing rule. If timezone field is not given, account timezone is used as default.You can refer to Supported Locale IDs for available timezones

func (TeamRoutingRuleOutput) ToTeamRoutingRuleOutput 

func (o TeamRoutingRuleOutput) ToTeamRoutingRuleOutput() TeamRoutingRuleOutput

func (TeamRoutingRuleOutput) ToTeamRoutingRuleOutputWithContext 

func (o TeamRoutingRuleOutput) ToTeamRoutingRuleOutputWithContext(ctx context.Context) TeamRoutingRuleOutput

type TeamRoutingRuleState 

type TeamRoutingRuleState struct {
	// You can refer Criteria for detailed information about criteria and its fields
	Criterias TeamRoutingRuleCriteriaArrayInput
	// Only use when importing default routing rule
	IsDefault pulumi.BoolPtrInput
	// Name of the team routing rule
	Name pulumi.StringPtrInput
	// Target entity of schedule, escalation, or the reserved word none which will be notified in routing rule. The possible values are: `schedule`, `escalation`, `none`
	Notifies TeamRoutingRuleNotifyArrayInput
	// The order of the team routing rule within the rules. order value is actually the index of the team routing rule whose minimum value is 0 and whose maximum value is n-1 (number of team routing rules is n)
	Order pulumi.IntPtrInput
	// Id of the team owning the routing rule
	TeamId pulumi.StringPtrInput
	// You can refer Time Restriction for detailed information about time restriction and its fields.
	TimeRestrictions TeamRoutingRuleTimeRestrictionArrayInput
	// Timezone of team routing rule. If timezone field is not given, account timezone is used as default.You can refer to Supported Locale IDs for available timezones
	Timezone pulumi.StringPtrInput
}

func (TeamRoutingRuleState) ElementType 

func (TeamRoutingRuleState) ElementType() reflect.Type

type TeamRoutingRuleTimeRestriction 

type TeamRoutingRuleTimeRestriction struct {
	Restriction     []TeamRoutingRuleTimeRestrictionRestriction     `pulumi:"restriction"`
	RestrictionList []TeamRoutingRuleTimeRestrictionRestrictionList `pulumi:"restrictionList"`
	Type            string                                          `pulumi:"type"`
}

type TeamRoutingRuleTimeRestrictionArgs 

type TeamRoutingRuleTimeRestrictionArgs struct {
	Restriction     TeamRoutingRuleTimeRestrictionRestrictionArrayInput     `pulumi:"restriction"`
	RestrictionList TeamRoutingRuleTimeRestrictionRestrictionListArrayInput `pulumi:"restrictionList"`
	Type            pulumi.StringInput                                      `pulumi:"type"`
}

func (TeamRoutingRuleTimeRestrictionArgs) ElementType 

func (TeamRoutingRuleTimeRestrictionArgs) ElementType() reflect.Type

func (TeamRoutingRuleTimeRestrictionArgs) ToTeamRoutingRuleTimeRestrictionOutput 

func (i TeamRoutingRuleTimeRestrictionArgs) ToTeamRoutingRuleTimeRestrictionOutput() TeamRoutingRuleTimeRestrictionOutput

func (TeamRoutingRuleTimeRestrictionArgs) ToTeamRoutingRuleTimeRestrictionOutputWithContext 

func (i TeamRoutingRuleTimeRestrictionArgs) ToTeamRoutingRuleTimeRestrictionOutputWithContext(ctx context.Context) TeamRoutingRuleTimeRestrictionOutput

type TeamRoutingRuleTimeRestrictionArray 

type TeamRoutingRuleTimeRestrictionArray []TeamRoutingRuleTimeRestrictionInput

func (TeamRoutingRuleTimeRestrictionArray) ElementType 

func (TeamRoutingRuleTimeRestrictionArray) ElementType() reflect.Type

func (TeamRoutingRuleTimeRestrictionArray) ToTeamRoutingRuleTimeRestrictionArrayOutput 

func (i TeamRoutingRuleTimeRestrictionArray) ToTeamRoutingRuleTimeRestrictionArrayOutput() TeamRoutingRuleTimeRestrictionArrayOutput

func (TeamRoutingRuleTimeRestrictionArray) ToTeamRoutingRuleTimeRestrictionArrayOutputWithContext 

func (i TeamRoutingRuleTimeRestrictionArray) ToTeamRoutingRuleTimeRestrictionArrayOutputWithContext(ctx context.Context) TeamRoutingRuleTimeRestrictionArrayOutput

type TeamRoutingRuleTimeRestrictionArrayInput 

type TeamRoutingRuleTimeRestrictionArrayInput interface {
	pulumi.Input

	ToTeamRoutingRuleTimeRestrictionArrayOutput() TeamRoutingRuleTimeRestrictionArrayOutput
	ToTeamRoutingRuleTimeRestrictionArrayOutputWithContext(context.Context) TeamRoutingRuleTimeRestrictionArrayOutput
}

TeamRoutingRuleTimeRestrictionArrayInput is an input type that accepts TeamRoutingRuleTimeRestrictionArray and TeamRoutingRuleTimeRestrictionArrayOutput values. You can construct a concrete instance of `TeamRoutingRuleTimeRestrictionArrayInput` via: 

TeamRoutingRuleTimeRestrictionArray{ TeamRoutingRuleTimeRestrictionArgs{...} }

type TeamRoutingRuleTimeRestrictionArrayOutput 

type TeamRoutingRuleTimeRestrictionArrayOutput struct{ *pulumi.OutputState }

func (TeamRoutingRuleTimeRestrictionArrayOutput) ElementType 

func (TeamRoutingRuleTimeRestrictionArrayOutput) ElementType() reflect.Type

func (TeamRoutingRuleTimeRestrictionArrayOutput) Index 

func (o TeamRoutingRuleTimeRestrictionArrayOutput) Index(i pulumi.IntInput) TeamRoutingRuleTimeRestrictionOutput

func (TeamRoutingRuleTimeRestrictionArrayOutput) ToTeamRoutingRuleTimeRestrictionArrayOutput 

func (o TeamRoutingRuleTimeRestrictionArrayOutput) ToTeamRoutingRuleTimeRestrictionArrayOutput() TeamRoutingRuleTimeRestrictionArrayOutput

func (TeamRoutingRuleTimeRestrictionArrayOutput) ToTeamRoutingRuleTimeRestrictionArrayOutputWithContext 

func (o TeamRoutingRuleTimeRestrictionArrayOutput) ToTeamRoutingRuleTimeRestrictionArrayOutputWithContext(ctx context.Context) TeamRoutingRuleTimeRestrictionArrayOutput

type TeamRoutingRuleTimeRestrictionInput 

type TeamRoutingRuleTimeRestrictionInput interface {
	pulumi.Input

	ToTeamRoutingRuleTimeRestrictionOutput() TeamRoutingRuleTimeRestrictionOutput
	ToTeamRoutingRuleTimeRestrictionOutputWithContext(context.Context) TeamRoutingRuleTimeRestrictionOutput
}

TeamRoutingRuleTimeRestrictionInput is an input type that accepts TeamRoutingRuleTimeRestrictionArgs and TeamRoutingRuleTimeRestrictionOutput values. You can construct a concrete instance of `TeamRoutingRuleTimeRestrictionInput` via: 

TeamRoutingRuleTimeRestrictionArgs{...}

type TeamRoutingRuleTimeRestrictionOutput 

type TeamRoutingRuleTimeRestrictionOutput struct{ *pulumi.OutputState }

func (TeamRoutingRuleTimeRestrictionOutput) ElementType 

func (TeamRoutingRuleTimeRestrictionOutput) ElementType() reflect.Type

func (TeamRoutingRuleTimeRestrictionOutput) Restriction added in v1.1.6 

func (o TeamRoutingRuleTimeRestrictionOutput) Restriction() TeamRoutingRuleTimeRestrictionRestrictionArrayOutput

func (TeamRoutingRuleTimeRestrictionOutput) RestrictionList added in v1.1.7 

func (o TeamRoutingRuleTimeRestrictionOutput) RestrictionList() TeamRoutingRuleTimeRestrictionRestrictionListArrayOutput

func (TeamRoutingRuleTimeRestrictionOutput) ToTeamRoutingRuleTimeRestrictionOutput 

func (o TeamRoutingRuleTimeRestrictionOutput) ToTeamRoutingRuleTimeRestrictionOutput() TeamRoutingRuleTimeRestrictionOutput

func (TeamRoutingRuleTimeRestrictionOutput) ToTeamRoutingRuleTimeRestrictionOutputWithContext 

func (o TeamRoutingRuleTimeRestrictionOutput) ToTeamRoutingRuleTimeRestrictionOutputWithContext(ctx context.Context) TeamRoutingRuleTimeRestrictionOutput

func (TeamRoutingRuleTimeRestrictionOutput) Type 

func (o TeamRoutingRuleTimeRestrictionOutput) Type() pulumi.StringOutput

type TeamRoutingRuleTimeRestrictionRestriction 

type TeamRoutingRuleTimeRestrictionRestriction struct {
	EndHour   int `pulumi:"endHour"`
	EndMin    int `pulumi:"endMin"`
	StartHour int `pulumi:"startHour"`
	StartMin  int `pulumi:"startMin"`
}

type TeamRoutingRuleTimeRestrictionRestrictionArgs 

type TeamRoutingRuleTimeRestrictionRestrictionArgs struct {
	EndHour   pulumi.IntInput `pulumi:"endHour"`
	EndMin    pulumi.IntInput `pulumi:"endMin"`
	StartHour pulumi.IntInput `pulumi:"startHour"`
	StartMin  pulumi.IntInput `pulumi:"startMin"`
}

func (TeamRoutingRuleTimeRestrictionRestrictionArgs) ElementType 

func (TeamRoutingRuleTimeRestrictionRestrictionArgs) ElementType() reflect.Type

func (TeamRoutingRuleTimeRestrictionRestrictionArgs) ToTeamRoutingRuleTimeRestrictionRestrictionOutput 

func (i TeamRoutingRuleTimeRestrictionRestrictionArgs) ToTeamRoutingRuleTimeRestrictionRestrictionOutput() TeamRoutingRuleTimeRestrictionRestrictionOutput

func (TeamRoutingRuleTimeRestrictionRestrictionArgs) ToTeamRoutingRuleTimeRestrictionRestrictionOutputWithContext 

func (i TeamRoutingRuleTimeRestrictionRestrictionArgs) ToTeamRoutingRuleTimeRestrictionRestrictionOutputWithContext(ctx context.Context) TeamRoutingRuleTimeRestrictionRestrictionOutput

type TeamRoutingRuleTimeRestrictionRestrictionArray 

type TeamRoutingRuleTimeRestrictionRestrictionArray []TeamRoutingRuleTimeRestrictionRestrictionInput

func (TeamRoutingRuleTimeRestrictionRestrictionArray) ElementType 

func (TeamRoutingRuleTimeRestrictionRestrictionArray) ElementType() reflect.Type

func (TeamRoutingRuleTimeRestrictionRestrictionArray) ToTeamRoutingRuleTimeRestrictionRestrictionArrayOutput 

func (i TeamRoutingRuleTimeRestrictionRestrictionArray) ToTeamRoutingRuleTimeRestrictionRestrictionArrayOutput() TeamRoutingRuleTimeRestrictionRestrictionArrayOutput

func (TeamRoutingRuleTimeRestrictionRestrictionArray) ToTeamRoutingRuleTimeRestrictionRestrictionArrayOutputWithContext 

func (i TeamRoutingRuleTimeRestrictionRestrictionArray) ToTeamRoutingRuleTimeRestrictionRestrictionArrayOutputWithContext(ctx context.Context) TeamRoutingRuleTimeRestrictionRestrictionArrayOutput

type TeamRoutingRuleTimeRestrictionRestrictionArrayInput 

type TeamRoutingRuleTimeRestrictionRestrictionArrayInput interface {
	pulumi.Input

	ToTeamRoutingRuleTimeRestrictionRestrictionArrayOutput() TeamRoutingRuleTimeRestrictionRestrictionArrayOutput
	ToTeamRoutingRuleTimeRestrictionRestrictionArrayOutputWithContext(context.Context) TeamRoutingRuleTimeRestrictionRestrictionArrayOutput
}

TeamRoutingRuleTimeRestrictionRestrictionArrayInput is an input type that accepts TeamRoutingRuleTimeRestrictionRestrictionArray and TeamRoutingRuleTimeRestrictionRestrictionArrayOutput values. You can construct a concrete instance of `TeamRoutingRuleTimeRestrictionRestrictionArrayInput` via: 

TeamRoutingRuleTimeRestrictionRestrictionArray{ TeamRoutingRuleTimeRestrictionRestrictionArgs{...} }

type TeamRoutingRuleTimeRestrictionRestrictionArrayOutput 

type TeamRoutingRuleTimeRestrictionRestrictionArrayOutput struct{ *pulumi.OutputState }

func (TeamRoutingRuleTimeRestrictionRestrictionArrayOutput) ElementType 

func (TeamRoutingRuleTimeRestrictionRestrictionArrayOutput) ElementType() reflect.Type

func (TeamRoutingRuleTimeRestrictionRestrictionArrayOutput) Index 

func (o TeamRoutingRuleTimeRestrictionRestrictionArrayOutput) Index(i pulumi.IntInput) TeamRoutingRuleTimeRestrictionRestrictionOutput

func (TeamRoutingRuleTimeRestrictionRestrictionArrayOutput) ToTeamRoutingRuleTimeRestrictionRestrictionArrayOutput 

func (o TeamRoutingRuleTimeRestrictionRestrictionArrayOutput) ToTeamRoutingRuleTimeRestrictionRestrictionArrayOutput() TeamRoutingRuleTimeRestrictionRestrictionArrayOutput

func (TeamRoutingRuleTimeRestrictionRestrictionArrayOutput) ToTeamRoutingRuleTimeRestrictionRestrictionArrayOutputWithContext 

func (o TeamRoutingRuleTimeRestrictionRestrictionArrayOutput) ToTeamRoutingRuleTimeRestrictionRestrictionArrayOutputWithContext(ctx context.Context) TeamRoutingRuleTimeRestrictionRestrictionArrayOutput

type TeamRoutingRuleTimeRestrictionRestrictionInput 

type TeamRoutingRuleTimeRestrictionRestrictionInput interface {
	pulumi.Input

	ToTeamRoutingRuleTimeRestrictionRestrictionOutput() TeamRoutingRuleTimeRestrictionRestrictionOutput
	ToTeamRoutingRuleTimeRestrictionRestrictionOutputWithContext(context.Context) TeamRoutingRuleTimeRestrictionRestrictionOutput
}

TeamRoutingRuleTimeRestrictionRestrictionInput is an input type that accepts TeamRoutingRuleTimeRestrictionRestrictionArgs and TeamRoutingRuleTimeRestrictionRestrictionOutput values. You can construct a concrete instance of `TeamRoutingRuleTimeRestrictionRestrictionInput` via: 

TeamRoutingRuleTimeRestrictionRestrictionArgs{...}

type TeamRoutingRuleTimeRestrictionRestrictionList added in v1.1.7 

type TeamRoutingRuleTimeRestrictionRestrictionList struct {
	EndDay    string `pulumi:"endDay"`
	EndHour   int    `pulumi:"endHour"`
	EndMin    int    `pulumi:"endMin"`
	StartDay  string `pulumi:"startDay"`
	StartHour int    `pulumi:"startHour"`
	StartMin  int    `pulumi:"startMin"`
}

type TeamRoutingRuleTimeRestrictionRestrictionListArgs added in v1.1.7 

type TeamRoutingRuleTimeRestrictionRestrictionListArgs struct {
	EndDay    pulumi.StringInput `pulumi:"endDay"`
	EndHour   pulumi.IntInput    `pulumi:"endHour"`
	EndMin    pulumi.IntInput    `pulumi:"endMin"`
	StartDay  pulumi.StringInput `pulumi:"startDay"`
	StartHour pulumi.IntInput    `pulumi:"startHour"`
	StartMin  pulumi.IntInput    `pulumi:"startMin"`
}

func (TeamRoutingRuleTimeRestrictionRestrictionListArgs) ElementType added in v1.1.7 

func (TeamRoutingRuleTimeRestrictionRestrictionListArgs) ElementType() reflect.Type

func (TeamRoutingRuleTimeRestrictionRestrictionListArgs) ToTeamRoutingRuleTimeRestrictionRestrictionListOutput added in v1.1.7 

func (i TeamRoutingRuleTimeRestrictionRestrictionListArgs) ToTeamRoutingRuleTimeRestrictionRestrictionListOutput() TeamRoutingRuleTimeRestrictionRestrictionListOutput

func (TeamRoutingRuleTimeRestrictionRestrictionListArgs) ToTeamRoutingRuleTimeRestrictionRestrictionListOutputWithContext added in v1.1.7 

func (i TeamRoutingRuleTimeRestrictionRestrictionListArgs) ToTeamRoutingRuleTimeRestrictionRestrictionListOutputWithContext(ctx context.Context) TeamRoutingRuleTimeRestrictionRestrictionListOutput

type TeamRoutingRuleTimeRestrictionRestrictionListArray added in v1.1.7 

type TeamRoutingRuleTimeRestrictionRestrictionListArray []TeamRoutingRuleTimeRestrictionRestrictionListInput

func (TeamRoutingRuleTimeRestrictionRestrictionListArray) ElementType added in v1.1.7 

func (TeamRoutingRuleTimeRestrictionRestrictionListArray) ElementType() reflect.Type

func (TeamRoutingRuleTimeRestrictionRestrictionListArray) ToTeamRoutingRuleTimeRestrictionRestrictionListArrayOutput added in v1.1.7 

func (i TeamRoutingRuleTimeRestrictionRestrictionListArray) ToTeamRoutingRuleTimeRestrictionRestrictionListArrayOutput() TeamRoutingRuleTimeRestrictionRestrictionListArrayOutput

func (TeamRoutingRuleTimeRestrictionRestrictionListArray) ToTeamRoutingRuleTimeRestrictionRestrictionListArrayOutputWithContext added in v1.1.7 

func (i TeamRoutingRuleTimeRestrictionRestrictionListArray) ToTeamRoutingRuleTimeRestrictionRestrictionListArrayOutputWithContext(ctx context.Context) TeamRoutingRuleTimeRestrictionRestrictionListArrayOutput

type TeamRoutingRuleTimeRestrictionRestrictionListArrayInput added in v1.1.7 

type TeamRoutingRuleTimeRestrictionRestrictionListArrayInput interface {
	pulumi.Input

	ToTeamRoutingRuleTimeRestrictionRestrictionListArrayOutput() TeamRoutingRuleTimeRestrictionRestrictionListArrayOutput
	ToTeamRoutingRuleTimeRestrictionRestrictionListArrayOutputWithContext(context.Context) TeamRoutingRuleTimeRestrictionRestrictionListArrayOutput
}

TeamRoutingRuleTimeRestrictionRestrictionListArrayInput is an input type that accepts TeamRoutingRuleTimeRestrictionRestrictionListArray and TeamRoutingRuleTimeRestrictionRestrictionListArrayOutput values. You can construct a concrete instance of `TeamRoutingRuleTimeRestrictionRestrictionListArrayInput` via: 

TeamRoutingRuleTimeRestrictionRestrictionListArray{ TeamRoutingRuleTimeRestrictionRestrictionListArgs{...} }

type TeamRoutingRuleTimeRestrictionRestrictionListArrayOutput added in v1.1.7 

type TeamRoutingRuleTimeRestrictionRestrictionListArrayOutput struct{ *pulumi.OutputState }

func (TeamRoutingRuleTimeRestrictionRestrictionListArrayOutput) ElementType added in v1.1.7 

func (TeamRoutingRuleTimeRestrictionRestrictionListArrayOutput) ElementType() reflect.Type

func (TeamRoutingRuleTimeRestrictionRestrictionListArrayOutput) Index added in v1.1.7 

func (o TeamRoutingRuleTimeRestrictionRestrictionListArrayOutput) Index(i pulumi.IntInput) TeamRoutingRuleTimeRestrictionRestrictionListOutput

func (TeamRoutingRuleTimeRestrictionRestrictionListArrayOutput) ToTeamRoutingRuleTimeRestrictionRestrictionListArrayOutput added in v1.1.7 

func (o TeamRoutingRuleTimeRestrictionRestrictionListArrayOutput) ToTeamRoutingRuleTimeRestrictionRestrictionListArrayOutput() TeamRoutingRuleTimeRestrictionRestrictionListArrayOutput

func (TeamRoutingRuleTimeRestrictionRestrictionListArrayOutput) ToTeamRoutingRuleTimeRestrictionRestrictionListArrayOutputWithContext added in v1.1.7 

func (o TeamRoutingRuleTimeRestrictionRestrictionListArrayOutput) ToTeamRoutingRuleTimeRestrictionRestrictionListArrayOutputWithContext(ctx context.Context) TeamRoutingRuleTimeRestrictionRestrictionListArrayOutput

type TeamRoutingRuleTimeRestrictionRestrictionListInput added in v1.1.7 

type TeamRoutingRuleTimeRestrictionRestrictionListInput interface {
	pulumi.Input

	ToTeamRoutingRuleTimeRestrictionRestrictionListOutput() TeamRoutingRuleTimeRestrictionRestrictionListOutput
	ToTeamRoutingRuleTimeRestrictionRestrictionListOutputWithContext(context.Context) TeamRoutingRuleTimeRestrictionRestrictionListOutput
}

TeamRoutingRuleTimeRestrictionRestrictionListInput is an input type that accepts TeamRoutingRuleTimeRestrictionRestrictionListArgs and TeamRoutingRuleTimeRestrictionRestrictionListOutput values. You can construct a concrete instance of `TeamRoutingRuleTimeRestrictionRestrictionListInput` via: 

TeamRoutingRuleTimeRestrictionRestrictionListArgs{...}

type TeamRoutingRuleTimeRestrictionRestrictionListOutput added in v1.1.7 

type TeamRoutingRuleTimeRestrictionRestrictionListOutput struct{ *pulumi.OutputState }

func (TeamRoutingRuleTimeRestrictionRestrictionListOutput) ElementType added in v1.1.7 

func (TeamRoutingRuleTimeRestrictionRestrictionListOutput) ElementType() reflect.Type

func (TeamRoutingRuleTimeRestrictionRestrictionListOutput) EndDay added in v1.1.7 

func (o TeamRoutingRuleTimeRestrictionRestrictionListOutput) EndDay() pulumi.StringOutput

func (TeamRoutingRuleTimeRestrictionRestrictionListOutput) EndHour added in v1.1.7 

func (o TeamRoutingRuleTimeRestrictionRestrictionListOutput) EndHour() pulumi.IntOutput

func (TeamRoutingRuleTimeRestrictionRestrictionListOutput) EndMin added in v1.1.7 

func (o TeamRoutingRuleTimeRestrictionRestrictionListOutput) EndMin() pulumi.IntOutput

func (TeamRoutingRuleTimeRestrictionRestrictionListOutput) StartDay added in v1.1.7 

func (o TeamRoutingRuleTimeRestrictionRestrictionListOutput) StartDay() pulumi.StringOutput

func (TeamRoutingRuleTimeRestrictionRestrictionListOutput) StartHour added in v1.1.7 

func (o TeamRoutingRuleTimeRestrictionRestrictionListOutput) StartHour() pulumi.IntOutput

func (TeamRoutingRuleTimeRestrictionRestrictionListOutput) StartMin added in v1.1.7 

func (o TeamRoutingRuleTimeRestrictionRestrictionListOutput) StartMin() pulumi.IntOutput

func (TeamRoutingRuleTimeRestrictionRestrictionListOutput) ToTeamRoutingRuleTimeRestrictionRestrictionListOutput added in v1.1.7 

func (o TeamRoutingRuleTimeRestrictionRestrictionListOutput) ToTeamRoutingRuleTimeRestrictionRestrictionListOutput() TeamRoutingRuleTimeRestrictionRestrictionListOutput

func (TeamRoutingRuleTimeRestrictionRestrictionListOutput) ToTeamRoutingRuleTimeRestrictionRestrictionListOutputWithContext added in v1.1.7 

func (o TeamRoutingRuleTimeRestrictionRestrictionListOutput) ToTeamRoutingRuleTimeRestrictionRestrictionListOutputWithContext(ctx context.Context) TeamRoutingRuleTimeRestrictionRestrictionListOutput

type TeamRoutingRuleTimeRestrictionRestrictionOutput 

type TeamRoutingRuleTimeRestrictionRestrictionOutput struct{ *pulumi.OutputState }

func (TeamRoutingRuleTimeRestrictionRestrictionOutput) ElementType 

func (TeamRoutingRuleTimeRestrictionRestrictionOutput) ElementType() reflect.Type

func (TeamRoutingRuleTimeRestrictionRestrictionOutput) EndHour 

func (o TeamRoutingRuleTimeRestrictionRestrictionOutput) EndHour() pulumi.IntOutput

func (TeamRoutingRuleTimeRestrictionRestrictionOutput) EndMin 

func (o TeamRoutingRuleTimeRestrictionRestrictionOutput) EndMin() pulumi.IntOutput

func (TeamRoutingRuleTimeRestrictionRestrictionOutput) StartHour 

func (o TeamRoutingRuleTimeRestrictionRestrictionOutput) StartHour() pulumi.IntOutput

func (TeamRoutingRuleTimeRestrictionRestrictionOutput) StartMin 

func (o TeamRoutingRuleTimeRestrictionRestrictionOutput) StartMin() pulumi.IntOutput

func (TeamRoutingRuleTimeRestrictionRestrictionOutput) ToTeamRoutingRuleTimeRestrictionRestrictionOutput 

func (o TeamRoutingRuleTimeRestrictionRestrictionOutput) ToTeamRoutingRuleTimeRestrictionRestrictionOutput() TeamRoutingRuleTimeRestrictionRestrictionOutput

func (TeamRoutingRuleTimeRestrictionRestrictionOutput) ToTeamRoutingRuleTimeRestrictionRestrictionOutputWithContext 

func (o TeamRoutingRuleTimeRestrictionRestrictionOutput) ToTeamRoutingRuleTimeRestrictionRestrictionOutputWithContext(ctx context.Context) TeamRoutingRuleTimeRestrictionRestrictionOutput

type TeamState 

type TeamState struct {
	// Set to true to remove default escalation and schedule for newly created team. **Be careful its also changes that team routing rule to None. That means you have to define routing rule as well**
	DeleteDefaultResources pulumi.BoolPtrInput
	// A description for this team.
	Description pulumi.StringPtrInput
	// Set to true to ignore any configured member blocks and any team member added/updated/removed via OpsGenie web UI. Use this option e.g. to maintain membership via web UI only and use it only for new teams. Changing the value for existing teams might lead to strange behaviour. Default: `false`.
	IgnoreMembers pulumi.BoolPtrInput
	// A Member block as documented below.
	Members TeamMemberArrayInput
	// The name associated with this team. Opsgenie defines that this must not be longer than 100 characters.
	Name pulumi.StringPtrInput
}

func (TeamState) ElementType 

func (TeamState) ElementType() reflect.Type

type User 

type User struct {
	pulumi.CustomResourceState

	// The Full Name of the User.
	FullName pulumi.StringOutput `pulumi:"fullName"`
	// Location information for the user. Please look at [Supported Locale Ids](https://docs.opsgenie.com/docs/supported-locales) for available locales.
	Locale pulumi.StringPtrOutput `pulumi:"locale"`
	// The Role assigned to the User. Either a built-in such as 'Admin' or 'User' - or the name of a custom role.
	Role pulumi.StringOutput `pulumi:"role"`
	// Skype username of the user.
	SkypeUsername pulumi.StringPtrOutput `pulumi:"skypeUsername"`
	// A list of tags to be associated with the user.
	Tags pulumi.StringArrayOutput `pulumi:"tags"`
	// Timezone information of the user. Please look at [Supported Timezone Ids](https://docs.opsgenie.com/docs/supported-timezone-ids) for available timezones.
	Timezone pulumi.StringPtrOutput `pulumi:"timezone"`
	// Address of the user.
	UserAddresses UserUserAddressArrayOutput `pulumi:"userAddresses"`
	// Details about the user in form of key and list. of values.
	UserDetails pulumi.StringMapOutput `pulumi:"userDetails"`
	// The email address associated with this user. Opsgenie defines that this must not be longer than 100 characters and must contain lowercase characters only.
	Username pulumi.StringOutput `pulumi:"username"`
}

Manages a User within Opsgenie.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opsgenie.NewUser(ctx, "test", &opsgenie.UserArgs{
			Username: pulumi.String("user@domain.com"),
			FullName: pulumi.String("Test User"),
			Role:     pulumi.String("User"),
			Locale:   pulumi.String("en_US"),
			Timezone: pulumi.String("America/New_York"),
			Tags: pulumi.StringArray{
				pulumi.String("sre"),
				pulumi.String("opsgenie"),
			},
			SkypeUsername: pulumi.String("skypename"),
			UserAddresses: opsgenie.UserUserAddressArray{
				&opsgenie.UserUserAddressArgs{
					Country: pulumi.String("Country"),
					State:   pulumi.String("State"),
					City:    pulumi.String("City"),
					Line:    pulumi.String("Line"),
					Zipcode: pulumi.String("998877"),
				},
			},
			UserDetails: pulumi.StringMap{
				"key1": pulumi.String("val1,val2"),
				"key2": pulumi.String("val3,val4"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Users can be imported using the `user_id`, e.g.

```sh $ pulumi import opsgenie:index/user:User user user_id` ```

func GetUser 

func GetUser(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *UserState, opts ...pulumi.ResourceOption) (*User, error)

GetUser gets an existing User resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewUser 

func NewUser(ctx *pulumi.Context,
	name string, args *UserArgs, opts ...pulumi.ResourceOption) (*User, error)

NewUser registers a new resource with the given unique name, arguments, and options.

func (*User) ElementType 

func (*User) ElementType() reflect.Type

func (*User) ToUserOutput 

func (i *User) ToUserOutput() UserOutput

func (*User) ToUserOutputWithContext 

func (i *User) ToUserOutputWithContext(ctx context.Context) UserOutput

type UserArgs 

type UserArgs struct {
	// The Full Name of the User.
	FullName pulumi.StringInput
	// Location information for the user. Please look at [Supported Locale Ids](https://docs.opsgenie.com/docs/supported-locales) for available locales.
	Locale pulumi.StringPtrInput
	// The Role assigned to the User. Either a built-in such as 'Admin' or 'User' - or the name of a custom role.
	Role pulumi.StringInput
	// Skype username of the user.
	SkypeUsername pulumi.StringPtrInput
	// A list of tags to be associated with the user.
	Tags pulumi.StringArrayInput
	// Timezone information of the user. Please look at [Supported Timezone Ids](https://docs.opsgenie.com/docs/supported-timezone-ids) for available timezones.
	Timezone pulumi.StringPtrInput
	// Address of the user.
	UserAddresses UserUserAddressArrayInput
	// Details about the user in form of key and list. of values.
	UserDetails pulumi.StringMapInput
	// The email address associated with this user. Opsgenie defines that this must not be longer than 100 characters and must contain lowercase characters only.
	Username pulumi.StringInput
}

The set of arguments for constructing a User resource.

func (UserArgs) ElementType 

func (UserArgs) ElementType() reflect.Type

type UserArray added in v0.1.3 

type UserArray []UserInput

func (UserArray) ElementType added in v0.1.3 

func (UserArray) ElementType() reflect.Type

func (UserArray) ToUserArrayOutput added in v0.1.3 

func (i UserArray) ToUserArrayOutput() UserArrayOutput

func (UserArray) ToUserArrayOutputWithContext added in v0.1.3 

func (i UserArray) ToUserArrayOutputWithContext(ctx context.Context) UserArrayOutput

type UserArrayInput added in v0.1.3 

type UserArrayInput interface {
	pulumi.Input

	ToUserArrayOutput() UserArrayOutput
	ToUserArrayOutputWithContext(context.Context) UserArrayOutput
}

UserArrayInput is an input type that accepts UserArray and UserArrayOutput values. You can construct a concrete instance of `UserArrayInput` via: 

UserArray{ UserArgs{...} }

type UserArrayOutput added in v0.1.3 

type UserArrayOutput struct{ *pulumi.OutputState }

func (UserArrayOutput) ElementType added in v0.1.3 

func (UserArrayOutput) ElementType() reflect.Type

func (UserArrayOutput) Index added in v0.1.3 

func (o UserArrayOutput) Index(i pulumi.IntInput) UserOutput

func (UserArrayOutput) ToUserArrayOutput added in v0.1.3 

func (o UserArrayOutput) ToUserArrayOutput() UserArrayOutput

func (UserArrayOutput) ToUserArrayOutputWithContext added in v0.1.3 

func (o UserArrayOutput) ToUserArrayOutputWithContext(ctx context.Context) UserArrayOutput

type UserContact 

type UserContact struct {
	pulumi.CustomResourceState

	// Enable contact of the user in OpsGenie. Default value is true.
	Enabled pulumi.BoolPtrOutput `pulumi:"enabled"`
	// This parameter is the contact method of user and should be one of email, sms or voice. Please note that adding mobile is not supported from API.
	Method pulumi.StringOutput `pulumi:"method"`
	// to field is the address of given method.
	To pulumi.StringOutput `pulumi:"to"`
	// The username for contact.(reference)
	Username pulumi.StringOutput `pulumi:"username"`
}

Manages a User Contact.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-opsgenie/sdk/go/opsgenie"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opsgenie.NewUserContact(ctx, "sms", &opsgenie.UserContactArgs{
			Username: pulumi.Any(exampleuser.Username),
			To:       pulumi.String("39-123"),
			Method:   pulumi.String("sms"),
		})
		if err != nil {
			return err
		}
		_, err = opsgenie.NewUserContact(ctx, "email", &opsgenie.UserContactArgs{
			Username: pulumi.Any(exampleuser.Username),
			To:       pulumi.String("fahri@opsgenie.com"),
			Method:   pulumi.String("email"),
		})
		if err != nil {
			return err
		}
		_, err = opsgenie.NewUserContact(ctx, "voice", &opsgenie.UserContactArgs{
			Username: pulumi.Any(exampleuser.Username),
			To:       pulumi.String("39-123"),
			Method:   pulumi.String("voice"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Users can be imported using the `username/contact_id`, e.g.

```sh $ pulumi import opsgenie:index/userContact:UserContact testcontact username/contact_id` ```

func GetUserContact 

func GetUserContact(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *UserContactState, opts ...pulumi.ResourceOption) (*UserContact, error)

GetUserContact gets an existing UserContact resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewUserContact 

func NewUserContact(ctx *pulumi.Context,
	name string, args *UserContactArgs, opts ...pulumi.ResourceOption) (*UserContact, error)

NewUserContact registers a new resource with the given unique name, arguments, and options.

func (*UserContact) ElementType 

func (*UserContact) ElementType() reflect.Type

func (*UserContact) ToUserContactOutput 

func (i *UserContact) ToUserContactOutput() UserContactOutput

func (*UserContact) ToUserContactOutputWithContext 

func (i *UserContact) ToUserContactOutputWithContext(ctx context.Context) UserContactOutput

type UserContactArgs 

type UserContactArgs struct {
	// Enable contact of the user in OpsGenie. Default value is true.
	Enabled pulumi.BoolPtrInput
	// This parameter is the contact method of user and should be one of email, sms or voice. Please note that adding mobile is not supported from API.
	Method pulumi.StringInput
	// to field is the address of given method.
	To pulumi.StringInput
	// The username for contact.(reference)
	Username pulumi.StringInput
}

The set of arguments for constructing a UserContact resource.

func (UserContactArgs) ElementType 

func (UserContactArgs) ElementType() reflect.Type

type UserContactArray added in v0.1.3 

type UserContactArray []UserContactInput

func (UserContactArray) ElementType added in v0.1.3 

func (UserContactArray) ElementType() reflect.Type

func (UserContactArray) ToUserContactArrayOutput added in v0.1.3 

func (i UserContactArray) ToUserContactArrayOutput() UserContactArrayOutput

func (UserContactArray) ToUserContactArrayOutputWithContext added in v0.1.3 

func (i UserContactArray) ToUserContactArrayOutputWithContext(ctx context.Context) UserContactArrayOutput

type UserContactArrayInput added in v0.1.3 

type UserContactArrayInput interface {
	pulumi.Input

	ToUserContactArrayOutput() UserContactArrayOutput
	ToUserContactArrayOutputWithContext(context.Context) UserContactArrayOutput
}

UserContactArrayInput is an input type that accepts UserContactArray and UserContactArrayOutput values. You can construct a concrete instance of `UserContactArrayInput` via: 

UserContactArray{ UserContactArgs{...} }

type UserContactArrayOutput added in v0.1.3 

type UserContactArrayOutput struct{ *pulumi.OutputState }

func (UserContactArrayOutput) ElementType added in v0.1.3 

func (UserContactArrayOutput) ElementType() reflect.Type

func (UserContactArrayOutput) Index added in v0.1.3 

func (o UserContactArrayOutput) Index(i pulumi.IntInput) UserContactOutput

func (UserContactArrayOutput) ToUserContactArrayOutput added in v0.1.3 

func (o UserContactArrayOutput) ToUserContactArrayOutput() UserContactArrayOutput

func (UserContactArrayOutput) ToUserContactArrayOutputWithContext added in v0.1.3 

func (o UserContactArrayOutput) ToUserContactArrayOutputWithContext(ctx context.Context) UserContactArrayOutput

type UserContactInput 

type UserContactInput interface {
	pulumi.Input

	ToUserContactOutput() UserContactOutput
	ToUserContactOutputWithContext(ctx context.Context) UserContactOutput
}

type UserContactMap added in v0.1.3 

type UserContactMap map[string]UserContactInput

func (UserContactMap) ElementType added in v0.1.3 

func (UserContactMap) ElementType() reflect.Type

func (UserContactMap) ToUserContactMapOutput added in v0.1.3 

func (i UserContactMap) ToUserContactMapOutput() UserContactMapOutput

func (UserContactMap) ToUserContactMapOutputWithContext added in v0.1.3 

func (i UserContactMap) ToUserContactMapOutputWithContext(ctx context.Context) UserContactMapOutput

type UserContactMapInput added in v0.1.3 

type UserContactMapInput interface {
	pulumi.Input

	ToUserContactMapOutput() UserContactMapOutput
	ToUserContactMapOutputWithContext(context.Context) UserContactMapOutput
}

UserContactMapInput is an input type that accepts UserContactMap and UserContactMapOutput values. You can construct a concrete instance of `UserContactMapInput` via: 

UserContactMap{ "key": UserContactArgs{...} }

type UserContactMapOutput added in v0.1.3 

type UserContactMapOutput struct{ *pulumi.OutputState }

func (UserContactMapOutput) ElementType added in v0.1.3 

func (UserContactMapOutput) ElementType() reflect.Type

func (UserContactMapOutput) MapIndex added in v0.1.3 

func (o UserContactMapOutput) MapIndex(k pulumi.StringInput) UserContactOutput

func (UserContactMapOutput) ToUserContactMapOutput added in v0.1.3 

func (o UserContactMapOutput) ToUserContactMapOutput() UserContactMapOutput

func (UserContactMapOutput) ToUserContactMapOutputWithContext added in v0.1.3 

func (o UserContactMapOutput) ToUserContactMapOutputWithContext(ctx context.Context) UserContactMapOutput

type UserContactOutput 

type UserContactOutput struct{ *pulumi.OutputState }

func (UserContactOutput) ElementType 

func (UserContactOutput) ElementType() reflect.Type

func (UserContactOutput) Enabled added in v1.1.9 

func (o UserContactOutput) Enabled() pulumi.BoolPtrOutput

Enable contact of the user in OpsGenie. Default value is true.

func (UserContactOutput) Method added in v1.1.9 

func (o UserContactOutput) Method() pulumi.StringOutput

This parameter is the contact method of user and should be one of email, sms or voice. Please note that adding mobile is not supported from API.

func (UserContactOutput) To added in v1.1.9 

func (o UserContactOutput) To() pulumi.StringOutput

to field is the address of given method.

func (UserContactOutput) ToUserContactOutput 

func (o UserContactOutput) ToUserContactOutput() UserContactOutput

func (UserContactOutput) ToUserContactOutputWithContext 

func (o UserContactOutput) ToUserContactOutputWithContext(ctx context.Context) UserContactOutput

func (UserContactOutput) Username added in v1.1.9 

func (o UserContactOutput) Username() pulumi.StringOutput

The username for contact.(reference)

type UserContactState 

type UserContactState struct {
	// Enable contact of the user in OpsGenie. Default value is true.
	Enabled pulumi.BoolPtrInput
	// This parameter is the contact method of user and should be one of email, sms or voice. Please note that adding mobile is not supported from API.
	Method pulumi.StringPtrInput
	// to field is the address of given method.
	To pulumi.StringPtrInput
	// The username for contact.(reference)
	Username pulumi.StringPtrInput
}

func (UserContactState) ElementType 

func (UserContactState) ElementType() reflect.Type

type UserInput 

type UserInput interface {
	pulumi.Input

	ToUserOutput() UserOutput
	ToUserOutputWithContext(ctx context.Context) UserOutput
}

type UserMap added in v0.1.3 

type UserMap map[string]UserInput

func (UserMap) ElementType added in v0.1.3 

func (UserMap) ElementType() reflect.Type

func (UserMap) ToUserMapOutput added in v0.1.3 

func (i UserMap) ToUserMapOutput() UserMapOutput

func (UserMap) ToUserMapOutputWithContext added in v0.1.3 

func (i UserMap) ToUserMapOutputWithContext(ctx context.Context) UserMapOutput

type UserMapInput added in v0.1.3 

type UserMapInput interface {
	pulumi.Input

	ToUserMapOutput() UserMapOutput
	ToUserMapOutputWithContext(context.Context) UserMapOutput
}

UserMapInput is an input type that accepts UserMap and UserMapOutput values. You can construct a concrete instance of `UserMapInput` via: 

UserMap{ "key": UserArgs{...} }

type UserMapOutput added in v0.1.3 

type UserMapOutput struct{ *pulumi.OutputState }

func (UserMapOutput) ElementType added in v0.1.3 

func (UserMapOutput) ElementType() reflect.Type

func (UserMapOutput) MapIndex added in v0.1.3 

func (o UserMapOutput) MapIndex(k pulumi.StringInput) UserOutput

func (UserMapOutput) ToUserMapOutput added in v0.1.3 

func (o UserMapOutput) ToUserMapOutput() UserMapOutput

func (UserMapOutput) ToUserMapOutputWithContext added in v0.1.3 

func (o UserMapOutput) ToUserMapOutputWithContext(ctx context.Context) UserMapOutput

type UserOutput 

type UserOutput struct{ *pulumi.OutputState }

func (UserOutput) ElementType 

func (UserOutput) ElementType() reflect.Type

func (UserOutput) FullName added in v1.1.9 

func (o UserOutput) FullName() pulumi.StringOutput

The Full Name of the User.

func (UserOutput) Locale added in v1.1.9 

func (o UserOutput) Locale() pulumi.StringPtrOutput

Location information for the user. Please look at [Supported Locale Ids](https://docs.opsgenie.com/docs/supported-locales) for available locales.

func (UserOutput) Role added in v1.1.9 

func (o UserOutput) Role() pulumi.StringOutput

The Role assigned to the User. Either a built-in such as 'Admin' or 'User' - or the name of a custom role.

func (UserOutput) SkypeUsername added in v1.1.9 

func (o UserOutput) SkypeUsername() pulumi.StringPtrOutput

Skype username of the user.

func (UserOutput) Tags added in v1.1.9 

func (o UserOutput) Tags() pulumi.StringArrayOutput

A list of tags to be associated with the user.

func (UserOutput) Timezone added in v1.1.9 

func (o UserOutput) Timezone() pulumi.StringPtrOutput

Timezone information of the user. Please look at [Supported Timezone Ids](https://docs.opsgenie.com/docs/supported-timezone-ids) for available timezones.

func (UserOutput) ToUserOutput 

func (o UserOutput) ToUserOutput() UserOutput

func (UserOutput) ToUserOutputWithContext 

func (o UserOutput) ToUserOutputWithContext(ctx context.Context) UserOutput

func (UserOutput) UserAddresses added in v1.1.9 

func (o UserOutput) UserAddresses() UserUserAddressArrayOutput

Address of the user.

func (UserOutput) UserDetails added in v1.1.9 

func (o UserOutput) UserDetails() pulumi.StringMapOutput

Details about the user in form of key and list. of values.

func (UserOutput) Username added in v1.1.9 

func (o UserOutput) Username() pulumi.StringOutput

The email address associated with this user. Opsgenie defines that this must not be longer than 100 characters and must contain lowercase characters only.

type UserState 

type UserState struct {
	// The Full Name of the User.
	FullName pulumi.StringPtrInput
	// Location information for the user. Please look at [Supported Locale Ids](https://docs.opsgenie.com/docs/supported-locales) for available locales.
	Locale pulumi.StringPtrInput
	// The Role assigned to the User. Either a built-in such as 'Admin' or 'User' - or the name of a custom role.
	Role pulumi.StringPtrInput
	// Skype username of the user.
	SkypeUsername pulumi.StringPtrInput
	// A list of tags to be associated with the user.
	Tags pulumi.StringArrayInput
	// Timezone information of the user. Please look at [Supported Timezone Ids](https://docs.opsgenie.com/docs/supported-timezone-ids) for available timezones.
	Timezone pulumi.StringPtrInput
	// Address of the user.
	UserAddresses UserUserAddressArrayInput
	// Details about the user in form of key and list. of values.
	UserDetails pulumi.StringMapInput
	// The email address associated with this user. Opsgenie defines that this must not be longer than 100 characters and must contain lowercase characters only.
	Username pulumi.StringPtrInput
}

func (UserState) ElementType 

func (UserState) ElementType() reflect.Type

type UserUserAddress 

type UserUserAddress struct {
	City    string `pulumi:"city"`
	Country string `pulumi:"country"`
	Line    string `pulumi:"line"`
	State   string `pulumi:"state"`
	Zipcode string `pulumi:"zipcode"`
}

type UserUserAddressArgs 

type UserUserAddressArgs struct {
	City    pulumi.StringInput `pulumi:"city"`
	Country pulumi.StringInput `pulumi:"country"`
	Line    pulumi.StringInput `pulumi:"line"`
	State   pulumi.StringInput `pulumi:"state"`
	Zipcode pulumi.StringInput `pulumi:"zipcode"`
}

func (UserUserAddressArgs) ElementType 

func (UserUserAddressArgs) ElementType() reflect.Type

func (UserUserAddressArgs) ToUserUserAddressOutput 

func (i UserUserAddressArgs) ToUserUserAddressOutput() UserUserAddressOutput

func (UserUserAddressArgs) ToUserUserAddressOutputWithContext 

func (i UserUserAddressArgs) ToUserUserAddressOutputWithContext(ctx context.Context) UserUserAddressOutput

type UserUserAddressArray 

type UserUserAddressArray []UserUserAddressInput

func (UserUserAddressArray) ElementType 

func (UserUserAddressArray) ElementType() reflect.Type

func (UserUserAddressArray) ToUserUserAddressArrayOutput 

func (i UserUserAddressArray) ToUserUserAddressArrayOutput() UserUserAddressArrayOutput

func (UserUserAddressArray) ToUserUserAddressArrayOutputWithContext 

func (i UserUserAddressArray) ToUserUserAddressArrayOutputWithContext(ctx context.Context) UserUserAddressArrayOutput

type UserUserAddressArrayInput 

type UserUserAddressArrayInput interface {
	pulumi.Input

	ToUserUserAddressArrayOutput() UserUserAddressArrayOutput
	ToUserUserAddressArrayOutputWithContext(context.Context) UserUserAddressArrayOutput
}

UserUserAddressArrayInput is an input type that accepts UserUserAddressArray and UserUserAddressArrayOutput values. You can construct a concrete instance of `UserUserAddressArrayInput` via: 

UserUserAddressArray{ UserUserAddressArgs{...} }

type UserUserAddressArrayOutput 

type UserUserAddressArrayOutput struct{ *pulumi.OutputState }

func (UserUserAddressArrayOutput) ElementType 

func (UserUserAddressArrayOutput) ElementType() reflect.Type

func (UserUserAddressArrayOutput) Index 

func (o UserUserAddressArrayOutput) Index(i pulumi.IntInput) UserUserAddressOutput

func (UserUserAddressArrayOutput) ToUserUserAddressArrayOutput 

func (o UserUserAddressArrayOutput) ToUserUserAddressArrayOutput() UserUserAddressArrayOutput

func (UserUserAddressArrayOutput) ToUserUserAddressArrayOutputWithContext 

func (o UserUserAddressArrayOutput) ToUserUserAddressArrayOutputWithContext(ctx context.Context) UserUserAddressArrayOutput

type UserUserAddressInput 

type UserUserAddressInput interface {
	pulumi.Input

	ToUserUserAddressOutput() UserUserAddressOutput
	ToUserUserAddressOutputWithContext(context.Context) UserUserAddressOutput
}

UserUserAddressInput is an input type that accepts UserUserAddressArgs and UserUserAddressOutput values. You can construct a concrete instance of `UserUserAddressInput` via: 

UserUserAddressArgs{...}

type UserUserAddressOutput 

type UserUserAddressOutput struct{ *pulumi.OutputState }

func (UserUserAddressOutput) City 

func (o UserUserAddressOutput) City() pulumi.StringOutput

func (UserUserAddressOutput) Country 

func (o UserUserAddressOutput) Country() pulumi.StringOutput

func (UserUserAddressOutput) ElementType 

func (UserUserAddressOutput) ElementType() reflect.Type

func (UserUserAddressOutput) Line 

func (o UserUserAddressOutput) Line() pulumi.StringOutput

func (UserUserAddressOutput) State 

func (o UserUserAddressOutput) State() pulumi.StringOutput

func (UserUserAddressOutput) ToUserUserAddressOutput 

func (o UserUserAddressOutput) ToUserUserAddressOutput() UserUserAddressOutput

func (UserUserAddressOutput) ToUserUserAddressOutputWithContext 

func (o UserUserAddressOutput) ToUserUserAddressOutputWithContext(ctx context.Context) UserUserAddressOutput

func (UserUserAddressOutput) Zipcode 

func (o UserUserAddressOutput) Zipcode() pulumi.StringOutput

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.