ses

package
v6.0.0-alpha.4 Latest Latest
Warning

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

 Go to latest Published: Jul 17, 2023 License: Apache-2.0 Imports: 7 Imported by: 1

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ActiveReceiptRuleSet 

type ActiveReceiptRuleSet struct {
	pulumi.CustomResourceState

	// The SES receipt rule set ARN.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The name of the rule set
	RuleSetName pulumi.StringOutput `pulumi:"ruleSetName"`
}

Provides a resource to designate the active SES receipt rule set

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ses.NewActiveReceiptRuleSet(ctx, "main", &ses.ActiveReceiptRuleSetArgs{
			RuleSetName: pulumi.String("primary-rules"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Active SES receipt rule sets can be imported using the rule set name.

```sh 

$ pulumi import aws:ses/activeReceiptRuleSet:ActiveReceiptRuleSet my_rule_set my_rule_set_name

```

func GetActiveReceiptRuleSet 

func GetActiveReceiptRuleSet(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ActiveReceiptRuleSetState, opts ...pulumi.ResourceOption) (*ActiveReceiptRuleSet, error)

GetActiveReceiptRuleSet gets an existing ActiveReceiptRuleSet 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 NewActiveReceiptRuleSet 

func NewActiveReceiptRuleSet(ctx *pulumi.Context,
	name string, args *ActiveReceiptRuleSetArgs, opts ...pulumi.ResourceOption) (*ActiveReceiptRuleSet, error)

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

func (*ActiveReceiptRuleSet) ElementType 

func (*ActiveReceiptRuleSet) ElementType() reflect.Type

func (*ActiveReceiptRuleSet) ToActiveReceiptRuleSetOutput 

func (i *ActiveReceiptRuleSet) ToActiveReceiptRuleSetOutput() ActiveReceiptRuleSetOutput

func (*ActiveReceiptRuleSet) ToActiveReceiptRuleSetOutputWithContext 

func (i *ActiveReceiptRuleSet) ToActiveReceiptRuleSetOutputWithContext(ctx context.Context) ActiveReceiptRuleSetOutput

type ActiveReceiptRuleSetArgs 

type ActiveReceiptRuleSetArgs struct {
	// The name of the rule set
	RuleSetName pulumi.StringInput
}

The set of arguments for constructing a ActiveReceiptRuleSet resource.

func (ActiveReceiptRuleSetArgs) ElementType 

func (ActiveReceiptRuleSetArgs) ElementType() reflect.Type

type ActiveReceiptRuleSetArray 

type ActiveReceiptRuleSetArray []ActiveReceiptRuleSetInput

func (ActiveReceiptRuleSetArray) ElementType 

func (ActiveReceiptRuleSetArray) ElementType() reflect.Type

func (ActiveReceiptRuleSetArray) ToActiveReceiptRuleSetArrayOutput 

func (i ActiveReceiptRuleSetArray) ToActiveReceiptRuleSetArrayOutput() ActiveReceiptRuleSetArrayOutput

func (ActiveReceiptRuleSetArray) ToActiveReceiptRuleSetArrayOutputWithContext 

func (i ActiveReceiptRuleSetArray) ToActiveReceiptRuleSetArrayOutputWithContext(ctx context.Context) ActiveReceiptRuleSetArrayOutput

type ActiveReceiptRuleSetArrayInput 

type ActiveReceiptRuleSetArrayInput interface {
	pulumi.Input

	ToActiveReceiptRuleSetArrayOutput() ActiveReceiptRuleSetArrayOutput
	ToActiveReceiptRuleSetArrayOutputWithContext(context.Context) ActiveReceiptRuleSetArrayOutput
}

ActiveReceiptRuleSetArrayInput is an input type that accepts ActiveReceiptRuleSetArray and ActiveReceiptRuleSetArrayOutput values. You can construct a concrete instance of `ActiveReceiptRuleSetArrayInput` via: 

ActiveReceiptRuleSetArray{ ActiveReceiptRuleSetArgs{...} }

type ActiveReceiptRuleSetArrayOutput 

type ActiveReceiptRuleSetArrayOutput struct{ *pulumi.OutputState }

func (ActiveReceiptRuleSetArrayOutput) ElementType 

func (ActiveReceiptRuleSetArrayOutput) ElementType() reflect.Type

func (ActiveReceiptRuleSetArrayOutput) Index 

func (o ActiveReceiptRuleSetArrayOutput) Index(i pulumi.IntInput) ActiveReceiptRuleSetOutput

func (ActiveReceiptRuleSetArrayOutput) ToActiveReceiptRuleSetArrayOutput 

func (o ActiveReceiptRuleSetArrayOutput) ToActiveReceiptRuleSetArrayOutput() ActiveReceiptRuleSetArrayOutput

func (ActiveReceiptRuleSetArrayOutput) ToActiveReceiptRuleSetArrayOutputWithContext 

func (o ActiveReceiptRuleSetArrayOutput) ToActiveReceiptRuleSetArrayOutputWithContext(ctx context.Context) ActiveReceiptRuleSetArrayOutput

type ActiveReceiptRuleSetInput 

type ActiveReceiptRuleSetInput interface {
	pulumi.Input

	ToActiveReceiptRuleSetOutput() ActiveReceiptRuleSetOutput
	ToActiveReceiptRuleSetOutputWithContext(ctx context.Context) ActiveReceiptRuleSetOutput
}

type ActiveReceiptRuleSetMap 

type ActiveReceiptRuleSetMap map[string]ActiveReceiptRuleSetInput

func (ActiveReceiptRuleSetMap) ElementType 

func (ActiveReceiptRuleSetMap) ElementType() reflect.Type

func (ActiveReceiptRuleSetMap) ToActiveReceiptRuleSetMapOutput 

func (i ActiveReceiptRuleSetMap) ToActiveReceiptRuleSetMapOutput() ActiveReceiptRuleSetMapOutput

func (ActiveReceiptRuleSetMap) ToActiveReceiptRuleSetMapOutputWithContext 

func (i ActiveReceiptRuleSetMap) ToActiveReceiptRuleSetMapOutputWithContext(ctx context.Context) ActiveReceiptRuleSetMapOutput

type ActiveReceiptRuleSetMapInput 

type ActiveReceiptRuleSetMapInput interface {
	pulumi.Input

	ToActiveReceiptRuleSetMapOutput() ActiveReceiptRuleSetMapOutput
	ToActiveReceiptRuleSetMapOutputWithContext(context.Context) ActiveReceiptRuleSetMapOutput
}

ActiveReceiptRuleSetMapInput is an input type that accepts ActiveReceiptRuleSetMap and ActiveReceiptRuleSetMapOutput values. You can construct a concrete instance of `ActiveReceiptRuleSetMapInput` via: 

ActiveReceiptRuleSetMap{ "key": ActiveReceiptRuleSetArgs{...} }

type ActiveReceiptRuleSetMapOutput 

type ActiveReceiptRuleSetMapOutput struct{ *pulumi.OutputState }

func (ActiveReceiptRuleSetMapOutput) ElementType 

func (ActiveReceiptRuleSetMapOutput) ElementType() reflect.Type

func (ActiveReceiptRuleSetMapOutput) MapIndex 

func (o ActiveReceiptRuleSetMapOutput) MapIndex(k pulumi.StringInput) ActiveReceiptRuleSetOutput

func (ActiveReceiptRuleSetMapOutput) ToActiveReceiptRuleSetMapOutput 

func (o ActiveReceiptRuleSetMapOutput) ToActiveReceiptRuleSetMapOutput() ActiveReceiptRuleSetMapOutput

func (ActiveReceiptRuleSetMapOutput) ToActiveReceiptRuleSetMapOutputWithContext 

func (o ActiveReceiptRuleSetMapOutput) ToActiveReceiptRuleSetMapOutputWithContext(ctx context.Context) ActiveReceiptRuleSetMapOutput

type ActiveReceiptRuleSetOutput 

type ActiveReceiptRuleSetOutput struct{ *pulumi.OutputState }

func (ActiveReceiptRuleSetOutput) Arn 

func (o ActiveReceiptRuleSetOutput) Arn() pulumi.StringOutput

The SES receipt rule set ARN.

func (ActiveReceiptRuleSetOutput) ElementType 

func (ActiveReceiptRuleSetOutput) ElementType() reflect.Type

func (ActiveReceiptRuleSetOutput) RuleSetName 

func (o ActiveReceiptRuleSetOutput) RuleSetName() pulumi.StringOutput

The name of the rule set

func (ActiveReceiptRuleSetOutput) ToActiveReceiptRuleSetOutput 

func (o ActiveReceiptRuleSetOutput) ToActiveReceiptRuleSetOutput() ActiveReceiptRuleSetOutput

func (ActiveReceiptRuleSetOutput) ToActiveReceiptRuleSetOutputWithContext 

func (o ActiveReceiptRuleSetOutput) ToActiveReceiptRuleSetOutputWithContext(ctx context.Context) ActiveReceiptRuleSetOutput

type ActiveReceiptRuleSetState 

type ActiveReceiptRuleSetState struct {
	// The SES receipt rule set ARN.
	Arn pulumi.StringPtrInput
	// The name of the rule set
	RuleSetName pulumi.StringPtrInput
}

func (ActiveReceiptRuleSetState) ElementType 

func (ActiveReceiptRuleSetState) ElementType() reflect.Type

type ConfigurationSet 

type ConfigurationSet struct {
	pulumi.CustomResourceState

	// SES configuration set ARN.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// Whether messages that use the configuration set are required to use TLS. See below.
	DeliveryOptions ConfigurationSetDeliveryOptionsPtrOutput `pulumi:"deliveryOptions"`
	// Date and time at which the reputation metrics for the configuration set were last reset. Resetting these metrics is known as a fresh start.
	LastFreshStart pulumi.StringOutput `pulumi:"lastFreshStart"`
	// Name of the configuration set.
	//
	// The following argument is optional:
	Name pulumi.StringOutput `pulumi:"name"`
	// Whether or not Amazon SES publishes reputation metrics for the configuration set, such as bounce and complaint rates, to Amazon CloudWatch. The default value is `false`.
	ReputationMetricsEnabled pulumi.BoolPtrOutput `pulumi:"reputationMetricsEnabled"`
	// Whether email sending is enabled or disabled for the configuration set. The default value is `true`.
	SendingEnabled pulumi.BoolPtrOutput `pulumi:"sendingEnabled"`
	// Domain that is used to redirect email recipients to an Amazon SES-operated domain. See below. **NOTE:** This functionality is best effort.
	TrackingOptions ConfigurationSetTrackingOptionsPtrOutput `pulumi:"trackingOptions"`
}

Provides an SES configuration set resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ses.NewConfigurationSet(ctx, "test", nil)
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Require TLS Connections

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ses.NewConfigurationSet(ctx, "test", &ses.ConfigurationSetArgs{
			DeliveryOptions: &ses.ConfigurationSetDeliveryOptionsArgs{
				TlsPolicy: pulumi.String("Require"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

SES Configuration Sets can be imported using their `name`, e.g.,

```sh 

$ pulumi import aws:ses/configurationSet:ConfigurationSet test some-configuration-set-test

```

func GetConfigurationSet 

func GetConfigurationSet(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ConfigurationSetState, opts ...pulumi.ResourceOption) (*ConfigurationSet, error)

GetConfigurationSet gets an existing ConfigurationSet 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 NewConfigurationSet 

func NewConfigurationSet(ctx *pulumi.Context,
	name string, args *ConfigurationSetArgs, opts ...pulumi.ResourceOption) (*ConfigurationSet, error)

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

func (*ConfigurationSet) ElementType 

func (*ConfigurationSet) ElementType() reflect.Type

func (*ConfigurationSet) ToConfigurationSetOutput 

func (i *ConfigurationSet) ToConfigurationSetOutput() ConfigurationSetOutput

func (*ConfigurationSet) ToConfigurationSetOutputWithContext 

func (i *ConfigurationSet) ToConfigurationSetOutputWithContext(ctx context.Context) ConfigurationSetOutput

type ConfigurationSetArgs 

type ConfigurationSetArgs struct {
	// Whether messages that use the configuration set are required to use TLS. See below.
	DeliveryOptions ConfigurationSetDeliveryOptionsPtrInput
	// Name of the configuration set.
	//
	// The following argument is optional:
	Name pulumi.StringPtrInput
	// Whether or not Amazon SES publishes reputation metrics for the configuration set, such as bounce and complaint rates, to Amazon CloudWatch. The default value is `false`.
	ReputationMetricsEnabled pulumi.BoolPtrInput
	// Whether email sending is enabled or disabled for the configuration set. The default value is `true`.
	SendingEnabled pulumi.BoolPtrInput
	// Domain that is used to redirect email recipients to an Amazon SES-operated domain. See below. **NOTE:** This functionality is best effort.
	TrackingOptions ConfigurationSetTrackingOptionsPtrInput
}

The set of arguments for constructing a ConfigurationSet resource.

func (ConfigurationSetArgs) ElementType 

func (ConfigurationSetArgs) ElementType() reflect.Type

type ConfigurationSetArray 

type ConfigurationSetArray []ConfigurationSetInput

func (ConfigurationSetArray) ElementType 

func (ConfigurationSetArray) ElementType() reflect.Type

func (ConfigurationSetArray) ToConfigurationSetArrayOutput 

func (i ConfigurationSetArray) ToConfigurationSetArrayOutput() ConfigurationSetArrayOutput

func (ConfigurationSetArray) ToConfigurationSetArrayOutputWithContext 

func (i ConfigurationSetArray) ToConfigurationSetArrayOutputWithContext(ctx context.Context) ConfigurationSetArrayOutput

type ConfigurationSetArrayInput 

type ConfigurationSetArrayInput interface {
	pulumi.Input

	ToConfigurationSetArrayOutput() ConfigurationSetArrayOutput
	ToConfigurationSetArrayOutputWithContext(context.Context) ConfigurationSetArrayOutput
}

ConfigurationSetArrayInput is an input type that accepts ConfigurationSetArray and ConfigurationSetArrayOutput values. You can construct a concrete instance of `ConfigurationSetArrayInput` via: 

ConfigurationSetArray{ ConfigurationSetArgs{...} }

type ConfigurationSetArrayOutput 

type ConfigurationSetArrayOutput struct{ *pulumi.OutputState }

func (ConfigurationSetArrayOutput) ElementType 

func (ConfigurationSetArrayOutput) ElementType() reflect.Type

func (ConfigurationSetArrayOutput) Index 

func (o ConfigurationSetArrayOutput) Index(i pulumi.IntInput) ConfigurationSetOutput

func (ConfigurationSetArrayOutput) ToConfigurationSetArrayOutput 

func (o ConfigurationSetArrayOutput) ToConfigurationSetArrayOutput() ConfigurationSetArrayOutput

func (ConfigurationSetArrayOutput) ToConfigurationSetArrayOutputWithContext 

func (o ConfigurationSetArrayOutput) ToConfigurationSetArrayOutputWithContext(ctx context.Context) ConfigurationSetArrayOutput

type ConfigurationSetDeliveryOptions 

type ConfigurationSetDeliveryOptions struct {
	// Whether messages that use the configuration set are required to use Transport Layer Security (TLS). If the value is `Require`, messages are only delivered if a TLS connection can be established. If the value is `Optional`, messages can be delivered in plain text if a TLS connection can't be established. Valid values: `Require` or `Optional`. Defaults to `Optional`.
	TlsPolicy *string `pulumi:"tlsPolicy"`
}

type ConfigurationSetDeliveryOptionsArgs 

type ConfigurationSetDeliveryOptionsArgs struct {
	// Whether messages that use the configuration set are required to use Transport Layer Security (TLS). If the value is `Require`, messages are only delivered if a TLS connection can be established. If the value is `Optional`, messages can be delivered in plain text if a TLS connection can't be established. Valid values: `Require` or `Optional`. Defaults to `Optional`.
	TlsPolicy pulumi.StringPtrInput `pulumi:"tlsPolicy"`
}

func (ConfigurationSetDeliveryOptionsArgs) ElementType 

func (ConfigurationSetDeliveryOptionsArgs) ElementType() reflect.Type

func (ConfigurationSetDeliveryOptionsArgs) ToConfigurationSetDeliveryOptionsOutput 

func (i ConfigurationSetDeliveryOptionsArgs) ToConfigurationSetDeliveryOptionsOutput() ConfigurationSetDeliveryOptionsOutput

func (ConfigurationSetDeliveryOptionsArgs) ToConfigurationSetDeliveryOptionsOutputWithContext 

func (i ConfigurationSetDeliveryOptionsArgs) ToConfigurationSetDeliveryOptionsOutputWithContext(ctx context.Context) ConfigurationSetDeliveryOptionsOutput

func (ConfigurationSetDeliveryOptionsArgs) ToConfigurationSetDeliveryOptionsPtrOutput 

func (i ConfigurationSetDeliveryOptionsArgs) ToConfigurationSetDeliveryOptionsPtrOutput() ConfigurationSetDeliveryOptionsPtrOutput

func (ConfigurationSetDeliveryOptionsArgs) ToConfigurationSetDeliveryOptionsPtrOutputWithContext 

func (i ConfigurationSetDeliveryOptionsArgs) ToConfigurationSetDeliveryOptionsPtrOutputWithContext(ctx context.Context) ConfigurationSetDeliveryOptionsPtrOutput

type ConfigurationSetDeliveryOptionsInput 

type ConfigurationSetDeliveryOptionsInput interface {
	pulumi.Input

	ToConfigurationSetDeliveryOptionsOutput() ConfigurationSetDeliveryOptionsOutput
	ToConfigurationSetDeliveryOptionsOutputWithContext(context.Context) ConfigurationSetDeliveryOptionsOutput
}

ConfigurationSetDeliveryOptionsInput is an input type that accepts ConfigurationSetDeliveryOptionsArgs and ConfigurationSetDeliveryOptionsOutput values. You can construct a concrete instance of `ConfigurationSetDeliveryOptionsInput` via: 

ConfigurationSetDeliveryOptionsArgs{...}

type ConfigurationSetDeliveryOptionsOutput 

type ConfigurationSetDeliveryOptionsOutput struct{ *pulumi.OutputState }

func (ConfigurationSetDeliveryOptionsOutput) ElementType 

func (ConfigurationSetDeliveryOptionsOutput) ElementType() reflect.Type

func (ConfigurationSetDeliveryOptionsOutput) TlsPolicy 

func (o ConfigurationSetDeliveryOptionsOutput) TlsPolicy() pulumi.StringPtrOutput

Whether messages that use the configuration set are required to use Transport Layer Security (TLS). If the value is `Require`, messages are only delivered if a TLS connection can be established. If the value is `Optional`, messages can be delivered in plain text if a TLS connection can't be established. Valid values: `Require` or `Optional`. Defaults to `Optional`.

func (ConfigurationSetDeliveryOptionsOutput) ToConfigurationSetDeliveryOptionsOutput 

func (o ConfigurationSetDeliveryOptionsOutput) ToConfigurationSetDeliveryOptionsOutput() ConfigurationSetDeliveryOptionsOutput

func (ConfigurationSetDeliveryOptionsOutput) ToConfigurationSetDeliveryOptionsOutputWithContext 

func (o ConfigurationSetDeliveryOptionsOutput) ToConfigurationSetDeliveryOptionsOutputWithContext(ctx context.Context) ConfigurationSetDeliveryOptionsOutput

func (ConfigurationSetDeliveryOptionsOutput) ToConfigurationSetDeliveryOptionsPtrOutput 

func (o ConfigurationSetDeliveryOptionsOutput) ToConfigurationSetDeliveryOptionsPtrOutput() ConfigurationSetDeliveryOptionsPtrOutput

func (ConfigurationSetDeliveryOptionsOutput) ToConfigurationSetDeliveryOptionsPtrOutputWithContext 

func (o ConfigurationSetDeliveryOptionsOutput) ToConfigurationSetDeliveryOptionsPtrOutputWithContext(ctx context.Context) ConfigurationSetDeliveryOptionsPtrOutput

type ConfigurationSetDeliveryOptionsPtrInput 

type ConfigurationSetDeliveryOptionsPtrInput interface {
	pulumi.Input

	ToConfigurationSetDeliveryOptionsPtrOutput() ConfigurationSetDeliveryOptionsPtrOutput
	ToConfigurationSetDeliveryOptionsPtrOutputWithContext(context.Context) ConfigurationSetDeliveryOptionsPtrOutput
}

ConfigurationSetDeliveryOptionsPtrInput is an input type that accepts ConfigurationSetDeliveryOptionsArgs, ConfigurationSetDeliveryOptionsPtr and ConfigurationSetDeliveryOptionsPtrOutput values. You can construct a concrete instance of `ConfigurationSetDeliveryOptionsPtrInput` via: 

        ConfigurationSetDeliveryOptionsArgs{...}

or:

        nil

func ConfigurationSetDeliveryOptionsPtr 

func ConfigurationSetDeliveryOptionsPtr(v *ConfigurationSetDeliveryOptionsArgs) ConfigurationSetDeliveryOptionsPtrInput

type ConfigurationSetDeliveryOptionsPtrOutput 

type ConfigurationSetDeliveryOptionsPtrOutput struct{ *pulumi.OutputState }

func (ConfigurationSetDeliveryOptionsPtrOutput) Elem 

func (o ConfigurationSetDeliveryOptionsPtrOutput) Elem() ConfigurationSetDeliveryOptionsOutput

func (ConfigurationSetDeliveryOptionsPtrOutput) ElementType 

func (ConfigurationSetDeliveryOptionsPtrOutput) ElementType() reflect.Type

func (ConfigurationSetDeliveryOptionsPtrOutput) TlsPolicy 

func (o ConfigurationSetDeliveryOptionsPtrOutput) TlsPolicy() pulumi.StringPtrOutput

Whether messages that use the configuration set are required to use Transport Layer Security (TLS). If the value is `Require`, messages are only delivered if a TLS connection can be established. If the value is `Optional`, messages can be delivered in plain text if a TLS connection can't be established. Valid values: `Require` or `Optional`. Defaults to `Optional`.

func (ConfigurationSetDeliveryOptionsPtrOutput) ToConfigurationSetDeliveryOptionsPtrOutput 

func (o ConfigurationSetDeliveryOptionsPtrOutput) ToConfigurationSetDeliveryOptionsPtrOutput() ConfigurationSetDeliveryOptionsPtrOutput

func (ConfigurationSetDeliveryOptionsPtrOutput) ToConfigurationSetDeliveryOptionsPtrOutputWithContext 

func (o ConfigurationSetDeliveryOptionsPtrOutput) ToConfigurationSetDeliveryOptionsPtrOutputWithContext(ctx context.Context) ConfigurationSetDeliveryOptionsPtrOutput

type ConfigurationSetInput 

type ConfigurationSetInput interface {
	pulumi.Input

	ToConfigurationSetOutput() ConfigurationSetOutput
	ToConfigurationSetOutputWithContext(ctx context.Context) ConfigurationSetOutput
}

type ConfigurationSetMap 

type ConfigurationSetMap map[string]ConfigurationSetInput

func (ConfigurationSetMap) ElementType 

func (ConfigurationSetMap) ElementType() reflect.Type

func (ConfigurationSetMap) ToConfigurationSetMapOutput 

func (i ConfigurationSetMap) ToConfigurationSetMapOutput() ConfigurationSetMapOutput

func (ConfigurationSetMap) ToConfigurationSetMapOutputWithContext 

func (i ConfigurationSetMap) ToConfigurationSetMapOutputWithContext(ctx context.Context) ConfigurationSetMapOutput

type ConfigurationSetMapInput 

type ConfigurationSetMapInput interface {
	pulumi.Input

	ToConfigurationSetMapOutput() ConfigurationSetMapOutput
	ToConfigurationSetMapOutputWithContext(context.Context) ConfigurationSetMapOutput
}

ConfigurationSetMapInput is an input type that accepts ConfigurationSetMap and ConfigurationSetMapOutput values. You can construct a concrete instance of `ConfigurationSetMapInput` via: 

ConfigurationSetMap{ "key": ConfigurationSetArgs{...} }

type ConfigurationSetMapOutput 

type ConfigurationSetMapOutput struct{ *pulumi.OutputState }

func (ConfigurationSetMapOutput) ElementType 

func (ConfigurationSetMapOutput) ElementType() reflect.Type

func (ConfigurationSetMapOutput) MapIndex 

func (o ConfigurationSetMapOutput) MapIndex(k pulumi.StringInput) ConfigurationSetOutput

func (ConfigurationSetMapOutput) ToConfigurationSetMapOutput 

func (o ConfigurationSetMapOutput) ToConfigurationSetMapOutput() ConfigurationSetMapOutput

func (ConfigurationSetMapOutput) ToConfigurationSetMapOutputWithContext 

func (o ConfigurationSetMapOutput) ToConfigurationSetMapOutputWithContext(ctx context.Context) ConfigurationSetMapOutput

type ConfigurationSetOutput 

type ConfigurationSetOutput struct{ *pulumi.OutputState }

func (ConfigurationSetOutput) Arn 

func (o ConfigurationSetOutput) Arn() pulumi.StringOutput

SES configuration set ARN.

func (ConfigurationSetOutput) DeliveryOptions 

func (o ConfigurationSetOutput) DeliveryOptions() ConfigurationSetDeliveryOptionsPtrOutput

Whether messages that use the configuration set are required to use TLS. See below.

func (ConfigurationSetOutput) ElementType 

func (ConfigurationSetOutput) ElementType() reflect.Type

func (ConfigurationSetOutput) LastFreshStart 

func (o ConfigurationSetOutput) LastFreshStart() pulumi.StringOutput

Date and time at which the reputation metrics for the configuration set were last reset. Resetting these metrics is known as a fresh start.

func (ConfigurationSetOutput) Name 

func (o ConfigurationSetOutput) Name() pulumi.StringOutput

Name of the configuration set.

The following argument is optional:

func (ConfigurationSetOutput) ReputationMetricsEnabled 

func (o ConfigurationSetOutput) ReputationMetricsEnabled() pulumi.BoolPtrOutput

Whether or not Amazon SES publishes reputation metrics for the configuration set, such as bounce and complaint rates, to Amazon CloudWatch. The default value is `false`.

func (ConfigurationSetOutput) SendingEnabled 

func (o ConfigurationSetOutput) SendingEnabled() pulumi.BoolPtrOutput

Whether email sending is enabled or disabled for the configuration set. The default value is `true`.

func (ConfigurationSetOutput) ToConfigurationSetOutput 

func (o ConfigurationSetOutput) ToConfigurationSetOutput() ConfigurationSetOutput

func (ConfigurationSetOutput) ToConfigurationSetOutputWithContext 

func (o ConfigurationSetOutput) ToConfigurationSetOutputWithContext(ctx context.Context) ConfigurationSetOutput

func (ConfigurationSetOutput) TrackingOptions 

func (o ConfigurationSetOutput) TrackingOptions() ConfigurationSetTrackingOptionsPtrOutput

Domain that is used to redirect email recipients to an Amazon SES-operated domain. See below. **NOTE:** This functionality is best effort.

type ConfigurationSetState 

type ConfigurationSetState struct {
	// SES configuration set ARN.
	Arn pulumi.StringPtrInput
	// Whether messages that use the configuration set are required to use TLS. See below.
	DeliveryOptions ConfigurationSetDeliveryOptionsPtrInput
	// Date and time at which the reputation metrics for the configuration set were last reset. Resetting these metrics is known as a fresh start.
	LastFreshStart pulumi.StringPtrInput
	// Name of the configuration set.
	//
	// The following argument is optional:
	Name pulumi.StringPtrInput
	// Whether or not Amazon SES publishes reputation metrics for the configuration set, such as bounce and complaint rates, to Amazon CloudWatch. The default value is `false`.
	ReputationMetricsEnabled pulumi.BoolPtrInput
	// Whether email sending is enabled or disabled for the configuration set. The default value is `true`.
	SendingEnabled pulumi.BoolPtrInput
	// Domain that is used to redirect email recipients to an Amazon SES-operated domain. See below. **NOTE:** This functionality is best effort.
	TrackingOptions ConfigurationSetTrackingOptionsPtrInput
}

func (ConfigurationSetState) ElementType 

func (ConfigurationSetState) ElementType() reflect.Type

type ConfigurationSetTrackingOptions 

type ConfigurationSetTrackingOptions struct {
	// Custom subdomain that is used to redirect email recipients to the Amazon SES event tracking domain.
	CustomRedirectDomain *string `pulumi:"customRedirectDomain"`
}

type ConfigurationSetTrackingOptionsArgs 

type ConfigurationSetTrackingOptionsArgs struct {
	// Custom subdomain that is used to redirect email recipients to the Amazon SES event tracking domain.
	CustomRedirectDomain pulumi.StringPtrInput `pulumi:"customRedirectDomain"`
}

func (ConfigurationSetTrackingOptionsArgs) ElementType 

func (ConfigurationSetTrackingOptionsArgs) ElementType() reflect.Type

func (ConfigurationSetTrackingOptionsArgs) ToConfigurationSetTrackingOptionsOutput 

func (i ConfigurationSetTrackingOptionsArgs) ToConfigurationSetTrackingOptionsOutput() ConfigurationSetTrackingOptionsOutput

func (ConfigurationSetTrackingOptionsArgs) ToConfigurationSetTrackingOptionsOutputWithContext 

func (i ConfigurationSetTrackingOptionsArgs) ToConfigurationSetTrackingOptionsOutputWithContext(ctx context.Context) ConfigurationSetTrackingOptionsOutput

func (ConfigurationSetTrackingOptionsArgs) ToConfigurationSetTrackingOptionsPtrOutput 

func (i ConfigurationSetTrackingOptionsArgs) ToConfigurationSetTrackingOptionsPtrOutput() ConfigurationSetTrackingOptionsPtrOutput

func (ConfigurationSetTrackingOptionsArgs) ToConfigurationSetTrackingOptionsPtrOutputWithContext 

func (i ConfigurationSetTrackingOptionsArgs) ToConfigurationSetTrackingOptionsPtrOutputWithContext(ctx context.Context) ConfigurationSetTrackingOptionsPtrOutput

type ConfigurationSetTrackingOptionsInput 

type ConfigurationSetTrackingOptionsInput interface {
	pulumi.Input

	ToConfigurationSetTrackingOptionsOutput() ConfigurationSetTrackingOptionsOutput
	ToConfigurationSetTrackingOptionsOutputWithContext(context.Context) ConfigurationSetTrackingOptionsOutput
}

ConfigurationSetTrackingOptionsInput is an input type that accepts ConfigurationSetTrackingOptionsArgs and ConfigurationSetTrackingOptionsOutput values. You can construct a concrete instance of `ConfigurationSetTrackingOptionsInput` via: 

ConfigurationSetTrackingOptionsArgs{...}

type ConfigurationSetTrackingOptionsOutput 

type ConfigurationSetTrackingOptionsOutput struct{ *pulumi.OutputState }

func (ConfigurationSetTrackingOptionsOutput) CustomRedirectDomain 

func (o ConfigurationSetTrackingOptionsOutput) CustomRedirectDomain() pulumi.StringPtrOutput

Custom subdomain that is used to redirect email recipients to the Amazon SES event tracking domain.

func (ConfigurationSetTrackingOptionsOutput) ElementType 

func (ConfigurationSetTrackingOptionsOutput) ElementType() reflect.Type

func (ConfigurationSetTrackingOptionsOutput) ToConfigurationSetTrackingOptionsOutput 

func (o ConfigurationSetTrackingOptionsOutput) ToConfigurationSetTrackingOptionsOutput() ConfigurationSetTrackingOptionsOutput

func (ConfigurationSetTrackingOptionsOutput) ToConfigurationSetTrackingOptionsOutputWithContext 

func (o ConfigurationSetTrackingOptionsOutput) ToConfigurationSetTrackingOptionsOutputWithContext(ctx context.Context) ConfigurationSetTrackingOptionsOutput

func (ConfigurationSetTrackingOptionsOutput) ToConfigurationSetTrackingOptionsPtrOutput 

func (o ConfigurationSetTrackingOptionsOutput) ToConfigurationSetTrackingOptionsPtrOutput() ConfigurationSetTrackingOptionsPtrOutput

func (ConfigurationSetTrackingOptionsOutput) ToConfigurationSetTrackingOptionsPtrOutputWithContext 

func (o ConfigurationSetTrackingOptionsOutput) ToConfigurationSetTrackingOptionsPtrOutputWithContext(ctx context.Context) ConfigurationSetTrackingOptionsPtrOutput

type ConfigurationSetTrackingOptionsPtrInput 

type ConfigurationSetTrackingOptionsPtrInput interface {
	pulumi.Input

	ToConfigurationSetTrackingOptionsPtrOutput() ConfigurationSetTrackingOptionsPtrOutput
	ToConfigurationSetTrackingOptionsPtrOutputWithContext(context.Context) ConfigurationSetTrackingOptionsPtrOutput
}

ConfigurationSetTrackingOptionsPtrInput is an input type that accepts ConfigurationSetTrackingOptionsArgs, ConfigurationSetTrackingOptionsPtr and ConfigurationSetTrackingOptionsPtrOutput values. You can construct a concrete instance of `ConfigurationSetTrackingOptionsPtrInput` via: 

        ConfigurationSetTrackingOptionsArgs{...}

or:

        nil

func ConfigurationSetTrackingOptionsPtr 

func ConfigurationSetTrackingOptionsPtr(v *ConfigurationSetTrackingOptionsArgs) ConfigurationSetTrackingOptionsPtrInput

type ConfigurationSetTrackingOptionsPtrOutput 

type ConfigurationSetTrackingOptionsPtrOutput struct{ *pulumi.OutputState }

func (ConfigurationSetTrackingOptionsPtrOutput) CustomRedirectDomain 

func (o ConfigurationSetTrackingOptionsPtrOutput) CustomRedirectDomain() pulumi.StringPtrOutput

Custom subdomain that is used to redirect email recipients to the Amazon SES event tracking domain.

func (ConfigurationSetTrackingOptionsPtrOutput) Elem 

func (o ConfigurationSetTrackingOptionsPtrOutput) Elem() ConfigurationSetTrackingOptionsOutput

func (ConfigurationSetTrackingOptionsPtrOutput) ElementType 

func (ConfigurationSetTrackingOptionsPtrOutput) ElementType() reflect.Type

func (ConfigurationSetTrackingOptionsPtrOutput) ToConfigurationSetTrackingOptionsPtrOutput 

func (o ConfigurationSetTrackingOptionsPtrOutput) ToConfigurationSetTrackingOptionsPtrOutput() ConfigurationSetTrackingOptionsPtrOutput

func (ConfigurationSetTrackingOptionsPtrOutput) ToConfigurationSetTrackingOptionsPtrOutputWithContext 

func (o ConfigurationSetTrackingOptionsPtrOutput) ToConfigurationSetTrackingOptionsPtrOutputWithContext(ctx context.Context) ConfigurationSetTrackingOptionsPtrOutput

type DomainDkim 

type DomainDkim struct {
	pulumi.CustomResourceState

	// DKIM tokens generated by SES.
	// These tokens should be used to create CNAME records used to verify SES Easy DKIM.
	// See below for an example of how this might be achieved
	// when the domain is hosted in Route 53 and managed by this provider.
	// Find out more about verifying domains in Amazon SES
	// in the [AWS SES docs](http://docs.aws.amazon.com/ses/latest/DeveloperGuide/easy-dkim-dns-records.html).
	DkimTokens pulumi.StringArrayOutput `pulumi:"dkimTokens"`
	// Verified domain name to generate DKIM tokens for.
	Domain pulumi.StringOutput `pulumi:"domain"`
}

Provides an SES domain DKIM generation resource.

Domain ownership needs to be confirmed first using sesDomainIdentity Resource

## Example Usage

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/route53"
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleDomainIdentity, err := ses.NewDomainIdentity(ctx, "exampleDomainIdentity", &ses.DomainIdentityArgs{
			Domain: pulumi.String("example.com"),
		})
		if err != nil {
			return err
		}
		exampleDomainDkim, err := ses.NewDomainDkim(ctx, "exampleDomainDkim", &ses.DomainDkimArgs{
			Domain: exampleDomainIdentity.Domain,
		})
		if err != nil {
			return err
		}
		var exampleAmazonsesDkimRecord []*route53.Record
		for index := 0; index < 3; index++ {
			key0 := index
			val0 := index
			__res, err := route53.NewRecord(ctx, fmt.Sprintf("exampleAmazonsesDkimRecord-%v", key0), &route53.RecordArgs{
				ZoneId: pulumi.String("ABCDEFGHIJ123"),
				Name: exampleDomainDkim.DkimTokens.ApplyT(func(dkimTokens []string) (string, error) {
					return fmt.Sprintf("%v._domainkey", dkimTokens[val0]), nil
				}).(pulumi.StringOutput),
				Type: pulumi.String("CNAME"),
				Ttl:  pulumi.Int(600),
				Records: pulumi.StringArray{
					exampleDomainDkim.DkimTokens.ApplyT(func(dkimTokens []string) (string, error) {
						return fmt.Sprintf("%v.dkim.amazonses.com", dkimTokens[val0]), nil
					}).(pulumi.StringOutput),
				},
			})
			if err != nil {
				return err
			}
			exampleAmazonsesDkimRecord = append(exampleAmazonsesDkimRecord, __res)
		}
		return nil
	})
}

```

## Import

DKIM tokens can be imported using the `domain` attribute, e.g.,

```sh 

$ pulumi import aws:ses/domainDkim:DomainDkim example example.com

```

func GetDomainDkim 

func GetDomainDkim(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *DomainDkimState, opts ...pulumi.ResourceOption) (*DomainDkim, error)

GetDomainDkim gets an existing DomainDkim 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 NewDomainDkim 

func NewDomainDkim(ctx *pulumi.Context,
	name string, args *DomainDkimArgs, opts ...pulumi.ResourceOption) (*DomainDkim, error)

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

func (*DomainDkim) ElementType 

func (*DomainDkim) ElementType() reflect.Type

func (*DomainDkim) ToDomainDkimOutput 

func (i *DomainDkim) ToDomainDkimOutput() DomainDkimOutput

func (*DomainDkim) ToDomainDkimOutputWithContext 

func (i *DomainDkim) ToDomainDkimOutputWithContext(ctx context.Context) DomainDkimOutput

type DomainDkimArgs 

type DomainDkimArgs struct {
	// Verified domain name to generate DKIM tokens for.
	Domain pulumi.StringInput
}

The set of arguments for constructing a DomainDkim resource.

func (DomainDkimArgs) ElementType 

func (DomainDkimArgs) ElementType() reflect.Type

type DomainDkimArray 

type DomainDkimArray []DomainDkimInput

func (DomainDkimArray) ElementType 

func (DomainDkimArray) ElementType() reflect.Type

func (DomainDkimArray) ToDomainDkimArrayOutput 

func (i DomainDkimArray) ToDomainDkimArrayOutput() DomainDkimArrayOutput

func (DomainDkimArray) ToDomainDkimArrayOutputWithContext 

func (i DomainDkimArray) ToDomainDkimArrayOutputWithContext(ctx context.Context) DomainDkimArrayOutput

type DomainDkimArrayInput 

type DomainDkimArrayInput interface {
	pulumi.Input

	ToDomainDkimArrayOutput() DomainDkimArrayOutput
	ToDomainDkimArrayOutputWithContext(context.Context) DomainDkimArrayOutput
}

DomainDkimArrayInput is an input type that accepts DomainDkimArray and DomainDkimArrayOutput values. You can construct a concrete instance of `DomainDkimArrayInput` via: 

DomainDkimArray{ DomainDkimArgs{...} }

type DomainDkimArrayOutput 

type DomainDkimArrayOutput struct{ *pulumi.OutputState }

func (DomainDkimArrayOutput) ElementType 

func (DomainDkimArrayOutput) ElementType() reflect.Type

func (DomainDkimArrayOutput) Index 

func (o DomainDkimArrayOutput) Index(i pulumi.IntInput) DomainDkimOutput

func (DomainDkimArrayOutput) ToDomainDkimArrayOutput 

func (o DomainDkimArrayOutput) ToDomainDkimArrayOutput() DomainDkimArrayOutput

func (DomainDkimArrayOutput) ToDomainDkimArrayOutputWithContext 

func (o DomainDkimArrayOutput) ToDomainDkimArrayOutputWithContext(ctx context.Context) DomainDkimArrayOutput

type DomainDkimInput 

type DomainDkimInput interface {
	pulumi.Input

	ToDomainDkimOutput() DomainDkimOutput
	ToDomainDkimOutputWithContext(ctx context.Context) DomainDkimOutput
}

type DomainDkimMap 

type DomainDkimMap map[string]DomainDkimInput

func (DomainDkimMap) ElementType 

func (DomainDkimMap) ElementType() reflect.Type

func (DomainDkimMap) ToDomainDkimMapOutput 

func (i DomainDkimMap) ToDomainDkimMapOutput() DomainDkimMapOutput

func (DomainDkimMap) ToDomainDkimMapOutputWithContext 

func (i DomainDkimMap) ToDomainDkimMapOutputWithContext(ctx context.Context) DomainDkimMapOutput

type DomainDkimMapInput 

type DomainDkimMapInput interface {
	pulumi.Input

	ToDomainDkimMapOutput() DomainDkimMapOutput
	ToDomainDkimMapOutputWithContext(context.Context) DomainDkimMapOutput
}

DomainDkimMapInput is an input type that accepts DomainDkimMap and DomainDkimMapOutput values. You can construct a concrete instance of `DomainDkimMapInput` via: 

DomainDkimMap{ "key": DomainDkimArgs{...} }

type DomainDkimMapOutput 

type DomainDkimMapOutput struct{ *pulumi.OutputState }

func (DomainDkimMapOutput) ElementType 

func (DomainDkimMapOutput) ElementType() reflect.Type

func (DomainDkimMapOutput) MapIndex 

func (o DomainDkimMapOutput) MapIndex(k pulumi.StringInput) DomainDkimOutput

func (DomainDkimMapOutput) ToDomainDkimMapOutput 

func (o DomainDkimMapOutput) ToDomainDkimMapOutput() DomainDkimMapOutput

func (DomainDkimMapOutput) ToDomainDkimMapOutputWithContext 

func (o DomainDkimMapOutput) ToDomainDkimMapOutputWithContext(ctx context.Context) DomainDkimMapOutput

type DomainDkimOutput 

type DomainDkimOutput struct{ *pulumi.OutputState }

func (DomainDkimOutput) DkimTokens 

func (o DomainDkimOutput) DkimTokens() pulumi.StringArrayOutput

DKIM tokens generated by SES. These tokens should be used to create CNAME records used to verify SES Easy DKIM. See below for an example of how this might be achieved when the domain is hosted in Route 53 and managed by this provider. Find out more about verifying domains in Amazon SES in the [AWS SES docs](http://docs.aws.amazon.com/ses/latest/DeveloperGuide/easy-dkim-dns-records.html).

func (DomainDkimOutput) Domain 

func (o DomainDkimOutput) Domain() pulumi.StringOutput

Verified domain name to generate DKIM tokens for.

func (DomainDkimOutput) ElementType 

func (DomainDkimOutput) ElementType() reflect.Type

func (DomainDkimOutput) ToDomainDkimOutput 

func (o DomainDkimOutput) ToDomainDkimOutput() DomainDkimOutput

func (DomainDkimOutput) ToDomainDkimOutputWithContext 

func (o DomainDkimOutput) ToDomainDkimOutputWithContext(ctx context.Context) DomainDkimOutput

type DomainDkimState 

type DomainDkimState struct {
	// DKIM tokens generated by SES.
	// These tokens should be used to create CNAME records used to verify SES Easy DKIM.
	// See below for an example of how this might be achieved
	// when the domain is hosted in Route 53 and managed by this provider.
	// Find out more about verifying domains in Amazon SES
	// in the [AWS SES docs](http://docs.aws.amazon.com/ses/latest/DeveloperGuide/easy-dkim-dns-records.html).
	DkimTokens pulumi.StringArrayInput
	// Verified domain name to generate DKIM tokens for.
	Domain pulumi.StringPtrInput
}

func (DomainDkimState) ElementType 

func (DomainDkimState) ElementType() reflect.Type

type DomainIdentity 

type DomainIdentity struct {
	pulumi.CustomResourceState

	// The ARN of the domain identity.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The domain name to assign to SES
	Domain pulumi.StringOutput `pulumi:"domain"`
	// A code which when added to the domain as a TXT record
	// will signal to SES that the owner of the domain has authorised SES to act on
	// their behalf. The domain identity will be in state "verification pending"
	// until this is done. See the With Route53 Record example
	// for how this might be achieved when the domain is hosted in Route 53 and
	// managed by this provider.  Find out more about verifying domains in Amazon
	// SES in the [AWS SES
	// docs](http://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-domains.html).
	VerificationToken pulumi.StringOutput `pulumi:"verificationToken"`
}

Provides an SES domain identity resource

## Example Usage ### Basic Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ses.NewDomainIdentity(ctx, "example", &ses.DomainIdentityArgs{
			Domain: pulumi.String("example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### With Route53 Record

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/route53"
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := ses.NewDomainIdentity(ctx, "example", &ses.DomainIdentityArgs{
			Domain: pulumi.String("example.com"),
		})
		if err != nil {
			return err
		}
		_, err = route53.NewRecord(ctx, "exampleAmazonsesVerificationRecord", &route53.RecordArgs{
			ZoneId: pulumi.String("ABCDEFGHIJ123"),
			Name:   pulumi.String("_amazonses.example.com"),
			Type:   pulumi.String("TXT"),
			Ttl:    pulumi.Int(600),
			Records: pulumi.StringArray{
				example.VerificationToken,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

SES domain identities can be imported using the domain name.

```sh 

$ pulumi import aws:ses/domainIdentity:DomainIdentity example example.com

```

func GetDomainIdentity 

func GetDomainIdentity(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *DomainIdentityState, opts ...pulumi.ResourceOption) (*DomainIdentity, error)

GetDomainIdentity gets an existing DomainIdentity 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 NewDomainIdentity 

func NewDomainIdentity(ctx *pulumi.Context,
	name string, args *DomainIdentityArgs, opts ...pulumi.ResourceOption) (*DomainIdentity, error)

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

func (*DomainIdentity) ElementType 

func (*DomainIdentity) ElementType() reflect.Type

func (*DomainIdentity) ToDomainIdentityOutput 

func (i *DomainIdentity) ToDomainIdentityOutput() DomainIdentityOutput

func (*DomainIdentity) ToDomainIdentityOutputWithContext 

func (i *DomainIdentity) ToDomainIdentityOutputWithContext(ctx context.Context) DomainIdentityOutput

type DomainIdentityArgs 

type DomainIdentityArgs struct {
	// The domain name to assign to SES
	Domain pulumi.StringInput
}

The set of arguments for constructing a DomainIdentity resource.

func (DomainIdentityArgs) ElementType 

func (DomainIdentityArgs) ElementType() reflect.Type

type DomainIdentityArray 

type DomainIdentityArray []DomainIdentityInput

func (DomainIdentityArray) ElementType 

func (DomainIdentityArray) ElementType() reflect.Type

func (DomainIdentityArray) ToDomainIdentityArrayOutput 

func (i DomainIdentityArray) ToDomainIdentityArrayOutput() DomainIdentityArrayOutput

func (DomainIdentityArray) ToDomainIdentityArrayOutputWithContext 

func (i DomainIdentityArray) ToDomainIdentityArrayOutputWithContext(ctx context.Context) DomainIdentityArrayOutput

type DomainIdentityArrayInput 

type DomainIdentityArrayInput interface {
	pulumi.Input

	ToDomainIdentityArrayOutput() DomainIdentityArrayOutput
	ToDomainIdentityArrayOutputWithContext(context.Context) DomainIdentityArrayOutput
}

DomainIdentityArrayInput is an input type that accepts DomainIdentityArray and DomainIdentityArrayOutput values. You can construct a concrete instance of `DomainIdentityArrayInput` via: 

DomainIdentityArray{ DomainIdentityArgs{...} }

type DomainIdentityArrayOutput 

type DomainIdentityArrayOutput struct{ *pulumi.OutputState }

func (DomainIdentityArrayOutput) ElementType 

func (DomainIdentityArrayOutput) ElementType() reflect.Type

func (DomainIdentityArrayOutput) Index 

func (o DomainIdentityArrayOutput) Index(i pulumi.IntInput) DomainIdentityOutput

func (DomainIdentityArrayOutput) ToDomainIdentityArrayOutput 

func (o DomainIdentityArrayOutput) ToDomainIdentityArrayOutput() DomainIdentityArrayOutput

func (DomainIdentityArrayOutput) ToDomainIdentityArrayOutputWithContext 

func (o DomainIdentityArrayOutput) ToDomainIdentityArrayOutputWithContext(ctx context.Context) DomainIdentityArrayOutput

type DomainIdentityInput 

type DomainIdentityInput interface {
	pulumi.Input

	ToDomainIdentityOutput() DomainIdentityOutput
	ToDomainIdentityOutputWithContext(ctx context.Context) DomainIdentityOutput
}

type DomainIdentityMap 

type DomainIdentityMap map[string]DomainIdentityInput

func (DomainIdentityMap) ElementType 

func (DomainIdentityMap) ElementType() reflect.Type

func (DomainIdentityMap) ToDomainIdentityMapOutput 

func (i DomainIdentityMap) ToDomainIdentityMapOutput() DomainIdentityMapOutput

func (DomainIdentityMap) ToDomainIdentityMapOutputWithContext 

func (i DomainIdentityMap) ToDomainIdentityMapOutputWithContext(ctx context.Context) DomainIdentityMapOutput

type DomainIdentityMapInput 

type DomainIdentityMapInput interface {
	pulumi.Input

	ToDomainIdentityMapOutput() DomainIdentityMapOutput
	ToDomainIdentityMapOutputWithContext(context.Context) DomainIdentityMapOutput
}

DomainIdentityMapInput is an input type that accepts DomainIdentityMap and DomainIdentityMapOutput values. You can construct a concrete instance of `DomainIdentityMapInput` via: 

DomainIdentityMap{ "key": DomainIdentityArgs{...} }

type DomainIdentityMapOutput 

type DomainIdentityMapOutput struct{ *pulumi.OutputState }

func (DomainIdentityMapOutput) ElementType 

func (DomainIdentityMapOutput) ElementType() reflect.Type

func (DomainIdentityMapOutput) MapIndex 

func (o DomainIdentityMapOutput) MapIndex(k pulumi.StringInput) DomainIdentityOutput

func (DomainIdentityMapOutput) ToDomainIdentityMapOutput 

func (o DomainIdentityMapOutput) ToDomainIdentityMapOutput() DomainIdentityMapOutput

func (DomainIdentityMapOutput) ToDomainIdentityMapOutputWithContext 

func (o DomainIdentityMapOutput) ToDomainIdentityMapOutputWithContext(ctx context.Context) DomainIdentityMapOutput

type DomainIdentityOutput 

type DomainIdentityOutput struct{ *pulumi.OutputState }

func (DomainIdentityOutput) Arn 

func (o DomainIdentityOutput) Arn() pulumi.StringOutput

The ARN of the domain identity.

func (DomainIdentityOutput) Domain 

func (o DomainIdentityOutput) Domain() pulumi.StringOutput

The domain name to assign to SES

func (DomainIdentityOutput) ElementType 

func (DomainIdentityOutput) ElementType() reflect.Type

func (DomainIdentityOutput) ToDomainIdentityOutput 

func (o DomainIdentityOutput) ToDomainIdentityOutput() DomainIdentityOutput

func (DomainIdentityOutput) ToDomainIdentityOutputWithContext 

func (o DomainIdentityOutput) ToDomainIdentityOutputWithContext(ctx context.Context) DomainIdentityOutput

func (DomainIdentityOutput) VerificationToken 

func (o DomainIdentityOutput) VerificationToken() pulumi.StringOutput

A code which when added to the domain as a TXT record will signal to SES that the owner of the domain has authorised SES to act on their behalf. The domain identity will be in state "verification pending" until this is done. See the With Route53 Record example for how this might be achieved when the domain is hosted in Route 53 and managed by this provider. Find out more about verifying domains in Amazon SES in the [AWS SES docs](http://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-domains.html).

type DomainIdentityState 

type DomainIdentityState struct {
	// The ARN of the domain identity.
	Arn pulumi.StringPtrInput
	// The domain name to assign to SES
	Domain pulumi.StringPtrInput
	// A code which when added to the domain as a TXT record
	// will signal to SES that the owner of the domain has authorised SES to act on
	// their behalf. The domain identity will be in state "verification pending"
	// until this is done. See the With Route53 Record example
	// for how this might be achieved when the domain is hosted in Route 53 and
	// managed by this provider.  Find out more about verifying domains in Amazon
	// SES in the [AWS SES
	// docs](http://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-domains.html).
	VerificationToken pulumi.StringPtrInput
}

func (DomainIdentityState) ElementType 

func (DomainIdentityState) ElementType() reflect.Type

type DomainIdentityVerification 

type DomainIdentityVerification struct {
	pulumi.CustomResourceState

	// The ARN of the domain identity.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The domain name of the SES domain identity to verify.
	Domain pulumi.StringOutput `pulumi:"domain"`
}

Represents a successful verification of an SES domain identity.

Most commonly, this resource is used together with `route53.Record` and `ses.DomainIdentity` to request an SES domain identity, deploy the required DNS verification records, and wait for verification to complete.

> **WARNING:** This resource implements a part of the verification workflow. It does not represent a real-world entity in AWS, therefore changing or deleting this resource on its own has no immediate effect.

## Example Usage

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/route53"
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := ses.NewDomainIdentity(ctx, "example", &ses.DomainIdentityArgs{
			Domain: pulumi.String("example.com"),
		})
		if err != nil {
			return err
		}
		exampleAmazonsesVerificationRecord, err := route53.NewRecord(ctx, "exampleAmazonsesVerificationRecord", &route53.RecordArgs{
			ZoneId: pulumi.Any(aws_route53_zone.Example.Zone_id),
			Name: example.ID().ApplyT(func(id string) (string, error) {
				return fmt.Sprintf("_amazonses.%v", id), nil
			}).(pulumi.StringOutput),
			Type: pulumi.String("TXT"),
			Ttl:  pulumi.Int(600),
			Records: pulumi.StringArray{
				example.VerificationToken,
			},
		})
		if err != nil {
			return err
		}
		_, err = ses.NewDomainIdentityVerification(ctx, "exampleVerification", &ses.DomainIdentityVerificationArgs{
			Domain: example.ID(),
		}, pulumi.DependsOn([]pulumi.Resource{
			exampleAmazonsesVerificationRecord,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetDomainIdentityVerification 

func GetDomainIdentityVerification(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *DomainIdentityVerificationState, opts ...pulumi.ResourceOption) (*DomainIdentityVerification, error)

GetDomainIdentityVerification gets an existing DomainIdentityVerification 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 NewDomainIdentityVerification 

func NewDomainIdentityVerification(ctx *pulumi.Context,
	name string, args *DomainIdentityVerificationArgs, opts ...pulumi.ResourceOption) (*DomainIdentityVerification, error)

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

func (*DomainIdentityVerification) ElementType 

func (*DomainIdentityVerification) ElementType() reflect.Type

func (*DomainIdentityVerification) ToDomainIdentityVerificationOutput 

func (i *DomainIdentityVerification) ToDomainIdentityVerificationOutput() DomainIdentityVerificationOutput

func (*DomainIdentityVerification) ToDomainIdentityVerificationOutputWithContext 

func (i *DomainIdentityVerification) ToDomainIdentityVerificationOutputWithContext(ctx context.Context) DomainIdentityVerificationOutput

type DomainIdentityVerificationArgs 

type DomainIdentityVerificationArgs struct {
	// The domain name of the SES domain identity to verify.
	Domain pulumi.StringInput
}

The set of arguments for constructing a DomainIdentityVerification resource.

func (DomainIdentityVerificationArgs) ElementType 

func (DomainIdentityVerificationArgs) ElementType() reflect.Type

type DomainIdentityVerificationArray 

type DomainIdentityVerificationArray []DomainIdentityVerificationInput

func (DomainIdentityVerificationArray) ElementType 

func (DomainIdentityVerificationArray) ElementType() reflect.Type

func (DomainIdentityVerificationArray) ToDomainIdentityVerificationArrayOutput 

func (i DomainIdentityVerificationArray) ToDomainIdentityVerificationArrayOutput() DomainIdentityVerificationArrayOutput

func (DomainIdentityVerificationArray) ToDomainIdentityVerificationArrayOutputWithContext 

func (i DomainIdentityVerificationArray) ToDomainIdentityVerificationArrayOutputWithContext(ctx context.Context) DomainIdentityVerificationArrayOutput

type DomainIdentityVerificationArrayInput 

type DomainIdentityVerificationArrayInput interface {
	pulumi.Input

	ToDomainIdentityVerificationArrayOutput() DomainIdentityVerificationArrayOutput
	ToDomainIdentityVerificationArrayOutputWithContext(context.Context) DomainIdentityVerificationArrayOutput
}

DomainIdentityVerificationArrayInput is an input type that accepts DomainIdentityVerificationArray and DomainIdentityVerificationArrayOutput values. You can construct a concrete instance of `DomainIdentityVerificationArrayInput` via: 

DomainIdentityVerificationArray{ DomainIdentityVerificationArgs{...} }

type DomainIdentityVerificationArrayOutput 

type DomainIdentityVerificationArrayOutput struct{ *pulumi.OutputState }

func (DomainIdentityVerificationArrayOutput) ElementType 

func (DomainIdentityVerificationArrayOutput) ElementType() reflect.Type

func (DomainIdentityVerificationArrayOutput) Index 

func (o DomainIdentityVerificationArrayOutput) Index(i pulumi.IntInput) DomainIdentityVerificationOutput

func (DomainIdentityVerificationArrayOutput) ToDomainIdentityVerificationArrayOutput 

func (o DomainIdentityVerificationArrayOutput) ToDomainIdentityVerificationArrayOutput() DomainIdentityVerificationArrayOutput

func (DomainIdentityVerificationArrayOutput) ToDomainIdentityVerificationArrayOutputWithContext 

func (o DomainIdentityVerificationArrayOutput) ToDomainIdentityVerificationArrayOutputWithContext(ctx context.Context) DomainIdentityVerificationArrayOutput

type DomainIdentityVerificationInput 

type DomainIdentityVerificationInput interface {
	pulumi.Input

	ToDomainIdentityVerificationOutput() DomainIdentityVerificationOutput
	ToDomainIdentityVerificationOutputWithContext(ctx context.Context) DomainIdentityVerificationOutput
}

type DomainIdentityVerificationMap 

type DomainIdentityVerificationMap map[string]DomainIdentityVerificationInput

func (DomainIdentityVerificationMap) ElementType 

func (DomainIdentityVerificationMap) ElementType() reflect.Type

func (DomainIdentityVerificationMap) ToDomainIdentityVerificationMapOutput 

func (i DomainIdentityVerificationMap) ToDomainIdentityVerificationMapOutput() DomainIdentityVerificationMapOutput

func (DomainIdentityVerificationMap) ToDomainIdentityVerificationMapOutputWithContext 

func (i DomainIdentityVerificationMap) ToDomainIdentityVerificationMapOutputWithContext(ctx context.Context) DomainIdentityVerificationMapOutput

type DomainIdentityVerificationMapInput 

type DomainIdentityVerificationMapInput interface {
	pulumi.Input

	ToDomainIdentityVerificationMapOutput() DomainIdentityVerificationMapOutput
	ToDomainIdentityVerificationMapOutputWithContext(context.Context) DomainIdentityVerificationMapOutput
}

DomainIdentityVerificationMapInput is an input type that accepts DomainIdentityVerificationMap and DomainIdentityVerificationMapOutput values. You can construct a concrete instance of `DomainIdentityVerificationMapInput` via: 

DomainIdentityVerificationMap{ "key": DomainIdentityVerificationArgs{...} }

type DomainIdentityVerificationMapOutput 

type DomainIdentityVerificationMapOutput struct{ *pulumi.OutputState }

func (DomainIdentityVerificationMapOutput) ElementType 

func (DomainIdentityVerificationMapOutput) ElementType() reflect.Type

func (DomainIdentityVerificationMapOutput) MapIndex 

func (o DomainIdentityVerificationMapOutput) MapIndex(k pulumi.StringInput) DomainIdentityVerificationOutput

func (DomainIdentityVerificationMapOutput) ToDomainIdentityVerificationMapOutput 

func (o DomainIdentityVerificationMapOutput) ToDomainIdentityVerificationMapOutput() DomainIdentityVerificationMapOutput

func (DomainIdentityVerificationMapOutput) ToDomainIdentityVerificationMapOutputWithContext 

func (o DomainIdentityVerificationMapOutput) ToDomainIdentityVerificationMapOutputWithContext(ctx context.Context) DomainIdentityVerificationMapOutput

type DomainIdentityVerificationOutput 

type DomainIdentityVerificationOutput struct{ *pulumi.OutputState }

func (DomainIdentityVerificationOutput) Arn 

func (o DomainIdentityVerificationOutput) Arn() pulumi.StringOutput

The ARN of the domain identity.

func (DomainIdentityVerificationOutput) Domain 

func (o DomainIdentityVerificationOutput) Domain() pulumi.StringOutput

The domain name of the SES domain identity to verify.

func (DomainIdentityVerificationOutput) ElementType 

func (DomainIdentityVerificationOutput) ElementType() reflect.Type

func (DomainIdentityVerificationOutput) ToDomainIdentityVerificationOutput 

func (o DomainIdentityVerificationOutput) ToDomainIdentityVerificationOutput() DomainIdentityVerificationOutput

func (DomainIdentityVerificationOutput) ToDomainIdentityVerificationOutputWithContext 

func (o DomainIdentityVerificationOutput) ToDomainIdentityVerificationOutputWithContext(ctx context.Context) DomainIdentityVerificationOutput

type DomainIdentityVerificationState 

type DomainIdentityVerificationState struct {
	// The ARN of the domain identity.
	Arn pulumi.StringPtrInput
	// The domain name of the SES domain identity to verify.
	Domain pulumi.StringPtrInput
}

func (DomainIdentityVerificationState) ElementType 

func (DomainIdentityVerificationState) ElementType() reflect.Type

type EmailIdentity 

type EmailIdentity struct {
	pulumi.CustomResourceState

	// The ARN of the email identity.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The email address to assign to SES.
	Email pulumi.StringOutput `pulumi:"email"`
}

Provides an SES email identity resource

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ses.NewEmailIdentity(ctx, "example", &ses.EmailIdentityArgs{
			Email: pulumi.String("email@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

SES email identities can be imported using the email address.

```sh 

$ pulumi import aws:ses/emailIdentity:EmailIdentity example email@example.com

```

func GetEmailIdentity 

func GetEmailIdentity(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *EmailIdentityState, opts ...pulumi.ResourceOption) (*EmailIdentity, error)

GetEmailIdentity gets an existing EmailIdentity 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 NewEmailIdentity 

func NewEmailIdentity(ctx *pulumi.Context,
	name string, args *EmailIdentityArgs, opts ...pulumi.ResourceOption) (*EmailIdentity, error)

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

func (*EmailIdentity) ElementType 

func (*EmailIdentity) ElementType() reflect.Type

func (*EmailIdentity) ToEmailIdentityOutput 

func (i *EmailIdentity) ToEmailIdentityOutput() EmailIdentityOutput

func (*EmailIdentity) ToEmailIdentityOutputWithContext 

func (i *EmailIdentity) ToEmailIdentityOutputWithContext(ctx context.Context) EmailIdentityOutput

type EmailIdentityArgs 

type EmailIdentityArgs struct {
	// The email address to assign to SES.
	Email pulumi.StringInput
}

The set of arguments for constructing a EmailIdentity resource.

func (EmailIdentityArgs) ElementType 

func (EmailIdentityArgs) ElementType() reflect.Type

type EmailIdentityArray 

type EmailIdentityArray []EmailIdentityInput

func (EmailIdentityArray) ElementType 

func (EmailIdentityArray) ElementType() reflect.Type

func (EmailIdentityArray) ToEmailIdentityArrayOutput 

func (i EmailIdentityArray) ToEmailIdentityArrayOutput() EmailIdentityArrayOutput

func (EmailIdentityArray) ToEmailIdentityArrayOutputWithContext 

func (i EmailIdentityArray) ToEmailIdentityArrayOutputWithContext(ctx context.Context) EmailIdentityArrayOutput

type EmailIdentityArrayInput 

type EmailIdentityArrayInput interface {
	pulumi.Input

	ToEmailIdentityArrayOutput() EmailIdentityArrayOutput
	ToEmailIdentityArrayOutputWithContext(context.Context) EmailIdentityArrayOutput
}

EmailIdentityArrayInput is an input type that accepts EmailIdentityArray and EmailIdentityArrayOutput values. You can construct a concrete instance of `EmailIdentityArrayInput` via: 

EmailIdentityArray{ EmailIdentityArgs{...} }

type EmailIdentityArrayOutput 

type EmailIdentityArrayOutput struct{ *pulumi.OutputState }

func (EmailIdentityArrayOutput) ElementType 

func (EmailIdentityArrayOutput) ElementType() reflect.Type

func (EmailIdentityArrayOutput) Index 

func (o EmailIdentityArrayOutput) Index(i pulumi.IntInput) EmailIdentityOutput

func (EmailIdentityArrayOutput) ToEmailIdentityArrayOutput 

func (o EmailIdentityArrayOutput) ToEmailIdentityArrayOutput() EmailIdentityArrayOutput

func (EmailIdentityArrayOutput) ToEmailIdentityArrayOutputWithContext 

func (o EmailIdentityArrayOutput) ToEmailIdentityArrayOutputWithContext(ctx context.Context) EmailIdentityArrayOutput

type EmailIdentityInput 

type EmailIdentityInput interface {
	pulumi.Input

	ToEmailIdentityOutput() EmailIdentityOutput
	ToEmailIdentityOutputWithContext(ctx context.Context) EmailIdentityOutput
}

type EmailIdentityMap 

type EmailIdentityMap map[string]EmailIdentityInput

func (EmailIdentityMap) ElementType 

func (EmailIdentityMap) ElementType() reflect.Type

func (EmailIdentityMap) ToEmailIdentityMapOutput 

func (i EmailIdentityMap) ToEmailIdentityMapOutput() EmailIdentityMapOutput

func (EmailIdentityMap) ToEmailIdentityMapOutputWithContext 

func (i EmailIdentityMap) ToEmailIdentityMapOutputWithContext(ctx context.Context) EmailIdentityMapOutput

type EmailIdentityMapInput 

type EmailIdentityMapInput interface {
	pulumi.Input

	ToEmailIdentityMapOutput() EmailIdentityMapOutput
	ToEmailIdentityMapOutputWithContext(context.Context) EmailIdentityMapOutput
}

EmailIdentityMapInput is an input type that accepts EmailIdentityMap and EmailIdentityMapOutput values. You can construct a concrete instance of `EmailIdentityMapInput` via: 

EmailIdentityMap{ "key": EmailIdentityArgs{...} }

type EmailIdentityMapOutput 

type EmailIdentityMapOutput struct{ *pulumi.OutputState }

func (EmailIdentityMapOutput) ElementType 

func (EmailIdentityMapOutput) ElementType() reflect.Type

func (EmailIdentityMapOutput) MapIndex 

func (o EmailIdentityMapOutput) MapIndex(k pulumi.StringInput) EmailIdentityOutput

func (EmailIdentityMapOutput) ToEmailIdentityMapOutput 

func (o EmailIdentityMapOutput) ToEmailIdentityMapOutput() EmailIdentityMapOutput

func (EmailIdentityMapOutput) ToEmailIdentityMapOutputWithContext 

func (o EmailIdentityMapOutput) ToEmailIdentityMapOutputWithContext(ctx context.Context) EmailIdentityMapOutput

type EmailIdentityOutput 

type EmailIdentityOutput struct{ *pulumi.OutputState }

func (EmailIdentityOutput) Arn 

func (o EmailIdentityOutput) Arn() pulumi.StringOutput

The ARN of the email identity.

func (EmailIdentityOutput) ElementType 

func (EmailIdentityOutput) ElementType() reflect.Type

func (EmailIdentityOutput) Email 

func (o EmailIdentityOutput) Email() pulumi.StringOutput

The email address to assign to SES.

func (EmailIdentityOutput) ToEmailIdentityOutput 

func (o EmailIdentityOutput) ToEmailIdentityOutput() EmailIdentityOutput

func (EmailIdentityOutput) ToEmailIdentityOutputWithContext 

func (o EmailIdentityOutput) ToEmailIdentityOutputWithContext(ctx context.Context) EmailIdentityOutput

type EmailIdentityState 

type EmailIdentityState struct {
	// The ARN of the email identity.
	Arn pulumi.StringPtrInput
	// The email address to assign to SES.
	Email pulumi.StringPtrInput
}

func (EmailIdentityState) ElementType 

func (EmailIdentityState) ElementType() reflect.Type

type EventDestination 

type EventDestination struct {
	pulumi.CustomResourceState

	// The SES event destination ARN.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// CloudWatch destination for the events
	CloudwatchDestinations EventDestinationCloudwatchDestinationArrayOutput `pulumi:"cloudwatchDestinations"`
	// The name of the configuration set
	ConfigurationSetName pulumi.StringOutput `pulumi:"configurationSetName"`
	// If true, the event destination will be enabled
	Enabled pulumi.BoolPtrOutput `pulumi:"enabled"`
	// Send the events to a kinesis firehose destination
	KinesisDestination EventDestinationKinesisDestinationPtrOutput `pulumi:"kinesisDestination"`
	// A list of matching types. May be any of `"send"`, `"reject"`, `"bounce"`, `"complaint"`, `"delivery"`, `"open"`, `"click"`, or `"renderingFailure"`.
	MatchingTypes pulumi.StringArrayOutput `pulumi:"matchingTypes"`
	// The name of the event destination
	Name pulumi.StringOutput `pulumi:"name"`
	// Send the events to an SNS Topic destination
	//
	// > **NOTE:** You can specify `"cloudwatchDestination"` or `"kinesisDestination"` but not both
	SnsDestination EventDestinationSnsDestinationPtrOutput `pulumi:"snsDestination"`
}

Provides an SES event destination

## Example Usage ### CloudWatch Destination

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ses.NewEventDestination(ctx, "cloudwatch", &ses.EventDestinationArgs{
			ConfigurationSetName: pulumi.Any(aws_ses_configuration_set.Example.Name),
			Enabled:              pulumi.Bool(true),
			MatchingTypes: pulumi.StringArray{
				pulumi.String("bounce"),
				pulumi.String("send"),
			},
			CloudwatchDestinations: ses.EventDestinationCloudwatchDestinationArray{
				&ses.EventDestinationCloudwatchDestinationArgs{
					DefaultValue:  pulumi.String("default"),
					DimensionName: pulumi.String("dimension"),
					ValueSource:   pulumi.String("emailHeader"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Kinesis Destination

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ses.NewEventDestination(ctx, "kinesis", &ses.EventDestinationArgs{
			ConfigurationSetName: pulumi.Any(aws_ses_configuration_set.Example.Name),
			Enabled:              pulumi.Bool(true),
			MatchingTypes: pulumi.StringArray{
				pulumi.String("bounce"),
				pulumi.String("send"),
			},
			KinesisDestination: &ses.EventDestinationKinesisDestinationArgs{
				StreamArn: pulumi.Any(aws_kinesis_firehose_delivery_stream.Example.Arn),
				RoleArn:   pulumi.Any(aws_iam_role.Example.Arn),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### SNS Destination

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ses.NewEventDestination(ctx, "sns", &ses.EventDestinationArgs{
			ConfigurationSetName: pulumi.Any(aws_ses_configuration_set.Example.Name),
			Enabled:              pulumi.Bool(true),
			MatchingTypes: pulumi.StringArray{
				pulumi.String("bounce"),
				pulumi.String("send"),
			},
			SnsDestination: &ses.EventDestinationSnsDestinationArgs{
				TopicArn: pulumi.Any(aws_sns_topic.Example.Arn),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

SES event destinations can be imported using `configuration_set_name` together with the event destination's `name`, e.g.,

```sh 

$ pulumi import aws:ses/eventDestination:EventDestination sns some-configuration-set-test/event-destination-sns

```

func GetEventDestination 

func GetEventDestination(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *EventDestinationState, opts ...pulumi.ResourceOption) (*EventDestination, error)

GetEventDestination gets an existing EventDestination 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 NewEventDestination 

func NewEventDestination(ctx *pulumi.Context,
	name string, args *EventDestinationArgs, opts ...pulumi.ResourceOption) (*EventDestination, error)

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

func (*EventDestination) ElementType 

func (*EventDestination) ElementType() reflect.Type

func (*EventDestination) ToEventDestinationOutput 

func (i *EventDestination) ToEventDestinationOutput() EventDestinationOutput

func (*EventDestination) ToEventDestinationOutputWithContext 

func (i *EventDestination) ToEventDestinationOutputWithContext(ctx context.Context) EventDestinationOutput

type EventDestinationArgs 

type EventDestinationArgs struct {
	// CloudWatch destination for the events
	CloudwatchDestinations EventDestinationCloudwatchDestinationArrayInput
	// The name of the configuration set
	ConfigurationSetName pulumi.StringInput
	// If true, the event destination will be enabled
	Enabled pulumi.BoolPtrInput
	// Send the events to a kinesis firehose destination
	KinesisDestination EventDestinationKinesisDestinationPtrInput
	// A list of matching types. May be any of `"send"`, `"reject"`, `"bounce"`, `"complaint"`, `"delivery"`, `"open"`, `"click"`, or `"renderingFailure"`.
	MatchingTypes pulumi.StringArrayInput
	// The name of the event destination
	Name pulumi.StringPtrInput
	// Send the events to an SNS Topic destination
	//
	// > **NOTE:** You can specify `"cloudwatchDestination"` or `"kinesisDestination"` but not both
	SnsDestination EventDestinationSnsDestinationPtrInput
}

The set of arguments for constructing a EventDestination resource.

func (EventDestinationArgs) ElementType 

func (EventDestinationArgs) ElementType() reflect.Type

type EventDestinationArray 

type EventDestinationArray []EventDestinationInput

func (EventDestinationArray) ElementType 

func (EventDestinationArray) ElementType() reflect.Type

func (EventDestinationArray) ToEventDestinationArrayOutput 

func (i EventDestinationArray) ToEventDestinationArrayOutput() EventDestinationArrayOutput

func (EventDestinationArray) ToEventDestinationArrayOutputWithContext 

func (i EventDestinationArray) ToEventDestinationArrayOutputWithContext(ctx context.Context) EventDestinationArrayOutput

type EventDestinationArrayInput 

type EventDestinationArrayInput interface {
	pulumi.Input

	ToEventDestinationArrayOutput() EventDestinationArrayOutput
	ToEventDestinationArrayOutputWithContext(context.Context) EventDestinationArrayOutput
}

EventDestinationArrayInput is an input type that accepts EventDestinationArray and EventDestinationArrayOutput values. You can construct a concrete instance of `EventDestinationArrayInput` via: 

EventDestinationArray{ EventDestinationArgs{...} }

type EventDestinationArrayOutput 

type EventDestinationArrayOutput struct{ *pulumi.OutputState }

func (EventDestinationArrayOutput) ElementType 

func (EventDestinationArrayOutput) ElementType() reflect.Type

func (EventDestinationArrayOutput) Index 

func (o EventDestinationArrayOutput) Index(i pulumi.IntInput) EventDestinationOutput

func (EventDestinationArrayOutput) ToEventDestinationArrayOutput 

func (o EventDestinationArrayOutput) ToEventDestinationArrayOutput() EventDestinationArrayOutput

func (EventDestinationArrayOutput) ToEventDestinationArrayOutputWithContext 

func (o EventDestinationArrayOutput) ToEventDestinationArrayOutputWithContext(ctx context.Context) EventDestinationArrayOutput

type EventDestinationCloudwatchDestination 

type EventDestinationCloudwatchDestination struct {
	// The default value for the event
	DefaultValue string `pulumi:"defaultValue"`
	// The name for the dimension
	DimensionName string `pulumi:"dimensionName"`
	// The source for the value. May be any of `"messageTag"`, `"emailHeader"` or `"linkTag"`.
	ValueSource string `pulumi:"valueSource"`
}

type EventDestinationCloudwatchDestinationArgs 

type EventDestinationCloudwatchDestinationArgs struct {
	// The default value for the event
	DefaultValue pulumi.StringInput `pulumi:"defaultValue"`
	// The name for the dimension
	DimensionName pulumi.StringInput `pulumi:"dimensionName"`
	// The source for the value. May be any of `"messageTag"`, `"emailHeader"` or `"linkTag"`.
	ValueSource pulumi.StringInput `pulumi:"valueSource"`
}

func (EventDestinationCloudwatchDestinationArgs) ElementType 

func (EventDestinationCloudwatchDestinationArgs) ElementType() reflect.Type

func (EventDestinationCloudwatchDestinationArgs) ToEventDestinationCloudwatchDestinationOutput 

func (i EventDestinationCloudwatchDestinationArgs) ToEventDestinationCloudwatchDestinationOutput() EventDestinationCloudwatchDestinationOutput

func (EventDestinationCloudwatchDestinationArgs) ToEventDestinationCloudwatchDestinationOutputWithContext 

func (i EventDestinationCloudwatchDestinationArgs) ToEventDestinationCloudwatchDestinationOutputWithContext(ctx context.Context) EventDestinationCloudwatchDestinationOutput

type EventDestinationCloudwatchDestinationArray 

type EventDestinationCloudwatchDestinationArray []EventDestinationCloudwatchDestinationInput

func (EventDestinationCloudwatchDestinationArray) ElementType 

func (EventDestinationCloudwatchDestinationArray) ElementType() reflect.Type

func (EventDestinationCloudwatchDestinationArray) ToEventDestinationCloudwatchDestinationArrayOutput 

func (i EventDestinationCloudwatchDestinationArray) ToEventDestinationCloudwatchDestinationArrayOutput() EventDestinationCloudwatchDestinationArrayOutput

func (EventDestinationCloudwatchDestinationArray) ToEventDestinationCloudwatchDestinationArrayOutputWithContext 

func (i EventDestinationCloudwatchDestinationArray) ToEventDestinationCloudwatchDestinationArrayOutputWithContext(ctx context.Context) EventDestinationCloudwatchDestinationArrayOutput

type EventDestinationCloudwatchDestinationArrayInput 

type EventDestinationCloudwatchDestinationArrayInput interface {
	pulumi.Input

	ToEventDestinationCloudwatchDestinationArrayOutput() EventDestinationCloudwatchDestinationArrayOutput
	ToEventDestinationCloudwatchDestinationArrayOutputWithContext(context.Context) EventDestinationCloudwatchDestinationArrayOutput
}

EventDestinationCloudwatchDestinationArrayInput is an input type that accepts EventDestinationCloudwatchDestinationArray and EventDestinationCloudwatchDestinationArrayOutput values. You can construct a concrete instance of `EventDestinationCloudwatchDestinationArrayInput` via: 

EventDestinationCloudwatchDestinationArray{ EventDestinationCloudwatchDestinationArgs{...} }

type EventDestinationCloudwatchDestinationArrayOutput 

type EventDestinationCloudwatchDestinationArrayOutput struct{ *pulumi.OutputState }

func (EventDestinationCloudwatchDestinationArrayOutput) ElementType 

func (EventDestinationCloudwatchDestinationArrayOutput) ElementType() reflect.Type

func (EventDestinationCloudwatchDestinationArrayOutput) Index 

func (o EventDestinationCloudwatchDestinationArrayOutput) Index(i pulumi.IntInput) EventDestinationCloudwatchDestinationOutput

func (EventDestinationCloudwatchDestinationArrayOutput) ToEventDestinationCloudwatchDestinationArrayOutput 

func (o EventDestinationCloudwatchDestinationArrayOutput) ToEventDestinationCloudwatchDestinationArrayOutput() EventDestinationCloudwatchDestinationArrayOutput

func (EventDestinationCloudwatchDestinationArrayOutput) ToEventDestinationCloudwatchDestinationArrayOutputWithContext 

func (o EventDestinationCloudwatchDestinationArrayOutput) ToEventDestinationCloudwatchDestinationArrayOutputWithContext(ctx context.Context) EventDestinationCloudwatchDestinationArrayOutput

type EventDestinationCloudwatchDestinationInput 

type EventDestinationCloudwatchDestinationInput interface {
	pulumi.Input

	ToEventDestinationCloudwatchDestinationOutput() EventDestinationCloudwatchDestinationOutput
	ToEventDestinationCloudwatchDestinationOutputWithContext(context.Context) EventDestinationCloudwatchDestinationOutput
}

EventDestinationCloudwatchDestinationInput is an input type that accepts EventDestinationCloudwatchDestinationArgs and EventDestinationCloudwatchDestinationOutput values. You can construct a concrete instance of `EventDestinationCloudwatchDestinationInput` via: 

EventDestinationCloudwatchDestinationArgs{...}

type EventDestinationCloudwatchDestinationOutput 

type EventDestinationCloudwatchDestinationOutput struct{ *pulumi.OutputState }

func (EventDestinationCloudwatchDestinationOutput) DefaultValue 

func (o EventDestinationCloudwatchDestinationOutput) DefaultValue() pulumi.StringOutput

The default value for the event

func (EventDestinationCloudwatchDestinationOutput) DimensionName 

func (o EventDestinationCloudwatchDestinationOutput) DimensionName() pulumi.StringOutput

The name for the dimension

func (EventDestinationCloudwatchDestinationOutput) ElementType 

func (EventDestinationCloudwatchDestinationOutput) ElementType() reflect.Type

func (EventDestinationCloudwatchDestinationOutput) ToEventDestinationCloudwatchDestinationOutput 

func (o EventDestinationCloudwatchDestinationOutput) ToEventDestinationCloudwatchDestinationOutput() EventDestinationCloudwatchDestinationOutput

func (EventDestinationCloudwatchDestinationOutput) ToEventDestinationCloudwatchDestinationOutputWithContext 

func (o EventDestinationCloudwatchDestinationOutput) ToEventDestinationCloudwatchDestinationOutputWithContext(ctx context.Context) EventDestinationCloudwatchDestinationOutput

func (EventDestinationCloudwatchDestinationOutput) ValueSource 

func (o EventDestinationCloudwatchDestinationOutput) ValueSource() pulumi.StringOutput

The source for the value. May be any of `"messageTag"`, `"emailHeader"` or `"linkTag"`.

type EventDestinationInput 

type EventDestinationInput interface {
	pulumi.Input

	ToEventDestinationOutput() EventDestinationOutput
	ToEventDestinationOutputWithContext(ctx context.Context) EventDestinationOutput
}

type EventDestinationKinesisDestination 

type EventDestinationKinesisDestination struct {
	// The ARN of the role that has permissions to access the Kinesis Stream
	RoleArn string `pulumi:"roleArn"`
	// The ARN of the Kinesis Stream
	StreamArn string `pulumi:"streamArn"`
}

type EventDestinationKinesisDestinationArgs 

type EventDestinationKinesisDestinationArgs struct {
	// The ARN of the role that has permissions to access the Kinesis Stream
	RoleArn pulumi.StringInput `pulumi:"roleArn"`
	// The ARN of the Kinesis Stream
	StreamArn pulumi.StringInput `pulumi:"streamArn"`
}

func (EventDestinationKinesisDestinationArgs) ElementType 

func (EventDestinationKinesisDestinationArgs) ElementType() reflect.Type

func (EventDestinationKinesisDestinationArgs) ToEventDestinationKinesisDestinationOutput 

func (i EventDestinationKinesisDestinationArgs) ToEventDestinationKinesisDestinationOutput() EventDestinationKinesisDestinationOutput

func (EventDestinationKinesisDestinationArgs) ToEventDestinationKinesisDestinationOutputWithContext 

func (i EventDestinationKinesisDestinationArgs) ToEventDestinationKinesisDestinationOutputWithContext(ctx context.Context) EventDestinationKinesisDestinationOutput

func (EventDestinationKinesisDestinationArgs) ToEventDestinationKinesisDestinationPtrOutput 

func (i EventDestinationKinesisDestinationArgs) ToEventDestinationKinesisDestinationPtrOutput() EventDestinationKinesisDestinationPtrOutput

func (EventDestinationKinesisDestinationArgs) ToEventDestinationKinesisDestinationPtrOutputWithContext 

func (i EventDestinationKinesisDestinationArgs) ToEventDestinationKinesisDestinationPtrOutputWithContext(ctx context.Context) EventDestinationKinesisDestinationPtrOutput

type EventDestinationKinesisDestinationInput 

type EventDestinationKinesisDestinationInput interface {
	pulumi.Input

	ToEventDestinationKinesisDestinationOutput() EventDestinationKinesisDestinationOutput
	ToEventDestinationKinesisDestinationOutputWithContext(context.Context) EventDestinationKinesisDestinationOutput
}

EventDestinationKinesisDestinationInput is an input type that accepts EventDestinationKinesisDestinationArgs and EventDestinationKinesisDestinationOutput values. You can construct a concrete instance of `EventDestinationKinesisDestinationInput` via: 

EventDestinationKinesisDestinationArgs{...}

type EventDestinationKinesisDestinationOutput 

type EventDestinationKinesisDestinationOutput struct{ *pulumi.OutputState }

func (EventDestinationKinesisDestinationOutput) ElementType 

func (EventDestinationKinesisDestinationOutput) ElementType() reflect.Type

func (EventDestinationKinesisDestinationOutput) RoleArn 

func (o EventDestinationKinesisDestinationOutput) RoleArn() pulumi.StringOutput

The ARN of the role that has permissions to access the Kinesis Stream

func (EventDestinationKinesisDestinationOutput) StreamArn 

func (o EventDestinationKinesisDestinationOutput) StreamArn() pulumi.StringOutput

The ARN of the Kinesis Stream

func (EventDestinationKinesisDestinationOutput) ToEventDestinationKinesisDestinationOutput 

func (o EventDestinationKinesisDestinationOutput) ToEventDestinationKinesisDestinationOutput() EventDestinationKinesisDestinationOutput

func (EventDestinationKinesisDestinationOutput) ToEventDestinationKinesisDestinationOutputWithContext 

func (o EventDestinationKinesisDestinationOutput) ToEventDestinationKinesisDestinationOutputWithContext(ctx context.Context) EventDestinationKinesisDestinationOutput

func (EventDestinationKinesisDestinationOutput) ToEventDestinationKinesisDestinationPtrOutput 

func (o EventDestinationKinesisDestinationOutput) ToEventDestinationKinesisDestinationPtrOutput() EventDestinationKinesisDestinationPtrOutput

func (EventDestinationKinesisDestinationOutput) ToEventDestinationKinesisDestinationPtrOutputWithContext 

func (o EventDestinationKinesisDestinationOutput) ToEventDestinationKinesisDestinationPtrOutputWithContext(ctx context.Context) EventDestinationKinesisDestinationPtrOutput

type EventDestinationKinesisDestinationPtrInput 

type EventDestinationKinesisDestinationPtrInput interface {
	pulumi.Input

	ToEventDestinationKinesisDestinationPtrOutput() EventDestinationKinesisDestinationPtrOutput
	ToEventDestinationKinesisDestinationPtrOutputWithContext(context.Context) EventDestinationKinesisDestinationPtrOutput
}

EventDestinationKinesisDestinationPtrInput is an input type that accepts EventDestinationKinesisDestinationArgs, EventDestinationKinesisDestinationPtr and EventDestinationKinesisDestinationPtrOutput values. You can construct a concrete instance of `EventDestinationKinesisDestinationPtrInput` via: 

        EventDestinationKinesisDestinationArgs{...}

or:

        nil

func EventDestinationKinesisDestinationPtr 

func EventDestinationKinesisDestinationPtr(v *EventDestinationKinesisDestinationArgs) EventDestinationKinesisDestinationPtrInput

type EventDestinationKinesisDestinationPtrOutput 

type EventDestinationKinesisDestinationPtrOutput struct{ *pulumi.OutputState }

func (EventDestinationKinesisDestinationPtrOutput) Elem 

func (o EventDestinationKinesisDestinationPtrOutput) Elem() EventDestinationKinesisDestinationOutput

func (EventDestinationKinesisDestinationPtrOutput) ElementType 

func (EventDestinationKinesisDestinationPtrOutput) ElementType() reflect.Type

func (EventDestinationKinesisDestinationPtrOutput) RoleArn 

func (o EventDestinationKinesisDestinationPtrOutput) RoleArn() pulumi.StringPtrOutput

The ARN of the role that has permissions to access the Kinesis Stream

func (EventDestinationKinesisDestinationPtrOutput) StreamArn 

func (o EventDestinationKinesisDestinationPtrOutput) StreamArn() pulumi.StringPtrOutput

The ARN of the Kinesis Stream

func (EventDestinationKinesisDestinationPtrOutput) ToEventDestinationKinesisDestinationPtrOutput 

func (o EventDestinationKinesisDestinationPtrOutput) ToEventDestinationKinesisDestinationPtrOutput() EventDestinationKinesisDestinationPtrOutput

func (EventDestinationKinesisDestinationPtrOutput) ToEventDestinationKinesisDestinationPtrOutputWithContext 

func (o EventDestinationKinesisDestinationPtrOutput) ToEventDestinationKinesisDestinationPtrOutputWithContext(ctx context.Context) EventDestinationKinesisDestinationPtrOutput

type EventDestinationMap 

type EventDestinationMap map[string]EventDestinationInput

func (EventDestinationMap) ElementType 

func (EventDestinationMap) ElementType() reflect.Type

func (EventDestinationMap) ToEventDestinationMapOutput 

func (i EventDestinationMap) ToEventDestinationMapOutput() EventDestinationMapOutput

func (EventDestinationMap) ToEventDestinationMapOutputWithContext 

func (i EventDestinationMap) ToEventDestinationMapOutputWithContext(ctx context.Context) EventDestinationMapOutput

type EventDestinationMapInput 

type EventDestinationMapInput interface {
	pulumi.Input

	ToEventDestinationMapOutput() EventDestinationMapOutput
	ToEventDestinationMapOutputWithContext(context.Context) EventDestinationMapOutput
}

EventDestinationMapInput is an input type that accepts EventDestinationMap and EventDestinationMapOutput values. You can construct a concrete instance of `EventDestinationMapInput` via: 

EventDestinationMap{ "key": EventDestinationArgs{...} }

type EventDestinationMapOutput 

type EventDestinationMapOutput struct{ *pulumi.OutputState }

func (EventDestinationMapOutput) ElementType 

func (EventDestinationMapOutput) ElementType() reflect.Type

func (EventDestinationMapOutput) MapIndex 

func (o EventDestinationMapOutput) MapIndex(k pulumi.StringInput) EventDestinationOutput

func (EventDestinationMapOutput) ToEventDestinationMapOutput 

func (o EventDestinationMapOutput) ToEventDestinationMapOutput() EventDestinationMapOutput

func (EventDestinationMapOutput) ToEventDestinationMapOutputWithContext 

func (o EventDestinationMapOutput) ToEventDestinationMapOutputWithContext(ctx context.Context) EventDestinationMapOutput

type EventDestinationOutput 

type EventDestinationOutput struct{ *pulumi.OutputState }

func (EventDestinationOutput) Arn 

func (o EventDestinationOutput) Arn() pulumi.StringOutput

The SES event destination ARN.

func (EventDestinationOutput) CloudwatchDestinations 

func (o EventDestinationOutput) CloudwatchDestinations() EventDestinationCloudwatchDestinationArrayOutput

CloudWatch destination for the events

func (EventDestinationOutput) ConfigurationSetName 

func (o EventDestinationOutput) ConfigurationSetName() pulumi.StringOutput

The name of the configuration set

func (EventDestinationOutput) ElementType 

func (EventDestinationOutput) ElementType() reflect.Type

func (EventDestinationOutput) Enabled 

func (o EventDestinationOutput) Enabled() pulumi.BoolPtrOutput

If true, the event destination will be enabled

func (EventDestinationOutput) KinesisDestination 

func (o EventDestinationOutput) KinesisDestination() EventDestinationKinesisDestinationPtrOutput

Send the events to a kinesis firehose destination

func (EventDestinationOutput) MatchingTypes 

func (o EventDestinationOutput) MatchingTypes() pulumi.StringArrayOutput

A list of matching types. May be any of `"send"`, `"reject"`, `"bounce"`, `"complaint"`, `"delivery"`, `"open"`, `"click"`, or `"renderingFailure"`.

func (EventDestinationOutput) Name 

func (o EventDestinationOutput) Name() pulumi.StringOutput

The name of the event destination

func (EventDestinationOutput) SnsDestination 

func (o EventDestinationOutput) SnsDestination() EventDestinationSnsDestinationPtrOutput

Send the events to an SNS Topic destination

> **NOTE:** You can specify `"cloudwatchDestination"` or `"kinesisDestination"` but not both

func (EventDestinationOutput) ToEventDestinationOutput 

func (o EventDestinationOutput) ToEventDestinationOutput() EventDestinationOutput

func (EventDestinationOutput) ToEventDestinationOutputWithContext 

func (o EventDestinationOutput) ToEventDestinationOutputWithContext(ctx context.Context) EventDestinationOutput

type EventDestinationSnsDestination 

type EventDestinationSnsDestination struct {
	// The ARN of the SNS topic
	TopicArn string `pulumi:"topicArn"`
}

type EventDestinationSnsDestinationArgs 

type EventDestinationSnsDestinationArgs struct {
	// The ARN of the SNS topic
	TopicArn pulumi.StringInput `pulumi:"topicArn"`
}

func (EventDestinationSnsDestinationArgs) ElementType 

func (EventDestinationSnsDestinationArgs) ElementType() reflect.Type

func (EventDestinationSnsDestinationArgs) ToEventDestinationSnsDestinationOutput 

func (i EventDestinationSnsDestinationArgs) ToEventDestinationSnsDestinationOutput() EventDestinationSnsDestinationOutput

func (EventDestinationSnsDestinationArgs) ToEventDestinationSnsDestinationOutputWithContext 

func (i EventDestinationSnsDestinationArgs) ToEventDestinationSnsDestinationOutputWithContext(ctx context.Context) EventDestinationSnsDestinationOutput

func (EventDestinationSnsDestinationArgs) ToEventDestinationSnsDestinationPtrOutput 

func (i EventDestinationSnsDestinationArgs) ToEventDestinationSnsDestinationPtrOutput() EventDestinationSnsDestinationPtrOutput

func (EventDestinationSnsDestinationArgs) ToEventDestinationSnsDestinationPtrOutputWithContext 

func (i EventDestinationSnsDestinationArgs) ToEventDestinationSnsDestinationPtrOutputWithContext(ctx context.Context) EventDestinationSnsDestinationPtrOutput

type EventDestinationSnsDestinationInput 

type EventDestinationSnsDestinationInput interface {
	pulumi.Input

	ToEventDestinationSnsDestinationOutput() EventDestinationSnsDestinationOutput
	ToEventDestinationSnsDestinationOutputWithContext(context.Context) EventDestinationSnsDestinationOutput
}

EventDestinationSnsDestinationInput is an input type that accepts EventDestinationSnsDestinationArgs and EventDestinationSnsDestinationOutput values. You can construct a concrete instance of `EventDestinationSnsDestinationInput` via: 

EventDestinationSnsDestinationArgs{...}

type EventDestinationSnsDestinationOutput 

type EventDestinationSnsDestinationOutput struct{ *pulumi.OutputState }

func (EventDestinationSnsDestinationOutput) ElementType 

func (EventDestinationSnsDestinationOutput) ElementType() reflect.Type

func (EventDestinationSnsDestinationOutput) ToEventDestinationSnsDestinationOutput 

func (o EventDestinationSnsDestinationOutput) ToEventDestinationSnsDestinationOutput() EventDestinationSnsDestinationOutput

func (EventDestinationSnsDestinationOutput) ToEventDestinationSnsDestinationOutputWithContext 

func (o EventDestinationSnsDestinationOutput) ToEventDestinationSnsDestinationOutputWithContext(ctx context.Context) EventDestinationSnsDestinationOutput

func (EventDestinationSnsDestinationOutput) ToEventDestinationSnsDestinationPtrOutput 

func (o EventDestinationSnsDestinationOutput) ToEventDestinationSnsDestinationPtrOutput() EventDestinationSnsDestinationPtrOutput

func (EventDestinationSnsDestinationOutput) ToEventDestinationSnsDestinationPtrOutputWithContext 

func (o EventDestinationSnsDestinationOutput) ToEventDestinationSnsDestinationPtrOutputWithContext(ctx context.Context) EventDestinationSnsDestinationPtrOutput

func (EventDestinationSnsDestinationOutput) TopicArn 

func (o EventDestinationSnsDestinationOutput) TopicArn() pulumi.StringOutput

The ARN of the SNS topic

type EventDestinationSnsDestinationPtrInput 

type EventDestinationSnsDestinationPtrInput interface {
	pulumi.Input

	ToEventDestinationSnsDestinationPtrOutput() EventDestinationSnsDestinationPtrOutput
	ToEventDestinationSnsDestinationPtrOutputWithContext(context.Context) EventDestinationSnsDestinationPtrOutput
}

EventDestinationSnsDestinationPtrInput is an input type that accepts EventDestinationSnsDestinationArgs, EventDestinationSnsDestinationPtr and EventDestinationSnsDestinationPtrOutput values. You can construct a concrete instance of `EventDestinationSnsDestinationPtrInput` via: 

        EventDestinationSnsDestinationArgs{...}

or:

        nil

func EventDestinationSnsDestinationPtr 

func EventDestinationSnsDestinationPtr(v *EventDestinationSnsDestinationArgs) EventDestinationSnsDestinationPtrInput

type EventDestinationSnsDestinationPtrOutput 

type EventDestinationSnsDestinationPtrOutput struct{ *pulumi.OutputState }

func (EventDestinationSnsDestinationPtrOutput) Elem 

func (o EventDestinationSnsDestinationPtrOutput) Elem() EventDestinationSnsDestinationOutput

func (EventDestinationSnsDestinationPtrOutput) ElementType 

func (EventDestinationSnsDestinationPtrOutput) ElementType() reflect.Type

func (EventDestinationSnsDestinationPtrOutput) ToEventDestinationSnsDestinationPtrOutput 

func (o EventDestinationSnsDestinationPtrOutput) ToEventDestinationSnsDestinationPtrOutput() EventDestinationSnsDestinationPtrOutput

func (EventDestinationSnsDestinationPtrOutput) ToEventDestinationSnsDestinationPtrOutputWithContext 

func (o EventDestinationSnsDestinationPtrOutput) ToEventDestinationSnsDestinationPtrOutputWithContext(ctx context.Context) EventDestinationSnsDestinationPtrOutput

func (EventDestinationSnsDestinationPtrOutput) TopicArn 

func (o EventDestinationSnsDestinationPtrOutput) TopicArn() pulumi.StringPtrOutput

The ARN of the SNS topic

type EventDestinationState 

type EventDestinationState struct {
	// The SES event destination ARN.
	Arn pulumi.StringPtrInput
	// CloudWatch destination for the events
	CloudwatchDestinations EventDestinationCloudwatchDestinationArrayInput
	// The name of the configuration set
	ConfigurationSetName pulumi.StringPtrInput
	// If true, the event destination will be enabled
	Enabled pulumi.BoolPtrInput
	// Send the events to a kinesis firehose destination
	KinesisDestination EventDestinationKinesisDestinationPtrInput
	// A list of matching types. May be any of `"send"`, `"reject"`, `"bounce"`, `"complaint"`, `"delivery"`, `"open"`, `"click"`, or `"renderingFailure"`.
	MatchingTypes pulumi.StringArrayInput
	// The name of the event destination
	Name pulumi.StringPtrInput
	// Send the events to an SNS Topic destination
	//
	// > **NOTE:** You can specify `"cloudwatchDestination"` or `"kinesisDestination"` but not both
	SnsDestination EventDestinationSnsDestinationPtrInput
}

func (EventDestinationState) ElementType 

func (EventDestinationState) ElementType() reflect.Type

type IdentityNotificationTopic 

type IdentityNotificationTopic struct {
	pulumi.CustomResourceState

	// The identity for which the Amazon SNS topic will be set. You can specify an identity by using its name or by using its Amazon Resource Name (ARN).
	Identity pulumi.StringOutput `pulumi:"identity"`
	// Whether SES should include original email headers in SNS notifications of this type. `false` by default.
	IncludeOriginalHeaders pulumi.BoolPtrOutput `pulumi:"includeOriginalHeaders"`
	// The type of notifications that will be published to the specified Amazon SNS topic. Valid Values: `Bounce`, `Complaint` or `Delivery`.
	NotificationType pulumi.StringOutput `pulumi:"notificationType"`
	// The Amazon Resource Name (ARN) of the Amazon SNS topic. Can be set to `""` (an empty string) to disable publishing.
	TopicArn pulumi.StringPtrOutput `pulumi:"topicArn"`
}

Resource for managing SES Identity Notification Topics

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ses.NewIdentityNotificationTopic(ctx, "test", &ses.IdentityNotificationTopicArgs{
			TopicArn:               pulumi.Any(aws_sns_topic.Example.Arn),
			NotificationType:       pulumi.String("Bounce"),
			Identity:               pulumi.Any(aws_ses_domain_identity.Example.Domain),
			IncludeOriginalHeaders: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Identity Notification Topics can be imported using the ID of the record. The ID is made up as `IDENTITY|TYPE` where `IDENTITY` is the SES Identity and `TYPE` is the Notification Type.

```sh 

$ pulumi import aws:ses/identityNotificationTopic:IdentityNotificationTopic test 'example.com|Bounce'

```

func GetIdentityNotificationTopic 

func GetIdentityNotificationTopic(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *IdentityNotificationTopicState, opts ...pulumi.ResourceOption) (*IdentityNotificationTopic, error)

GetIdentityNotificationTopic gets an existing IdentityNotificationTopic 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 NewIdentityNotificationTopic 

func NewIdentityNotificationTopic(ctx *pulumi.Context,
	name string, args *IdentityNotificationTopicArgs, opts ...pulumi.ResourceOption) (*IdentityNotificationTopic, error)

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

func (*IdentityNotificationTopic) ElementType 

func (*IdentityNotificationTopic) ElementType() reflect.Type

func (*IdentityNotificationTopic) ToIdentityNotificationTopicOutput 

func (i *IdentityNotificationTopic) ToIdentityNotificationTopicOutput() IdentityNotificationTopicOutput

func (*IdentityNotificationTopic) ToIdentityNotificationTopicOutputWithContext 

func (i *IdentityNotificationTopic) ToIdentityNotificationTopicOutputWithContext(ctx context.Context) IdentityNotificationTopicOutput

type IdentityNotificationTopicArgs 

type IdentityNotificationTopicArgs struct {
	// The identity for which the Amazon SNS topic will be set. You can specify an identity by using its name or by using its Amazon Resource Name (ARN).
	Identity pulumi.StringInput
	// Whether SES should include original email headers in SNS notifications of this type. `false` by default.
	IncludeOriginalHeaders pulumi.BoolPtrInput
	// The type of notifications that will be published to the specified Amazon SNS topic. Valid Values: `Bounce`, `Complaint` or `Delivery`.
	NotificationType pulumi.StringInput
	// The Amazon Resource Name (ARN) of the Amazon SNS topic. Can be set to `""` (an empty string) to disable publishing.
	TopicArn pulumi.StringPtrInput
}

The set of arguments for constructing a IdentityNotificationTopic resource.

func (IdentityNotificationTopicArgs) ElementType 

func (IdentityNotificationTopicArgs) ElementType() reflect.Type

type IdentityNotificationTopicArray 

type IdentityNotificationTopicArray []IdentityNotificationTopicInput

func (IdentityNotificationTopicArray) ElementType 

func (IdentityNotificationTopicArray) ElementType() reflect.Type

func (IdentityNotificationTopicArray) ToIdentityNotificationTopicArrayOutput 

func (i IdentityNotificationTopicArray) ToIdentityNotificationTopicArrayOutput() IdentityNotificationTopicArrayOutput

func (IdentityNotificationTopicArray) ToIdentityNotificationTopicArrayOutputWithContext 

func (i IdentityNotificationTopicArray) ToIdentityNotificationTopicArrayOutputWithContext(ctx context.Context) IdentityNotificationTopicArrayOutput

type IdentityNotificationTopicArrayInput 

type IdentityNotificationTopicArrayInput interface {
	pulumi.Input

	ToIdentityNotificationTopicArrayOutput() IdentityNotificationTopicArrayOutput
	ToIdentityNotificationTopicArrayOutputWithContext(context.Context) IdentityNotificationTopicArrayOutput
}

IdentityNotificationTopicArrayInput is an input type that accepts IdentityNotificationTopicArray and IdentityNotificationTopicArrayOutput values. You can construct a concrete instance of `IdentityNotificationTopicArrayInput` via: 

IdentityNotificationTopicArray{ IdentityNotificationTopicArgs{...} }

type IdentityNotificationTopicArrayOutput 

type IdentityNotificationTopicArrayOutput struct{ *pulumi.OutputState }

func (IdentityNotificationTopicArrayOutput) ElementType 

func (IdentityNotificationTopicArrayOutput) ElementType() reflect.Type

func (IdentityNotificationTopicArrayOutput) Index 

func (o IdentityNotificationTopicArrayOutput) Index(i pulumi.IntInput) IdentityNotificationTopicOutput

func (IdentityNotificationTopicArrayOutput) ToIdentityNotificationTopicArrayOutput 

func (o IdentityNotificationTopicArrayOutput) ToIdentityNotificationTopicArrayOutput() IdentityNotificationTopicArrayOutput

func (IdentityNotificationTopicArrayOutput) ToIdentityNotificationTopicArrayOutputWithContext 

func (o IdentityNotificationTopicArrayOutput) ToIdentityNotificationTopicArrayOutputWithContext(ctx context.Context) IdentityNotificationTopicArrayOutput

type IdentityNotificationTopicInput 

type IdentityNotificationTopicInput interface {
	pulumi.Input

	ToIdentityNotificationTopicOutput() IdentityNotificationTopicOutput
	ToIdentityNotificationTopicOutputWithContext(ctx context.Context) IdentityNotificationTopicOutput
}

type IdentityNotificationTopicMap 

type IdentityNotificationTopicMap map[string]IdentityNotificationTopicInput

func (IdentityNotificationTopicMap) ElementType 

func (IdentityNotificationTopicMap) ElementType() reflect.Type

func (IdentityNotificationTopicMap) ToIdentityNotificationTopicMapOutput 

func (i IdentityNotificationTopicMap) ToIdentityNotificationTopicMapOutput() IdentityNotificationTopicMapOutput

func (IdentityNotificationTopicMap) ToIdentityNotificationTopicMapOutputWithContext 

func (i IdentityNotificationTopicMap) ToIdentityNotificationTopicMapOutputWithContext(ctx context.Context) IdentityNotificationTopicMapOutput

type IdentityNotificationTopicMapInput 

type IdentityNotificationTopicMapInput interface {
	pulumi.Input

	ToIdentityNotificationTopicMapOutput() IdentityNotificationTopicMapOutput
	ToIdentityNotificationTopicMapOutputWithContext(context.Context) IdentityNotificationTopicMapOutput
}

IdentityNotificationTopicMapInput is an input type that accepts IdentityNotificationTopicMap and IdentityNotificationTopicMapOutput values. You can construct a concrete instance of `IdentityNotificationTopicMapInput` via: 

IdentityNotificationTopicMap{ "key": IdentityNotificationTopicArgs{...} }

type IdentityNotificationTopicMapOutput 

type IdentityNotificationTopicMapOutput struct{ *pulumi.OutputState }

func (IdentityNotificationTopicMapOutput) ElementType 

func (IdentityNotificationTopicMapOutput) ElementType() reflect.Type

func (IdentityNotificationTopicMapOutput) MapIndex 

func (o IdentityNotificationTopicMapOutput) MapIndex(k pulumi.StringInput) IdentityNotificationTopicOutput

func (IdentityNotificationTopicMapOutput) ToIdentityNotificationTopicMapOutput 

func (o IdentityNotificationTopicMapOutput) ToIdentityNotificationTopicMapOutput() IdentityNotificationTopicMapOutput

func (IdentityNotificationTopicMapOutput) ToIdentityNotificationTopicMapOutputWithContext 

func (o IdentityNotificationTopicMapOutput) ToIdentityNotificationTopicMapOutputWithContext(ctx context.Context) IdentityNotificationTopicMapOutput

type IdentityNotificationTopicOutput 

type IdentityNotificationTopicOutput struct{ *pulumi.OutputState }

func (IdentityNotificationTopicOutput) ElementType 

func (IdentityNotificationTopicOutput) ElementType() reflect.Type

func (IdentityNotificationTopicOutput) Identity 

func (o IdentityNotificationTopicOutput) Identity() pulumi.StringOutput

The identity for which the Amazon SNS topic will be set. You can specify an identity by using its name or by using its Amazon Resource Name (ARN).

func (IdentityNotificationTopicOutput) IncludeOriginalHeaders 

func (o IdentityNotificationTopicOutput) IncludeOriginalHeaders() pulumi.BoolPtrOutput

Whether SES should include original email headers in SNS notifications of this type. `false` by default.

func (IdentityNotificationTopicOutput) NotificationType 

func (o IdentityNotificationTopicOutput) NotificationType() pulumi.StringOutput

The type of notifications that will be published to the specified Amazon SNS topic. Valid Values: `Bounce`, `Complaint` or `Delivery`.

func (IdentityNotificationTopicOutput) ToIdentityNotificationTopicOutput 

func (o IdentityNotificationTopicOutput) ToIdentityNotificationTopicOutput() IdentityNotificationTopicOutput

func (IdentityNotificationTopicOutput) ToIdentityNotificationTopicOutputWithContext 

func (o IdentityNotificationTopicOutput) ToIdentityNotificationTopicOutputWithContext(ctx context.Context) IdentityNotificationTopicOutput

func (IdentityNotificationTopicOutput) TopicArn 

func (o IdentityNotificationTopicOutput) TopicArn() pulumi.StringPtrOutput

The Amazon Resource Name (ARN) of the Amazon SNS topic. Can be set to `""` (an empty string) to disable publishing.

type IdentityNotificationTopicState 

type IdentityNotificationTopicState struct {
	// The identity for which the Amazon SNS topic will be set. You can specify an identity by using its name or by using its Amazon Resource Name (ARN).
	Identity pulumi.StringPtrInput
	// Whether SES should include original email headers in SNS notifications of this type. `false` by default.
	IncludeOriginalHeaders pulumi.BoolPtrInput
	// The type of notifications that will be published to the specified Amazon SNS topic. Valid Values: `Bounce`, `Complaint` or `Delivery`.
	NotificationType pulumi.StringPtrInput
	// The Amazon Resource Name (ARN) of the Amazon SNS topic. Can be set to `""` (an empty string) to disable publishing.
	TopicArn pulumi.StringPtrInput
}

func (IdentityNotificationTopicState) ElementType 

func (IdentityNotificationTopicState) ElementType() reflect.Type

type IdentityPolicy 

type IdentityPolicy struct {
	pulumi.CustomResourceState

	// Name or Amazon Resource Name (ARN) of the SES Identity.
	Identity pulumi.StringOutput `pulumi:"identity"`
	// Name of the policy.
	Name pulumi.StringOutput `pulumi:"name"`
	// JSON string of the policy.
	Policy pulumi.StringOutput `pulumi:"policy"`
}

Manages a SES Identity Policy. More information about SES Sending Authorization Policies can be found in the [SES Developer Guide](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/sending-authorization-policies.html).

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/iam"
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleDomainIdentity, err := ses.NewDomainIdentity(ctx, "exampleDomainIdentity", &ses.DomainIdentityArgs{
			Domain: pulumi.String("example.com"),
		})
		if err != nil {
			return err
		}
		examplePolicyDocument := iam.GetPolicyDocumentOutput(ctx, iam.GetPolicyDocumentOutputArgs{
			Statements: iam.GetPolicyDocumentStatementArray{
				&iam.GetPolicyDocumentStatementArgs{
					Actions: pulumi.StringArray{
						pulumi.String("SES:SendEmail"),
						pulumi.String("SES:SendRawEmail"),
					},
					Resources: pulumi.StringArray{
						exampleDomainIdentity.Arn,
					},
					Principals: iam.GetPolicyDocumentStatementPrincipalArray{
						&iam.GetPolicyDocumentStatementPrincipalArgs{
							Identifiers: pulumi.StringArray{
								pulumi.String("*"),
							},
							Type: pulumi.String("AWS"),
						},
					},
				},
			},
		}, nil)
		_, err = ses.NewIdentityPolicy(ctx, "exampleIdentityPolicy", &ses.IdentityPolicyArgs{
			Identity: exampleDomainIdentity.Arn,
			Policy: examplePolicyDocument.ApplyT(func(examplePolicyDocument iam.GetPolicyDocumentResult) (*string, error) {
				return &examplePolicyDocument.Json, nil
			}).(pulumi.StringPtrOutput),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

SES Identity Policies can be imported using the identity and policy name, separated by a pipe character (`|`), e.g.,

```sh 

$ pulumi import aws:ses/identityPolicy:IdentityPolicy example 'example.com|example'

```

func GetIdentityPolicy 

func GetIdentityPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *IdentityPolicyState, opts ...pulumi.ResourceOption) (*IdentityPolicy, error)

GetIdentityPolicy gets an existing IdentityPolicy 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 NewIdentityPolicy 

func NewIdentityPolicy(ctx *pulumi.Context,
	name string, args *IdentityPolicyArgs, opts ...pulumi.ResourceOption) (*IdentityPolicy, error)

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

func (*IdentityPolicy) ElementType 

func (*IdentityPolicy) ElementType() reflect.Type

func (*IdentityPolicy) ToIdentityPolicyOutput 

func (i *IdentityPolicy) ToIdentityPolicyOutput() IdentityPolicyOutput

func (*IdentityPolicy) ToIdentityPolicyOutputWithContext 

func (i *IdentityPolicy) ToIdentityPolicyOutputWithContext(ctx context.Context) IdentityPolicyOutput

type IdentityPolicyArgs 

type IdentityPolicyArgs struct {
	// Name or Amazon Resource Name (ARN) of the SES Identity.
	Identity pulumi.StringInput
	// Name of the policy.
	Name pulumi.StringPtrInput
	// JSON string of the policy.
	Policy pulumi.StringInput
}

The set of arguments for constructing a IdentityPolicy resource.

func (IdentityPolicyArgs) ElementType 

func (IdentityPolicyArgs) ElementType() reflect.Type

type IdentityPolicyArray 

type IdentityPolicyArray []IdentityPolicyInput

func (IdentityPolicyArray) ElementType 

func (IdentityPolicyArray) ElementType() reflect.Type

func (IdentityPolicyArray) ToIdentityPolicyArrayOutput 

func (i IdentityPolicyArray) ToIdentityPolicyArrayOutput() IdentityPolicyArrayOutput

func (IdentityPolicyArray) ToIdentityPolicyArrayOutputWithContext 

func (i IdentityPolicyArray) ToIdentityPolicyArrayOutputWithContext(ctx context.Context) IdentityPolicyArrayOutput

type IdentityPolicyArrayInput 

type IdentityPolicyArrayInput interface {
	pulumi.Input

	ToIdentityPolicyArrayOutput() IdentityPolicyArrayOutput
	ToIdentityPolicyArrayOutputWithContext(context.Context) IdentityPolicyArrayOutput
}

IdentityPolicyArrayInput is an input type that accepts IdentityPolicyArray and IdentityPolicyArrayOutput values. You can construct a concrete instance of `IdentityPolicyArrayInput` via: 

IdentityPolicyArray{ IdentityPolicyArgs{...} }

type IdentityPolicyArrayOutput 

type IdentityPolicyArrayOutput struct{ *pulumi.OutputState }

func (IdentityPolicyArrayOutput) ElementType 

func (IdentityPolicyArrayOutput) ElementType() reflect.Type

func (IdentityPolicyArrayOutput) Index 

func (o IdentityPolicyArrayOutput) Index(i pulumi.IntInput) IdentityPolicyOutput

func (IdentityPolicyArrayOutput) ToIdentityPolicyArrayOutput 

func (o IdentityPolicyArrayOutput) ToIdentityPolicyArrayOutput() IdentityPolicyArrayOutput

func (IdentityPolicyArrayOutput) ToIdentityPolicyArrayOutputWithContext 

func (o IdentityPolicyArrayOutput) ToIdentityPolicyArrayOutputWithContext(ctx context.Context) IdentityPolicyArrayOutput

type IdentityPolicyInput 

type IdentityPolicyInput interface {
	pulumi.Input

	ToIdentityPolicyOutput() IdentityPolicyOutput
	ToIdentityPolicyOutputWithContext(ctx context.Context) IdentityPolicyOutput
}

type IdentityPolicyMap 

type IdentityPolicyMap map[string]IdentityPolicyInput

func (IdentityPolicyMap) ElementType 

func (IdentityPolicyMap) ElementType() reflect.Type

func (IdentityPolicyMap) ToIdentityPolicyMapOutput 

func (i IdentityPolicyMap) ToIdentityPolicyMapOutput() IdentityPolicyMapOutput

func (IdentityPolicyMap) ToIdentityPolicyMapOutputWithContext 

func (i IdentityPolicyMap) ToIdentityPolicyMapOutputWithContext(ctx context.Context) IdentityPolicyMapOutput

type IdentityPolicyMapInput 

type IdentityPolicyMapInput interface {
	pulumi.Input

	ToIdentityPolicyMapOutput() IdentityPolicyMapOutput
	ToIdentityPolicyMapOutputWithContext(context.Context) IdentityPolicyMapOutput
}

IdentityPolicyMapInput is an input type that accepts IdentityPolicyMap and IdentityPolicyMapOutput values. You can construct a concrete instance of `IdentityPolicyMapInput` via: 

IdentityPolicyMap{ "key": IdentityPolicyArgs{...} }

type IdentityPolicyMapOutput 

type IdentityPolicyMapOutput struct{ *pulumi.OutputState }

func (IdentityPolicyMapOutput) ElementType 

func (IdentityPolicyMapOutput) ElementType() reflect.Type

func (IdentityPolicyMapOutput) MapIndex 

func (o IdentityPolicyMapOutput) MapIndex(k pulumi.StringInput) IdentityPolicyOutput

func (IdentityPolicyMapOutput) ToIdentityPolicyMapOutput 

func (o IdentityPolicyMapOutput) ToIdentityPolicyMapOutput() IdentityPolicyMapOutput

func (IdentityPolicyMapOutput) ToIdentityPolicyMapOutputWithContext 

func (o IdentityPolicyMapOutput) ToIdentityPolicyMapOutputWithContext(ctx context.Context) IdentityPolicyMapOutput

type IdentityPolicyOutput 

type IdentityPolicyOutput struct{ *pulumi.OutputState }

func (IdentityPolicyOutput) ElementType 

func (IdentityPolicyOutput) ElementType() reflect.Type

func (IdentityPolicyOutput) Identity 

func (o IdentityPolicyOutput) Identity() pulumi.StringOutput

Name or Amazon Resource Name (ARN) of the SES Identity.

func (IdentityPolicyOutput) Name 

func (o IdentityPolicyOutput) Name() pulumi.StringOutput

Name of the policy.

func (IdentityPolicyOutput) Policy 

func (o IdentityPolicyOutput) Policy() pulumi.StringOutput

JSON string of the policy.

func (IdentityPolicyOutput) ToIdentityPolicyOutput 

func (o IdentityPolicyOutput) ToIdentityPolicyOutput() IdentityPolicyOutput

func (IdentityPolicyOutput) ToIdentityPolicyOutputWithContext 

func (o IdentityPolicyOutput) ToIdentityPolicyOutputWithContext(ctx context.Context) IdentityPolicyOutput

type IdentityPolicyState 

type IdentityPolicyState struct {
	// Name or Amazon Resource Name (ARN) of the SES Identity.
	Identity pulumi.StringPtrInput
	// Name of the policy.
	Name pulumi.StringPtrInput
	// JSON string of the policy.
	Policy pulumi.StringPtrInput
}

func (IdentityPolicyState) ElementType 

func (IdentityPolicyState) ElementType() reflect.Type

type LookupActiveReceiptRuleSetResult 

type LookupActiveReceiptRuleSetResult struct {
	// SES receipt rule set ARN.
	Arn string `pulumi:"arn"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// Name of the rule set
	RuleSetName string `pulumi:"ruleSetName"`
}

A collection of values returned by getActiveReceiptRuleSet.

func LookupActiveReceiptRuleSet 

func LookupActiveReceiptRuleSet(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*LookupActiveReceiptRuleSetResult, error)

Retrieve the active SES receipt rule set

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ses.LookupActiveReceiptRuleSet(ctx, nil, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupDomainIdentityArgs 

type LookupDomainIdentityArgs struct {
	// Name of the domain
	Domain string `pulumi:"domain"`
}

A collection of arguments for invoking getDomainIdentity.

type LookupDomainIdentityOutputArgs 

type LookupDomainIdentityOutputArgs struct {
	// Name of the domain
	Domain pulumi.StringInput `pulumi:"domain"`
}

A collection of arguments for invoking getDomainIdentity.

func (LookupDomainIdentityOutputArgs) ElementType 

func (LookupDomainIdentityOutputArgs) ElementType() reflect.Type

type LookupDomainIdentityResult 

type LookupDomainIdentityResult struct {
	// ARN of the domain identity.
	Arn string `pulumi:"arn"`
	// Name of the domain
	Domain string `pulumi:"domain"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// Code which when added to the domain as a TXT record will signal to SES that the owner of the domain has authorized SES to act on their behalf.
	VerificationToken string `pulumi:"verificationToken"`
}

A collection of values returned by getDomainIdentity.

func LookupDomainIdentity 

func LookupDomainIdentity(ctx *pulumi.Context, args *LookupDomainIdentityArgs, opts ...pulumi.InvokeOption) (*LookupDomainIdentityResult, error)

Retrieve the SES domain identity

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ses.LookupDomainIdentity(ctx, &ses.LookupDomainIdentityArgs{
			Domain: "example.com",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupDomainIdentityResultOutput 

type LookupDomainIdentityResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getDomainIdentity.

func LookupDomainIdentityOutput 

func LookupDomainIdentityOutput(ctx *pulumi.Context, args LookupDomainIdentityOutputArgs, opts ...pulumi.InvokeOption) LookupDomainIdentityResultOutput

func (LookupDomainIdentityResultOutput) Arn 

func (o LookupDomainIdentityResultOutput) Arn() pulumi.StringOutput

ARN of the domain identity.

func (LookupDomainIdentityResultOutput) Domain 

func (o LookupDomainIdentityResultOutput) Domain() pulumi.StringOutput

Name of the domain

func (LookupDomainIdentityResultOutput) ElementType 

func (LookupDomainIdentityResultOutput) ElementType() reflect.Type

func (LookupDomainIdentityResultOutput) Id 

func (o LookupDomainIdentityResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (LookupDomainIdentityResultOutput) ToLookupDomainIdentityResultOutput 

func (o LookupDomainIdentityResultOutput) ToLookupDomainIdentityResultOutput() LookupDomainIdentityResultOutput

func (LookupDomainIdentityResultOutput) ToLookupDomainIdentityResultOutputWithContext 

func (o LookupDomainIdentityResultOutput) ToLookupDomainIdentityResultOutputWithContext(ctx context.Context) LookupDomainIdentityResultOutput

func (LookupDomainIdentityResultOutput) VerificationToken 

func (o LookupDomainIdentityResultOutput) VerificationToken() pulumi.StringOutput

Code which when added to the domain as a TXT record will signal to SES that the owner of the domain has authorized SES to act on their behalf.

type LookupEmailIdentityArgs 

type LookupEmailIdentityArgs struct {
	// Email identity.
	Email string `pulumi:"email"`
}

A collection of arguments for invoking getEmailIdentity.

type LookupEmailIdentityOutputArgs 

type LookupEmailIdentityOutputArgs struct {
	// Email identity.
	Email pulumi.StringInput `pulumi:"email"`
}

A collection of arguments for invoking getEmailIdentity.

func (LookupEmailIdentityOutputArgs) ElementType 

func (LookupEmailIdentityOutputArgs) ElementType() reflect.Type

type LookupEmailIdentityResult 

type LookupEmailIdentityResult struct {
	// The ARN of the email identity.
	Arn string `pulumi:"arn"`
	// Email identity.
	Email string `pulumi:"email"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
}

A collection of values returned by getEmailIdentity.

func LookupEmailIdentity 

func LookupEmailIdentity(ctx *pulumi.Context, args *LookupEmailIdentityArgs, opts ...pulumi.InvokeOption) (*LookupEmailIdentityResult, error)

Retrieve the active SES email identity

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ses.LookupEmailIdentity(ctx, &ses.LookupEmailIdentityArgs{
			Email: "awesome@example.com",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupEmailIdentityResultOutput 

type LookupEmailIdentityResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getEmailIdentity.

func LookupEmailIdentityOutput 

func LookupEmailIdentityOutput(ctx *pulumi.Context, args LookupEmailIdentityOutputArgs, opts ...pulumi.InvokeOption) LookupEmailIdentityResultOutput

func (LookupEmailIdentityResultOutput) Arn 

func (o LookupEmailIdentityResultOutput) Arn() pulumi.StringOutput

The ARN of the email identity.

func (LookupEmailIdentityResultOutput) ElementType 

func (LookupEmailIdentityResultOutput) ElementType() reflect.Type

func (LookupEmailIdentityResultOutput) Email 

func (o LookupEmailIdentityResultOutput) Email() pulumi.StringOutput

Email identity.

func (LookupEmailIdentityResultOutput) Id 

func (o LookupEmailIdentityResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (LookupEmailIdentityResultOutput) ToLookupEmailIdentityResultOutput 

func (o LookupEmailIdentityResultOutput) ToLookupEmailIdentityResultOutput() LookupEmailIdentityResultOutput

func (LookupEmailIdentityResultOutput) ToLookupEmailIdentityResultOutputWithContext 

func (o LookupEmailIdentityResultOutput) ToLookupEmailIdentityResultOutputWithContext(ctx context.Context) LookupEmailIdentityResultOutput

type MailFrom 

type MailFrom struct {
	pulumi.CustomResourceState

	// The action that you want Amazon SES to take if it cannot successfully read the required MX record when you send an email. Defaults to `UseDefaultValue`. See the [SES API documentation](https://docs.aws.amazon.com/ses/latest/APIReference/API_SetIdentityMailFromDomain.html) for more information.
	BehaviorOnMxFailure pulumi.StringPtrOutput `pulumi:"behaviorOnMxFailure"`
	// Verified domain name or email identity to generate DKIM tokens for.
	Domain pulumi.StringOutput `pulumi:"domain"`
	// Subdomain (of above domain) which is to be used as MAIL FROM address (Required for DMARC validation)
	//
	// The following arguments are optional:
	MailFromDomain pulumi.StringOutput `pulumi:"mailFromDomain"`
}

Provides an SES domain MAIL FROM resource.

> **NOTE:** For the MAIL FROM domain to be fully usable, this resource should be paired with the ses.DomainIdentity resource. To validate the MAIL FROM domain, a DNS MX record is required. To pass SPF checks, a DNS TXT record may also be required. See the [Amazon SES MAIL FROM documentation](https://docs.aws.amazon.com/ses/latest/dg/mail-from.html) for more information.

## Example Usage ### Domain Identity MAIL FROM

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/route53"
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleDomainIdentity, err := ses.NewDomainIdentity(ctx, "exampleDomainIdentity", &ses.DomainIdentityArgs{
			Domain: pulumi.String("example.com"),
		})
		if err != nil {
			return err
		}
		exampleMailFrom, err := ses.NewMailFrom(ctx, "exampleMailFrom", &ses.MailFromArgs{
			Domain: exampleDomainIdentity.Domain,
			MailFromDomain: exampleDomainIdentity.Domain.ApplyT(func(domain string) (string, error) {
				return fmt.Sprintf("bounce.%v", domain), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		_, err = route53.NewRecord(ctx, "exampleSesDomainMailFromMx", &route53.RecordArgs{
			ZoneId: pulumi.Any(aws_route53_zone.Example.Id),
			Name:   exampleMailFrom.MailFromDomain,
			Type:   pulumi.String("MX"),
			Ttl:    pulumi.Int(600),
			Records: pulumi.StringArray{
				pulumi.String("10 feedback-smtp.us-east-1.amazonses.com"),
			},
		})
		if err != nil {
			return err
		}
		_, err = route53.NewRecord(ctx, "exampleSesDomainMailFromTxt", &route53.RecordArgs{
			ZoneId: pulumi.Any(aws_route53_zone.Example.Id),
			Name:   exampleMailFrom.MailFromDomain,
			Type:   pulumi.String("TXT"),
			Ttl:    pulumi.Int(600),
			Records: pulumi.StringArray{
				pulumi.String("v=spf1 include:amazonses.com -all"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Email Identity MAIL FROM

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleEmailIdentity, err := ses.NewEmailIdentity(ctx, "exampleEmailIdentity", &ses.EmailIdentityArgs{
			Email: pulumi.String("user@example.com"),
		})
		if err != nil {
			return err
		}
		_, err = ses.NewMailFrom(ctx, "exampleMailFrom", &ses.MailFromArgs{
			Domain:         exampleEmailIdentity.Email,
			MailFromDomain: pulumi.String("mail.example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

MAIL FROM domain can be imported using the `domain` attribute, e.g.,

```sh 

$ pulumi import aws:ses/mailFrom:MailFrom example example.com

```

func GetMailFrom 

func GetMailFrom(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *MailFromState, opts ...pulumi.ResourceOption) (*MailFrom, error)

GetMailFrom gets an existing MailFrom 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 NewMailFrom 

func NewMailFrom(ctx *pulumi.Context,
	name string, args *MailFromArgs, opts ...pulumi.ResourceOption) (*MailFrom, error)

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

func (*MailFrom) ElementType 

func (*MailFrom) ElementType() reflect.Type

func (*MailFrom) ToMailFromOutput 

func (i *MailFrom) ToMailFromOutput() MailFromOutput

func (*MailFrom) ToMailFromOutputWithContext 

func (i *MailFrom) ToMailFromOutputWithContext(ctx context.Context) MailFromOutput

type MailFromArgs 

type MailFromArgs struct {
	// The action that you want Amazon SES to take if it cannot successfully read the required MX record when you send an email. Defaults to `UseDefaultValue`. See the [SES API documentation](https://docs.aws.amazon.com/ses/latest/APIReference/API_SetIdentityMailFromDomain.html) for more information.
	BehaviorOnMxFailure pulumi.StringPtrInput
	// Verified domain name or email identity to generate DKIM tokens for.
	Domain pulumi.StringInput
	// Subdomain (of above domain) which is to be used as MAIL FROM address (Required for DMARC validation)
	//
	// The following arguments are optional:
	MailFromDomain pulumi.StringInput
}

The set of arguments for constructing a MailFrom resource.

func (MailFromArgs) ElementType 

func (MailFromArgs) ElementType() reflect.Type

type MailFromArray 

type MailFromArray []MailFromInput

func (MailFromArray) ElementType 

func (MailFromArray) ElementType() reflect.Type

func (MailFromArray) ToMailFromArrayOutput 

func (i MailFromArray) ToMailFromArrayOutput() MailFromArrayOutput

func (MailFromArray) ToMailFromArrayOutputWithContext 

func (i MailFromArray) ToMailFromArrayOutputWithContext(ctx context.Context) MailFromArrayOutput

type MailFromArrayInput 

type MailFromArrayInput interface {
	pulumi.Input

	ToMailFromArrayOutput() MailFromArrayOutput
	ToMailFromArrayOutputWithContext(context.Context) MailFromArrayOutput
}

MailFromArrayInput is an input type that accepts MailFromArray and MailFromArrayOutput values. You can construct a concrete instance of `MailFromArrayInput` via: 

MailFromArray{ MailFromArgs{...} }

type MailFromArrayOutput 

type MailFromArrayOutput struct{ *pulumi.OutputState }

func (MailFromArrayOutput) ElementType 

func (MailFromArrayOutput) ElementType() reflect.Type

func (MailFromArrayOutput) Index 

func (o MailFromArrayOutput) Index(i pulumi.IntInput) MailFromOutput

func (MailFromArrayOutput) ToMailFromArrayOutput 

func (o MailFromArrayOutput) ToMailFromArrayOutput() MailFromArrayOutput

func (MailFromArrayOutput) ToMailFromArrayOutputWithContext 

func (o MailFromArrayOutput) ToMailFromArrayOutputWithContext(ctx context.Context) MailFromArrayOutput

type MailFromInput 

type MailFromInput interface {
	pulumi.Input

	ToMailFromOutput() MailFromOutput
	ToMailFromOutputWithContext(ctx context.Context) MailFromOutput
}

type MailFromMap 

type MailFromMap map[string]MailFromInput

func (MailFromMap) ElementType 

func (MailFromMap) ElementType() reflect.Type

func (MailFromMap) ToMailFromMapOutput 

func (i MailFromMap) ToMailFromMapOutput() MailFromMapOutput

func (MailFromMap) ToMailFromMapOutputWithContext 

func (i MailFromMap) ToMailFromMapOutputWithContext(ctx context.Context) MailFromMapOutput

type MailFromMapInput 

type MailFromMapInput interface {
	pulumi.Input

	ToMailFromMapOutput() MailFromMapOutput
	ToMailFromMapOutputWithContext(context.Context) MailFromMapOutput
}

MailFromMapInput is an input type that accepts MailFromMap and MailFromMapOutput values. You can construct a concrete instance of `MailFromMapInput` via: 

MailFromMap{ "key": MailFromArgs{...} }

type MailFromMapOutput 

type MailFromMapOutput struct{ *pulumi.OutputState }

func (MailFromMapOutput) ElementType 

func (MailFromMapOutput) ElementType() reflect.Type

func (MailFromMapOutput) MapIndex 

func (o MailFromMapOutput) MapIndex(k pulumi.StringInput) MailFromOutput

func (MailFromMapOutput) ToMailFromMapOutput 

func (o MailFromMapOutput) ToMailFromMapOutput() MailFromMapOutput

func (MailFromMapOutput) ToMailFromMapOutputWithContext 

func (o MailFromMapOutput) ToMailFromMapOutputWithContext(ctx context.Context) MailFromMapOutput

type MailFromOutput 

type MailFromOutput struct{ *pulumi.OutputState }

func (MailFromOutput) BehaviorOnMxFailure 

func (o MailFromOutput) BehaviorOnMxFailure() pulumi.StringPtrOutput

The action that you want Amazon SES to take if it cannot successfully read the required MX record when you send an email. Defaults to `UseDefaultValue`. See the [SES API documentation](https://docs.aws.amazon.com/ses/latest/APIReference/API_SetIdentityMailFromDomain.html) for more information.

func (MailFromOutput) Domain 

func (o MailFromOutput) Domain() pulumi.StringOutput

Verified domain name or email identity to generate DKIM tokens for.

func (MailFromOutput) ElementType 

func (MailFromOutput) ElementType() reflect.Type

func (MailFromOutput) MailFromDomain 

func (o MailFromOutput) MailFromDomain() pulumi.StringOutput

Subdomain (of above domain) which is to be used as MAIL FROM address (Required for DMARC validation)

The following arguments are optional:

func (MailFromOutput) ToMailFromOutput 

func (o MailFromOutput) ToMailFromOutput() MailFromOutput

func (MailFromOutput) ToMailFromOutputWithContext 

func (o MailFromOutput) ToMailFromOutputWithContext(ctx context.Context) MailFromOutput

type MailFromState 

type MailFromState struct {
	// The action that you want Amazon SES to take if it cannot successfully read the required MX record when you send an email. Defaults to `UseDefaultValue`. See the [SES API documentation](https://docs.aws.amazon.com/ses/latest/APIReference/API_SetIdentityMailFromDomain.html) for more information.
	BehaviorOnMxFailure pulumi.StringPtrInput
	// Verified domain name or email identity to generate DKIM tokens for.
	Domain pulumi.StringPtrInput
	// Subdomain (of above domain) which is to be used as MAIL FROM address (Required for DMARC validation)
	//
	// The following arguments are optional:
	MailFromDomain pulumi.StringPtrInput
}

func (MailFromState) ElementType 

func (MailFromState) ElementType() reflect.Type

type ReceiptFilter 

type ReceiptFilter struct {
	pulumi.CustomResourceState

	// The SES receipt filter ARN.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The IP address or address range to filter, in CIDR notation
	Cidr pulumi.StringOutput `pulumi:"cidr"`
	// The name of the filter
	Name pulumi.StringOutput `pulumi:"name"`
	// Block or Allow
	Policy pulumi.StringOutput `pulumi:"policy"`
}

Provides an SES receipt filter resource

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ses.NewReceiptFilter(ctx, "filter", &ses.ReceiptFilterArgs{
			Cidr:   pulumi.String("10.10.10.10"),
			Policy: pulumi.String("Block"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

SES Receipt Filter can be imported using their `name`, e.g.,

```sh 

$ pulumi import aws:ses/receiptFilter:ReceiptFilter test some-filter

```

func GetReceiptFilter 

func GetReceiptFilter(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ReceiptFilterState, opts ...pulumi.ResourceOption) (*ReceiptFilter, error)

GetReceiptFilter gets an existing ReceiptFilter 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 NewReceiptFilter 

func NewReceiptFilter(ctx *pulumi.Context,
	name string, args *ReceiptFilterArgs, opts ...pulumi.ResourceOption) (*ReceiptFilter, error)

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

func (*ReceiptFilter) ElementType 

func (*ReceiptFilter) ElementType() reflect.Type

func (*ReceiptFilter) ToReceiptFilterOutput 

func (i *ReceiptFilter) ToReceiptFilterOutput() ReceiptFilterOutput

func (*ReceiptFilter) ToReceiptFilterOutputWithContext 

func (i *ReceiptFilter) ToReceiptFilterOutputWithContext(ctx context.Context) ReceiptFilterOutput

type ReceiptFilterArgs 

type ReceiptFilterArgs struct {
	// The IP address or address range to filter, in CIDR notation
	Cidr pulumi.StringInput
	// The name of the filter
	Name pulumi.StringPtrInput
	// Block or Allow
	Policy pulumi.StringInput
}

The set of arguments for constructing a ReceiptFilter resource.

func (ReceiptFilterArgs) ElementType 

func (ReceiptFilterArgs) ElementType() reflect.Type

type ReceiptFilterArray 

type ReceiptFilterArray []ReceiptFilterInput

func (ReceiptFilterArray) ElementType 

func (ReceiptFilterArray) ElementType() reflect.Type

func (ReceiptFilterArray) ToReceiptFilterArrayOutput 

func (i ReceiptFilterArray) ToReceiptFilterArrayOutput() ReceiptFilterArrayOutput

func (ReceiptFilterArray) ToReceiptFilterArrayOutputWithContext 

func (i ReceiptFilterArray) ToReceiptFilterArrayOutputWithContext(ctx context.Context) ReceiptFilterArrayOutput

type ReceiptFilterArrayInput 

type ReceiptFilterArrayInput interface {
	pulumi.Input

	ToReceiptFilterArrayOutput() ReceiptFilterArrayOutput
	ToReceiptFilterArrayOutputWithContext(context.Context) ReceiptFilterArrayOutput
}

ReceiptFilterArrayInput is an input type that accepts ReceiptFilterArray and ReceiptFilterArrayOutput values. You can construct a concrete instance of `ReceiptFilterArrayInput` via: 

ReceiptFilterArray{ ReceiptFilterArgs{...} }

type ReceiptFilterArrayOutput 

type ReceiptFilterArrayOutput struct{ *pulumi.OutputState }

func (ReceiptFilterArrayOutput) ElementType 

func (ReceiptFilterArrayOutput) ElementType() reflect.Type

func (ReceiptFilterArrayOutput) Index 

func (o ReceiptFilterArrayOutput) Index(i pulumi.IntInput) ReceiptFilterOutput

func (ReceiptFilterArrayOutput) ToReceiptFilterArrayOutput 

func (o ReceiptFilterArrayOutput) ToReceiptFilterArrayOutput() ReceiptFilterArrayOutput

func (ReceiptFilterArrayOutput) ToReceiptFilterArrayOutputWithContext 

func (o ReceiptFilterArrayOutput) ToReceiptFilterArrayOutputWithContext(ctx context.Context) ReceiptFilterArrayOutput

type ReceiptFilterInput 

type ReceiptFilterInput interface {
	pulumi.Input

	ToReceiptFilterOutput() ReceiptFilterOutput
	ToReceiptFilterOutputWithContext(ctx context.Context) ReceiptFilterOutput
}

type ReceiptFilterMap 

type ReceiptFilterMap map[string]ReceiptFilterInput

func (ReceiptFilterMap) ElementType 

func (ReceiptFilterMap) ElementType() reflect.Type

func (ReceiptFilterMap) ToReceiptFilterMapOutput 

func (i ReceiptFilterMap) ToReceiptFilterMapOutput() ReceiptFilterMapOutput

func (ReceiptFilterMap) ToReceiptFilterMapOutputWithContext 

func (i ReceiptFilterMap) ToReceiptFilterMapOutputWithContext(ctx context.Context) ReceiptFilterMapOutput

type ReceiptFilterMapInput 

type ReceiptFilterMapInput interface {
	pulumi.Input

	ToReceiptFilterMapOutput() ReceiptFilterMapOutput
	ToReceiptFilterMapOutputWithContext(context.Context) ReceiptFilterMapOutput
}

ReceiptFilterMapInput is an input type that accepts ReceiptFilterMap and ReceiptFilterMapOutput values. You can construct a concrete instance of `ReceiptFilterMapInput` via: 

ReceiptFilterMap{ "key": ReceiptFilterArgs{...} }

type ReceiptFilterMapOutput 

type ReceiptFilterMapOutput struct{ *pulumi.OutputState }

func (ReceiptFilterMapOutput) ElementType 

func (ReceiptFilterMapOutput) ElementType() reflect.Type

func (ReceiptFilterMapOutput) MapIndex 

func (o ReceiptFilterMapOutput) MapIndex(k pulumi.StringInput) ReceiptFilterOutput

func (ReceiptFilterMapOutput) ToReceiptFilterMapOutput 

func (o ReceiptFilterMapOutput) ToReceiptFilterMapOutput() ReceiptFilterMapOutput

func (ReceiptFilterMapOutput) ToReceiptFilterMapOutputWithContext 

func (o ReceiptFilterMapOutput) ToReceiptFilterMapOutputWithContext(ctx context.Context) ReceiptFilterMapOutput

type ReceiptFilterOutput 

type ReceiptFilterOutput struct{ *pulumi.OutputState }

func (ReceiptFilterOutput) Arn 

func (o ReceiptFilterOutput) Arn() pulumi.StringOutput

The SES receipt filter ARN.

func (ReceiptFilterOutput) Cidr 

func (o ReceiptFilterOutput) Cidr() pulumi.StringOutput

The IP address or address range to filter, in CIDR notation

func (ReceiptFilterOutput) ElementType 

func (ReceiptFilterOutput) ElementType() reflect.Type

func (ReceiptFilterOutput) Name 

func (o ReceiptFilterOutput) Name() pulumi.StringOutput

The name of the filter

func (ReceiptFilterOutput) Policy 

func (o ReceiptFilterOutput) Policy() pulumi.StringOutput

Block or Allow

func (ReceiptFilterOutput) ToReceiptFilterOutput 

func (o ReceiptFilterOutput) ToReceiptFilterOutput() ReceiptFilterOutput

func (ReceiptFilterOutput) ToReceiptFilterOutputWithContext 

func (o ReceiptFilterOutput) ToReceiptFilterOutputWithContext(ctx context.Context) ReceiptFilterOutput

type ReceiptFilterState 

type ReceiptFilterState struct {
	// The SES receipt filter ARN.
	Arn pulumi.StringPtrInput
	// The IP address or address range to filter, in CIDR notation
	Cidr pulumi.StringPtrInput
	// The name of the filter
	Name pulumi.StringPtrInput
	// Block or Allow
	Policy pulumi.StringPtrInput
}

func (ReceiptFilterState) ElementType 

func (ReceiptFilterState) ElementType() reflect.Type

type ReceiptRule 

type ReceiptRule struct {
	pulumi.CustomResourceState

	// A list of Add Header Action blocks. Documented below.
	AddHeaderActions ReceiptRuleAddHeaderActionArrayOutput `pulumi:"addHeaderActions"`
	// The name of the rule to place this rule after
	After pulumi.StringPtrOutput `pulumi:"after"`
	// The SES receipt rule ARN.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// A list of Bounce Action blocks. Documented below.
	BounceActions ReceiptRuleBounceActionArrayOutput `pulumi:"bounceActions"`
	// If true, the rule will be enabled
	Enabled pulumi.BoolPtrOutput `pulumi:"enabled"`
	// A list of Lambda Action blocks. Documented below.
	LambdaActions ReceiptRuleLambdaActionArrayOutput `pulumi:"lambdaActions"`
	// The name of the rule
	Name pulumi.StringOutput `pulumi:"name"`
	// A list of email addresses
	Recipients pulumi.StringArrayOutput `pulumi:"recipients"`
	// The name of the rule set
	RuleSetName pulumi.StringOutput `pulumi:"ruleSetName"`
	// A list of S3 Action blocks. Documented below.
	S3Actions ReceiptRuleS3ActionArrayOutput `pulumi:"s3Actions"`
	// If true, incoming emails will be scanned for spam and viruses
	ScanEnabled pulumi.BoolPtrOutput `pulumi:"scanEnabled"`
	// A list of SNS Action blocks. Documented below.
	SnsActions ReceiptRuleSnsActionArrayOutput `pulumi:"snsActions"`
	// A list of Stop Action blocks. Documented below.
	StopActions ReceiptRuleStopActionArrayOutput `pulumi:"stopActions"`
	// `Require` or `Optional`
	TlsPolicy pulumi.StringOutput `pulumi:"tlsPolicy"`
	// A list of WorkMail Action blocks. Documented below.
	WorkmailActions ReceiptRuleWorkmailActionArrayOutput `pulumi:"workmailActions"`
}

Provides an SES receipt rule resource

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ses.NewReceiptRule(ctx, "store", &ses.ReceiptRuleArgs{
			AddHeaderActions: ses.ReceiptRuleAddHeaderActionArray{
				&ses.ReceiptRuleAddHeaderActionArgs{
					HeaderName:  pulumi.String("Custom-Header"),
					HeaderValue: pulumi.String("Added by SES"),
					Position:    pulumi.Int(1),
				},
			},
			Enabled: pulumi.Bool(true),
			Recipients: pulumi.StringArray{
				pulumi.String("karen@example.com"),
			},
			RuleSetName: pulumi.String("default-rule-set"),
			S3Actions: ses.ReceiptRuleS3ActionArray{
				&ses.ReceiptRuleS3ActionArgs{
					BucketName: pulumi.String("emails"),
					Position:   pulumi.Int(2),
				},
			},
			ScanEnabled: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

SES receipt rules can be imported using the ruleset name and rule name separated by `:`.

```sh 

$ pulumi import aws:ses/receiptRule:ReceiptRule my_rule my_rule_set:my_rule

```

func GetReceiptRule 

func GetReceiptRule(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ReceiptRuleState, opts ...pulumi.ResourceOption) (*ReceiptRule, error)

GetReceiptRule gets an existing ReceiptRule 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 NewReceiptRule 

func NewReceiptRule(ctx *pulumi.Context,
	name string, args *ReceiptRuleArgs, opts ...pulumi.ResourceOption) (*ReceiptRule, error)

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

func (*ReceiptRule) ElementType 

func (*ReceiptRule) ElementType() reflect.Type

func (*ReceiptRule) ToReceiptRuleOutput 

func (i *ReceiptRule) ToReceiptRuleOutput() ReceiptRuleOutput

func (*ReceiptRule) ToReceiptRuleOutputWithContext 

func (i *ReceiptRule) ToReceiptRuleOutputWithContext(ctx context.Context) ReceiptRuleOutput

type ReceiptRuleAddHeaderAction 

type ReceiptRuleAddHeaderAction struct {
	// The name of the header to add
	HeaderName string `pulumi:"headerName"`
	// The value of the header to add
	HeaderValue string `pulumi:"headerValue"`
	// The position of the action in the receipt rule
	Position int `pulumi:"position"`
}

type ReceiptRuleAddHeaderActionArgs 

type ReceiptRuleAddHeaderActionArgs struct {
	// The name of the header to add
	HeaderName pulumi.StringInput `pulumi:"headerName"`
	// The value of the header to add
	HeaderValue pulumi.StringInput `pulumi:"headerValue"`
	// The position of the action in the receipt rule
	Position pulumi.IntInput `pulumi:"position"`
}

func (ReceiptRuleAddHeaderActionArgs) ElementType 

func (ReceiptRuleAddHeaderActionArgs) ElementType() reflect.Type

func (ReceiptRuleAddHeaderActionArgs) ToReceiptRuleAddHeaderActionOutput 

func (i ReceiptRuleAddHeaderActionArgs) ToReceiptRuleAddHeaderActionOutput() ReceiptRuleAddHeaderActionOutput

func (ReceiptRuleAddHeaderActionArgs) ToReceiptRuleAddHeaderActionOutputWithContext 

func (i ReceiptRuleAddHeaderActionArgs) ToReceiptRuleAddHeaderActionOutputWithContext(ctx context.Context) ReceiptRuleAddHeaderActionOutput

type ReceiptRuleAddHeaderActionArray 

type ReceiptRuleAddHeaderActionArray []ReceiptRuleAddHeaderActionInput

func (ReceiptRuleAddHeaderActionArray) ElementType 

func (ReceiptRuleAddHeaderActionArray) ElementType() reflect.Type

func (ReceiptRuleAddHeaderActionArray) ToReceiptRuleAddHeaderActionArrayOutput 

func (i ReceiptRuleAddHeaderActionArray) ToReceiptRuleAddHeaderActionArrayOutput() ReceiptRuleAddHeaderActionArrayOutput

func (ReceiptRuleAddHeaderActionArray) ToReceiptRuleAddHeaderActionArrayOutputWithContext 

func (i ReceiptRuleAddHeaderActionArray) ToReceiptRuleAddHeaderActionArrayOutputWithContext(ctx context.Context) ReceiptRuleAddHeaderActionArrayOutput

type ReceiptRuleAddHeaderActionArrayInput 

type ReceiptRuleAddHeaderActionArrayInput interface {
	pulumi.Input

	ToReceiptRuleAddHeaderActionArrayOutput() ReceiptRuleAddHeaderActionArrayOutput
	ToReceiptRuleAddHeaderActionArrayOutputWithContext(context.Context) ReceiptRuleAddHeaderActionArrayOutput
}

ReceiptRuleAddHeaderActionArrayInput is an input type that accepts ReceiptRuleAddHeaderActionArray and ReceiptRuleAddHeaderActionArrayOutput values. You can construct a concrete instance of `ReceiptRuleAddHeaderActionArrayInput` via: 

ReceiptRuleAddHeaderActionArray{ ReceiptRuleAddHeaderActionArgs{...} }

type ReceiptRuleAddHeaderActionArrayOutput 

type ReceiptRuleAddHeaderActionArrayOutput struct{ *pulumi.OutputState }

func (ReceiptRuleAddHeaderActionArrayOutput) ElementType 

func (ReceiptRuleAddHeaderActionArrayOutput) ElementType() reflect.Type

func (ReceiptRuleAddHeaderActionArrayOutput) Index 

func (o ReceiptRuleAddHeaderActionArrayOutput) Index(i pulumi.IntInput) ReceiptRuleAddHeaderActionOutput

func (ReceiptRuleAddHeaderActionArrayOutput) ToReceiptRuleAddHeaderActionArrayOutput 

func (o ReceiptRuleAddHeaderActionArrayOutput) ToReceiptRuleAddHeaderActionArrayOutput() ReceiptRuleAddHeaderActionArrayOutput

func (ReceiptRuleAddHeaderActionArrayOutput) ToReceiptRuleAddHeaderActionArrayOutputWithContext 

func (o ReceiptRuleAddHeaderActionArrayOutput) ToReceiptRuleAddHeaderActionArrayOutputWithContext(ctx context.Context) ReceiptRuleAddHeaderActionArrayOutput

type ReceiptRuleAddHeaderActionInput 

type ReceiptRuleAddHeaderActionInput interface {
	pulumi.Input

	ToReceiptRuleAddHeaderActionOutput() ReceiptRuleAddHeaderActionOutput
	ToReceiptRuleAddHeaderActionOutputWithContext(context.Context) ReceiptRuleAddHeaderActionOutput
}

ReceiptRuleAddHeaderActionInput is an input type that accepts ReceiptRuleAddHeaderActionArgs and ReceiptRuleAddHeaderActionOutput values. You can construct a concrete instance of `ReceiptRuleAddHeaderActionInput` via: 

ReceiptRuleAddHeaderActionArgs{...}

type ReceiptRuleAddHeaderActionOutput 

type ReceiptRuleAddHeaderActionOutput struct{ *pulumi.OutputState }

func (ReceiptRuleAddHeaderActionOutput) ElementType 

func (ReceiptRuleAddHeaderActionOutput) ElementType() reflect.Type

func (ReceiptRuleAddHeaderActionOutput) HeaderName 

func (o ReceiptRuleAddHeaderActionOutput) HeaderName() pulumi.StringOutput

The name of the header to add

func (ReceiptRuleAddHeaderActionOutput) HeaderValue 

func (o ReceiptRuleAddHeaderActionOutput) HeaderValue() pulumi.StringOutput

The value of the header to add

func (ReceiptRuleAddHeaderActionOutput) Position 

func (o ReceiptRuleAddHeaderActionOutput) Position() pulumi.IntOutput

The position of the action in the receipt rule

func (ReceiptRuleAddHeaderActionOutput) ToReceiptRuleAddHeaderActionOutput 

func (o ReceiptRuleAddHeaderActionOutput) ToReceiptRuleAddHeaderActionOutput() ReceiptRuleAddHeaderActionOutput

func (ReceiptRuleAddHeaderActionOutput) ToReceiptRuleAddHeaderActionOutputWithContext 

func (o ReceiptRuleAddHeaderActionOutput) ToReceiptRuleAddHeaderActionOutputWithContext(ctx context.Context) ReceiptRuleAddHeaderActionOutput

type ReceiptRuleArgs 

type ReceiptRuleArgs struct {
	// A list of Add Header Action blocks. Documented below.
	AddHeaderActions ReceiptRuleAddHeaderActionArrayInput
	// The name of the rule to place this rule after
	After pulumi.StringPtrInput
	// A list of Bounce Action blocks. Documented below.
	BounceActions ReceiptRuleBounceActionArrayInput
	// If true, the rule will be enabled
	Enabled pulumi.BoolPtrInput
	// A list of Lambda Action blocks. Documented below.
	LambdaActions ReceiptRuleLambdaActionArrayInput
	// The name of the rule
	Name pulumi.StringPtrInput
	// A list of email addresses
	Recipients pulumi.StringArrayInput
	// The name of the rule set
	RuleSetName pulumi.StringInput
	// A list of S3 Action blocks. Documented below.
	S3Actions ReceiptRuleS3ActionArrayInput
	// If true, incoming emails will be scanned for spam and viruses
	ScanEnabled pulumi.BoolPtrInput
	// A list of SNS Action blocks. Documented below.
	SnsActions ReceiptRuleSnsActionArrayInput
	// A list of Stop Action blocks. Documented below.
	StopActions ReceiptRuleStopActionArrayInput
	// `Require` or `Optional`
	TlsPolicy pulumi.StringPtrInput
	// A list of WorkMail Action blocks. Documented below.
	WorkmailActions ReceiptRuleWorkmailActionArrayInput
}

The set of arguments for constructing a ReceiptRule resource.

func (ReceiptRuleArgs) ElementType 

func (ReceiptRuleArgs) ElementType() reflect.Type

type ReceiptRuleArray 

type ReceiptRuleArray []ReceiptRuleInput

func (ReceiptRuleArray) ElementType 

func (ReceiptRuleArray) ElementType() reflect.Type

func (ReceiptRuleArray) ToReceiptRuleArrayOutput 

func (i ReceiptRuleArray) ToReceiptRuleArrayOutput() ReceiptRuleArrayOutput

func (ReceiptRuleArray) ToReceiptRuleArrayOutputWithContext 

func (i ReceiptRuleArray) ToReceiptRuleArrayOutputWithContext(ctx context.Context) ReceiptRuleArrayOutput

type ReceiptRuleArrayInput 

type ReceiptRuleArrayInput interface {
	pulumi.Input

	ToReceiptRuleArrayOutput() ReceiptRuleArrayOutput
	ToReceiptRuleArrayOutputWithContext(context.Context) ReceiptRuleArrayOutput
}

ReceiptRuleArrayInput is an input type that accepts ReceiptRuleArray and ReceiptRuleArrayOutput values. You can construct a concrete instance of `ReceiptRuleArrayInput` via: 

ReceiptRuleArray{ ReceiptRuleArgs{...} }

type ReceiptRuleArrayOutput 

type ReceiptRuleArrayOutput struct{ *pulumi.OutputState }

func (ReceiptRuleArrayOutput) ElementType 

func (ReceiptRuleArrayOutput) ElementType() reflect.Type

func (ReceiptRuleArrayOutput) Index 

func (o ReceiptRuleArrayOutput) Index(i pulumi.IntInput) ReceiptRuleOutput

func (ReceiptRuleArrayOutput) ToReceiptRuleArrayOutput 

func (o ReceiptRuleArrayOutput) ToReceiptRuleArrayOutput() ReceiptRuleArrayOutput

func (ReceiptRuleArrayOutput) ToReceiptRuleArrayOutputWithContext 

func (o ReceiptRuleArrayOutput) ToReceiptRuleArrayOutputWithContext(ctx context.Context) ReceiptRuleArrayOutput

type ReceiptRuleBounceAction 

type ReceiptRuleBounceAction struct {
	// The message to send
	Message string `pulumi:"message"`
	// The position of the action in the receipt rule
	Position int `pulumi:"position"`
	// The email address of the sender
	Sender string `pulumi:"sender"`
	// The RFC 5321 SMTP reply code
	SmtpReplyCode string `pulumi:"smtpReplyCode"`
	// The RFC 3463 SMTP enhanced status code
	StatusCode *string `pulumi:"statusCode"`
	// The ARN of an SNS topic to notify
	TopicArn *string `pulumi:"topicArn"`
}

type ReceiptRuleBounceActionArgs 

type ReceiptRuleBounceActionArgs struct {
	// The message to send
	Message pulumi.StringInput `pulumi:"message"`
	// The position of the action in the receipt rule
	Position pulumi.IntInput `pulumi:"position"`
	// The email address of the sender
	Sender pulumi.StringInput `pulumi:"sender"`
	// The RFC 5321 SMTP reply code
	SmtpReplyCode pulumi.StringInput `pulumi:"smtpReplyCode"`
	// The RFC 3463 SMTP enhanced status code
	StatusCode pulumi.StringPtrInput `pulumi:"statusCode"`
	// The ARN of an SNS topic to notify
	TopicArn pulumi.StringPtrInput `pulumi:"topicArn"`
}

func (ReceiptRuleBounceActionArgs) ElementType 

func (ReceiptRuleBounceActionArgs) ElementType() reflect.Type

func (ReceiptRuleBounceActionArgs) ToReceiptRuleBounceActionOutput 

func (i ReceiptRuleBounceActionArgs) ToReceiptRuleBounceActionOutput() ReceiptRuleBounceActionOutput

func (ReceiptRuleBounceActionArgs) ToReceiptRuleBounceActionOutputWithContext 

func (i ReceiptRuleBounceActionArgs) ToReceiptRuleBounceActionOutputWithContext(ctx context.Context) ReceiptRuleBounceActionOutput

type ReceiptRuleBounceActionArray 

type ReceiptRuleBounceActionArray []ReceiptRuleBounceActionInput

func (ReceiptRuleBounceActionArray) ElementType 

func (ReceiptRuleBounceActionArray) ElementType() reflect.Type

func (ReceiptRuleBounceActionArray) ToReceiptRuleBounceActionArrayOutput 

func (i ReceiptRuleBounceActionArray) ToReceiptRuleBounceActionArrayOutput() ReceiptRuleBounceActionArrayOutput

func (ReceiptRuleBounceActionArray) ToReceiptRuleBounceActionArrayOutputWithContext 

func (i ReceiptRuleBounceActionArray) ToReceiptRuleBounceActionArrayOutputWithContext(ctx context.Context) ReceiptRuleBounceActionArrayOutput

type ReceiptRuleBounceActionArrayInput 

type ReceiptRuleBounceActionArrayInput interface {
	pulumi.Input

	ToReceiptRuleBounceActionArrayOutput() ReceiptRuleBounceActionArrayOutput
	ToReceiptRuleBounceActionArrayOutputWithContext(context.Context) ReceiptRuleBounceActionArrayOutput
}

ReceiptRuleBounceActionArrayInput is an input type that accepts ReceiptRuleBounceActionArray and ReceiptRuleBounceActionArrayOutput values. You can construct a concrete instance of `ReceiptRuleBounceActionArrayInput` via: 

ReceiptRuleBounceActionArray{ ReceiptRuleBounceActionArgs{...} }

type ReceiptRuleBounceActionArrayOutput 

type ReceiptRuleBounceActionArrayOutput struct{ *pulumi.OutputState }

func (ReceiptRuleBounceActionArrayOutput) ElementType 

func (ReceiptRuleBounceActionArrayOutput) ElementType() reflect.Type

func (ReceiptRuleBounceActionArrayOutput) Index 

func (o ReceiptRuleBounceActionArrayOutput) Index(i pulumi.IntInput) ReceiptRuleBounceActionOutput

func (ReceiptRuleBounceActionArrayOutput) ToReceiptRuleBounceActionArrayOutput 

func (o ReceiptRuleBounceActionArrayOutput) ToReceiptRuleBounceActionArrayOutput() ReceiptRuleBounceActionArrayOutput

func (ReceiptRuleBounceActionArrayOutput) ToReceiptRuleBounceActionArrayOutputWithContext 

func (o ReceiptRuleBounceActionArrayOutput) ToReceiptRuleBounceActionArrayOutputWithContext(ctx context.Context) ReceiptRuleBounceActionArrayOutput

type ReceiptRuleBounceActionInput 

type ReceiptRuleBounceActionInput interface {
	pulumi.Input

	ToReceiptRuleBounceActionOutput() ReceiptRuleBounceActionOutput
	ToReceiptRuleBounceActionOutputWithContext(context.Context) ReceiptRuleBounceActionOutput
}

ReceiptRuleBounceActionInput is an input type that accepts ReceiptRuleBounceActionArgs and ReceiptRuleBounceActionOutput values. You can construct a concrete instance of `ReceiptRuleBounceActionInput` via: 

ReceiptRuleBounceActionArgs{...}

type ReceiptRuleBounceActionOutput 

type ReceiptRuleBounceActionOutput struct{ *pulumi.OutputState }

func (ReceiptRuleBounceActionOutput) ElementType 

func (ReceiptRuleBounceActionOutput) ElementType() reflect.Type

func (ReceiptRuleBounceActionOutput) Message 

func (o ReceiptRuleBounceActionOutput) Message() pulumi.StringOutput

The message to send

func (ReceiptRuleBounceActionOutput) Position 

func (o ReceiptRuleBounceActionOutput) Position() pulumi.IntOutput

The position of the action in the receipt rule

func (ReceiptRuleBounceActionOutput) Sender 

func (o ReceiptRuleBounceActionOutput) Sender() pulumi.StringOutput

The email address of the sender

func (ReceiptRuleBounceActionOutput) SmtpReplyCode 

func (o ReceiptRuleBounceActionOutput) SmtpReplyCode() pulumi.StringOutput

The RFC 5321 SMTP reply code

func (ReceiptRuleBounceActionOutput) StatusCode 

func (o ReceiptRuleBounceActionOutput) StatusCode() pulumi.StringPtrOutput

The RFC 3463 SMTP enhanced status code

func (ReceiptRuleBounceActionOutput) ToReceiptRuleBounceActionOutput 

func (o ReceiptRuleBounceActionOutput) ToReceiptRuleBounceActionOutput() ReceiptRuleBounceActionOutput

func (ReceiptRuleBounceActionOutput) ToReceiptRuleBounceActionOutputWithContext 

func (o ReceiptRuleBounceActionOutput) ToReceiptRuleBounceActionOutputWithContext(ctx context.Context) ReceiptRuleBounceActionOutput

func (ReceiptRuleBounceActionOutput) TopicArn 

func (o ReceiptRuleBounceActionOutput) TopicArn() pulumi.StringPtrOutput

The ARN of an SNS topic to notify

type ReceiptRuleInput 

type ReceiptRuleInput interface {
	pulumi.Input

	ToReceiptRuleOutput() ReceiptRuleOutput
	ToReceiptRuleOutputWithContext(ctx context.Context) ReceiptRuleOutput
}

type ReceiptRuleLambdaAction 

type ReceiptRuleLambdaAction struct {
	// The ARN of the Lambda function to invoke
	FunctionArn string `pulumi:"functionArn"`
	// `Event` or `RequestResponse`
	InvocationType *string `pulumi:"invocationType"`
	// The position of the action in the receipt rule
	Position int `pulumi:"position"`
	// The ARN of an SNS topic to notify
	TopicArn *string `pulumi:"topicArn"`
}

type ReceiptRuleLambdaActionArgs 

type ReceiptRuleLambdaActionArgs struct {
	// The ARN of the Lambda function to invoke
	FunctionArn pulumi.StringInput `pulumi:"functionArn"`
	// `Event` or `RequestResponse`
	InvocationType pulumi.StringPtrInput `pulumi:"invocationType"`
	// The position of the action in the receipt rule
	Position pulumi.IntInput `pulumi:"position"`
	// The ARN of an SNS topic to notify
	TopicArn pulumi.StringPtrInput `pulumi:"topicArn"`
}

func (ReceiptRuleLambdaActionArgs) ElementType 

func (ReceiptRuleLambdaActionArgs) ElementType() reflect.Type

func (ReceiptRuleLambdaActionArgs) ToReceiptRuleLambdaActionOutput 

func (i ReceiptRuleLambdaActionArgs) ToReceiptRuleLambdaActionOutput() ReceiptRuleLambdaActionOutput

func (ReceiptRuleLambdaActionArgs) ToReceiptRuleLambdaActionOutputWithContext 

func (i ReceiptRuleLambdaActionArgs) ToReceiptRuleLambdaActionOutputWithContext(ctx context.Context) ReceiptRuleLambdaActionOutput

type ReceiptRuleLambdaActionArray 

type ReceiptRuleLambdaActionArray []ReceiptRuleLambdaActionInput

func (ReceiptRuleLambdaActionArray) ElementType 

func (ReceiptRuleLambdaActionArray) ElementType() reflect.Type

func (ReceiptRuleLambdaActionArray) ToReceiptRuleLambdaActionArrayOutput 

func (i ReceiptRuleLambdaActionArray) ToReceiptRuleLambdaActionArrayOutput() ReceiptRuleLambdaActionArrayOutput

func (ReceiptRuleLambdaActionArray) ToReceiptRuleLambdaActionArrayOutputWithContext 

func (i ReceiptRuleLambdaActionArray) ToReceiptRuleLambdaActionArrayOutputWithContext(ctx context.Context) ReceiptRuleLambdaActionArrayOutput

type ReceiptRuleLambdaActionArrayInput 

type ReceiptRuleLambdaActionArrayInput interface {
	pulumi.Input

	ToReceiptRuleLambdaActionArrayOutput() ReceiptRuleLambdaActionArrayOutput
	ToReceiptRuleLambdaActionArrayOutputWithContext(context.Context) ReceiptRuleLambdaActionArrayOutput
}

ReceiptRuleLambdaActionArrayInput is an input type that accepts ReceiptRuleLambdaActionArray and ReceiptRuleLambdaActionArrayOutput values. You can construct a concrete instance of `ReceiptRuleLambdaActionArrayInput` via: 

ReceiptRuleLambdaActionArray{ ReceiptRuleLambdaActionArgs{...} }

type ReceiptRuleLambdaActionArrayOutput 

type ReceiptRuleLambdaActionArrayOutput struct{ *pulumi.OutputState }

func (ReceiptRuleLambdaActionArrayOutput) ElementType 

func (ReceiptRuleLambdaActionArrayOutput) ElementType() reflect.Type

func (ReceiptRuleLambdaActionArrayOutput) Index 

func (o ReceiptRuleLambdaActionArrayOutput) Index(i pulumi.IntInput) ReceiptRuleLambdaActionOutput

func (ReceiptRuleLambdaActionArrayOutput) ToReceiptRuleLambdaActionArrayOutput 

func (o ReceiptRuleLambdaActionArrayOutput) ToReceiptRuleLambdaActionArrayOutput() ReceiptRuleLambdaActionArrayOutput

func (ReceiptRuleLambdaActionArrayOutput) ToReceiptRuleLambdaActionArrayOutputWithContext 

func (o ReceiptRuleLambdaActionArrayOutput) ToReceiptRuleLambdaActionArrayOutputWithContext(ctx context.Context) ReceiptRuleLambdaActionArrayOutput

type ReceiptRuleLambdaActionInput 

type ReceiptRuleLambdaActionInput interface {
	pulumi.Input

	ToReceiptRuleLambdaActionOutput() ReceiptRuleLambdaActionOutput
	ToReceiptRuleLambdaActionOutputWithContext(context.Context) ReceiptRuleLambdaActionOutput
}

ReceiptRuleLambdaActionInput is an input type that accepts ReceiptRuleLambdaActionArgs and ReceiptRuleLambdaActionOutput values. You can construct a concrete instance of `ReceiptRuleLambdaActionInput` via: 

ReceiptRuleLambdaActionArgs{...}

type ReceiptRuleLambdaActionOutput 

type ReceiptRuleLambdaActionOutput struct{ *pulumi.OutputState }

func (ReceiptRuleLambdaActionOutput) ElementType 

func (ReceiptRuleLambdaActionOutput) ElementType() reflect.Type

func (ReceiptRuleLambdaActionOutput) FunctionArn 

func (o ReceiptRuleLambdaActionOutput) FunctionArn() pulumi.StringOutput

The ARN of the Lambda function to invoke

func (ReceiptRuleLambdaActionOutput) InvocationType 

func (o ReceiptRuleLambdaActionOutput) InvocationType() pulumi.StringPtrOutput

`Event` or `RequestResponse`

func (ReceiptRuleLambdaActionOutput) Position 

func (o ReceiptRuleLambdaActionOutput) Position() pulumi.IntOutput

The position of the action in the receipt rule

func (ReceiptRuleLambdaActionOutput) ToReceiptRuleLambdaActionOutput 

func (o ReceiptRuleLambdaActionOutput) ToReceiptRuleLambdaActionOutput() ReceiptRuleLambdaActionOutput

func (ReceiptRuleLambdaActionOutput) ToReceiptRuleLambdaActionOutputWithContext 

func (o ReceiptRuleLambdaActionOutput) ToReceiptRuleLambdaActionOutputWithContext(ctx context.Context) ReceiptRuleLambdaActionOutput

func (ReceiptRuleLambdaActionOutput) TopicArn 

func (o ReceiptRuleLambdaActionOutput) TopicArn() pulumi.StringPtrOutput

The ARN of an SNS topic to notify

type ReceiptRuleMap 

type ReceiptRuleMap map[string]ReceiptRuleInput

func (ReceiptRuleMap) ElementType 

func (ReceiptRuleMap) ElementType() reflect.Type

func (ReceiptRuleMap) ToReceiptRuleMapOutput 

func (i ReceiptRuleMap) ToReceiptRuleMapOutput() ReceiptRuleMapOutput

func (ReceiptRuleMap) ToReceiptRuleMapOutputWithContext 

func (i ReceiptRuleMap) ToReceiptRuleMapOutputWithContext(ctx context.Context) ReceiptRuleMapOutput

type ReceiptRuleMapInput 

type ReceiptRuleMapInput interface {
	pulumi.Input

	ToReceiptRuleMapOutput() ReceiptRuleMapOutput
	ToReceiptRuleMapOutputWithContext(context.Context) ReceiptRuleMapOutput
}

ReceiptRuleMapInput is an input type that accepts ReceiptRuleMap and ReceiptRuleMapOutput values. You can construct a concrete instance of `ReceiptRuleMapInput` via: 

ReceiptRuleMap{ "key": ReceiptRuleArgs{...} }

type ReceiptRuleMapOutput 

type ReceiptRuleMapOutput struct{ *pulumi.OutputState }

func (ReceiptRuleMapOutput) ElementType 

func (ReceiptRuleMapOutput) ElementType() reflect.Type

func (ReceiptRuleMapOutput) MapIndex 

func (o ReceiptRuleMapOutput) MapIndex(k pulumi.StringInput) ReceiptRuleOutput

func (ReceiptRuleMapOutput) ToReceiptRuleMapOutput 

func (o ReceiptRuleMapOutput) ToReceiptRuleMapOutput() ReceiptRuleMapOutput

func (ReceiptRuleMapOutput) ToReceiptRuleMapOutputWithContext 

func (o ReceiptRuleMapOutput) ToReceiptRuleMapOutputWithContext(ctx context.Context) ReceiptRuleMapOutput

type ReceiptRuleOutput 

type ReceiptRuleOutput struct{ *pulumi.OutputState }

func (ReceiptRuleOutput) AddHeaderActions 

func (o ReceiptRuleOutput) AddHeaderActions() ReceiptRuleAddHeaderActionArrayOutput

A list of Add Header Action blocks. Documented below.

func (ReceiptRuleOutput) After 

func (o ReceiptRuleOutput) After() pulumi.StringPtrOutput

The name of the rule to place this rule after

func (ReceiptRuleOutput) Arn 

func (o ReceiptRuleOutput) Arn() pulumi.StringOutput

The SES receipt rule ARN.

func (ReceiptRuleOutput) BounceActions 

func (o ReceiptRuleOutput) BounceActions() ReceiptRuleBounceActionArrayOutput

A list of Bounce Action blocks. Documented below.

func (ReceiptRuleOutput) ElementType 

func (ReceiptRuleOutput) ElementType() reflect.Type

func (ReceiptRuleOutput) Enabled 

func (o ReceiptRuleOutput) Enabled() pulumi.BoolPtrOutput

If true, the rule will be enabled

func (ReceiptRuleOutput) LambdaActions 

func (o ReceiptRuleOutput) LambdaActions() ReceiptRuleLambdaActionArrayOutput

A list of Lambda Action blocks. Documented below.

func (ReceiptRuleOutput) Name 

func (o ReceiptRuleOutput) Name() pulumi.StringOutput

The name of the rule

func (ReceiptRuleOutput) Recipients 

func (o ReceiptRuleOutput) Recipients() pulumi.StringArrayOutput

A list of email addresses

func (ReceiptRuleOutput) RuleSetName 

func (o ReceiptRuleOutput) RuleSetName() pulumi.StringOutput

The name of the rule set

func (ReceiptRuleOutput) S3Actions 

func (o ReceiptRuleOutput) S3Actions() ReceiptRuleS3ActionArrayOutput

A list of S3 Action blocks. Documented below.

func (ReceiptRuleOutput) ScanEnabled 

func (o ReceiptRuleOutput) ScanEnabled() pulumi.BoolPtrOutput

If true, incoming emails will be scanned for spam and viruses

func (ReceiptRuleOutput) SnsActions 

func (o ReceiptRuleOutput) SnsActions() ReceiptRuleSnsActionArrayOutput

A list of SNS Action blocks. Documented below.

func (ReceiptRuleOutput) StopActions 

func (o ReceiptRuleOutput) StopActions() ReceiptRuleStopActionArrayOutput

A list of Stop Action blocks. Documented below.

func (ReceiptRuleOutput) TlsPolicy 

func (o ReceiptRuleOutput) TlsPolicy() pulumi.StringOutput

`Require` or `Optional`

func (ReceiptRuleOutput) ToReceiptRuleOutput 

func (o ReceiptRuleOutput) ToReceiptRuleOutput() ReceiptRuleOutput

func (ReceiptRuleOutput) ToReceiptRuleOutputWithContext 

func (o ReceiptRuleOutput) ToReceiptRuleOutputWithContext(ctx context.Context) ReceiptRuleOutput

func (ReceiptRuleOutput) WorkmailActions 

func (o ReceiptRuleOutput) WorkmailActions() ReceiptRuleWorkmailActionArrayOutput

A list of WorkMail Action blocks. Documented below.

type ReceiptRuleS3Action 

type ReceiptRuleS3Action struct {
	// The name of the S3 bucket
	BucketName string `pulumi:"bucketName"`
	// The ARN of the KMS key
	KmsKeyArn *string `pulumi:"kmsKeyArn"`
	// The key prefix of the S3 bucket
	ObjectKeyPrefix *string `pulumi:"objectKeyPrefix"`
	// The position of the action in the receipt rule
	Position int `pulumi:"position"`
	// The ARN of an SNS topic to notify
	TopicArn *string `pulumi:"topicArn"`
}

type ReceiptRuleS3ActionArgs 

type ReceiptRuleS3ActionArgs struct {
	// The name of the S3 bucket
	BucketName pulumi.StringInput `pulumi:"bucketName"`
	// The ARN of the KMS key
	KmsKeyArn pulumi.StringPtrInput `pulumi:"kmsKeyArn"`
	// The key prefix of the S3 bucket
	ObjectKeyPrefix pulumi.StringPtrInput `pulumi:"objectKeyPrefix"`
	// The position of the action in the receipt rule
	Position pulumi.IntInput `pulumi:"position"`
	// The ARN of an SNS topic to notify
	TopicArn pulumi.StringPtrInput `pulumi:"topicArn"`
}

func (ReceiptRuleS3ActionArgs) ElementType 

func (ReceiptRuleS3ActionArgs) ElementType() reflect.Type

func (ReceiptRuleS3ActionArgs) ToReceiptRuleS3ActionOutput 

func (i ReceiptRuleS3ActionArgs) ToReceiptRuleS3ActionOutput() ReceiptRuleS3ActionOutput

func (ReceiptRuleS3ActionArgs) ToReceiptRuleS3ActionOutputWithContext 

func (i ReceiptRuleS3ActionArgs) ToReceiptRuleS3ActionOutputWithContext(ctx context.Context) ReceiptRuleS3ActionOutput

type ReceiptRuleS3ActionArray 

type ReceiptRuleS3ActionArray []ReceiptRuleS3ActionInput

func (ReceiptRuleS3ActionArray) ElementType 

func (ReceiptRuleS3ActionArray) ElementType() reflect.Type

func (ReceiptRuleS3ActionArray) ToReceiptRuleS3ActionArrayOutput 

func (i ReceiptRuleS3ActionArray) ToReceiptRuleS3ActionArrayOutput() ReceiptRuleS3ActionArrayOutput

func (ReceiptRuleS3ActionArray) ToReceiptRuleS3ActionArrayOutputWithContext 

func (i ReceiptRuleS3ActionArray) ToReceiptRuleS3ActionArrayOutputWithContext(ctx context.Context) ReceiptRuleS3ActionArrayOutput

type ReceiptRuleS3ActionArrayInput 

type ReceiptRuleS3ActionArrayInput interface {
	pulumi.Input

	ToReceiptRuleS3ActionArrayOutput() ReceiptRuleS3ActionArrayOutput
	ToReceiptRuleS3ActionArrayOutputWithContext(context.Context) ReceiptRuleS3ActionArrayOutput
}

ReceiptRuleS3ActionArrayInput is an input type that accepts ReceiptRuleS3ActionArray and ReceiptRuleS3ActionArrayOutput values. You can construct a concrete instance of `ReceiptRuleS3ActionArrayInput` via: 

ReceiptRuleS3ActionArray{ ReceiptRuleS3ActionArgs{...} }

type ReceiptRuleS3ActionArrayOutput 

type ReceiptRuleS3ActionArrayOutput struct{ *pulumi.OutputState }

func (ReceiptRuleS3ActionArrayOutput) ElementType 

func (ReceiptRuleS3ActionArrayOutput) ElementType() reflect.Type

func (ReceiptRuleS3ActionArrayOutput) Index 

func (o ReceiptRuleS3ActionArrayOutput) Index(i pulumi.IntInput) ReceiptRuleS3ActionOutput

func (ReceiptRuleS3ActionArrayOutput) ToReceiptRuleS3ActionArrayOutput 

func (o ReceiptRuleS3ActionArrayOutput) ToReceiptRuleS3ActionArrayOutput() ReceiptRuleS3ActionArrayOutput

func (ReceiptRuleS3ActionArrayOutput) ToReceiptRuleS3ActionArrayOutputWithContext 

func (o ReceiptRuleS3ActionArrayOutput) ToReceiptRuleS3ActionArrayOutputWithContext(ctx context.Context) ReceiptRuleS3ActionArrayOutput

type ReceiptRuleS3ActionInput 

type ReceiptRuleS3ActionInput interface {
	pulumi.Input

	ToReceiptRuleS3ActionOutput() ReceiptRuleS3ActionOutput
	ToReceiptRuleS3ActionOutputWithContext(context.Context) ReceiptRuleS3ActionOutput
}

ReceiptRuleS3ActionInput is an input type that accepts ReceiptRuleS3ActionArgs and ReceiptRuleS3ActionOutput values. You can construct a concrete instance of `ReceiptRuleS3ActionInput` via: 

ReceiptRuleS3ActionArgs{...}

type ReceiptRuleS3ActionOutput 

type ReceiptRuleS3ActionOutput struct{ *pulumi.OutputState }

func (ReceiptRuleS3ActionOutput) BucketName 

func (o ReceiptRuleS3ActionOutput) BucketName() pulumi.StringOutput

The name of the S3 bucket

func (ReceiptRuleS3ActionOutput) ElementType 

func (ReceiptRuleS3ActionOutput) ElementType() reflect.Type

func (ReceiptRuleS3ActionOutput) KmsKeyArn 

func (o ReceiptRuleS3ActionOutput) KmsKeyArn() pulumi.StringPtrOutput

The ARN of the KMS key

func (ReceiptRuleS3ActionOutput) ObjectKeyPrefix 

func (o ReceiptRuleS3ActionOutput) ObjectKeyPrefix() pulumi.StringPtrOutput

The key prefix of the S3 bucket

func (ReceiptRuleS3ActionOutput) Position 

func (o ReceiptRuleS3ActionOutput) Position() pulumi.IntOutput

The position of the action in the receipt rule

func (ReceiptRuleS3ActionOutput) ToReceiptRuleS3ActionOutput 

func (o ReceiptRuleS3ActionOutput) ToReceiptRuleS3ActionOutput() ReceiptRuleS3ActionOutput

func (ReceiptRuleS3ActionOutput) ToReceiptRuleS3ActionOutputWithContext 

func (o ReceiptRuleS3ActionOutput) ToReceiptRuleS3ActionOutputWithContext(ctx context.Context) ReceiptRuleS3ActionOutput

func (ReceiptRuleS3ActionOutput) TopicArn 

func (o ReceiptRuleS3ActionOutput) TopicArn() pulumi.StringPtrOutput

The ARN of an SNS topic to notify

type ReceiptRuleSet 

type ReceiptRuleSet struct {
	pulumi.CustomResourceState

	// SES receipt rule set ARN.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// Name of the rule set.
	RuleSetName pulumi.StringOutput `pulumi:"ruleSetName"`
}

Provides an SES receipt rule set resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ses.NewReceiptRuleSet(ctx, "main", &ses.ReceiptRuleSetArgs{
			RuleSetName: pulumi.String("primary-rules"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

SES receipt rule sets can be imported using the rule set name.

```sh 

$ pulumi import aws:ses/receiptRuleSet:ReceiptRuleSet my_rule_set my_rule_set_name

```

func GetReceiptRuleSet 

func GetReceiptRuleSet(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ReceiptRuleSetState, opts ...pulumi.ResourceOption) (*ReceiptRuleSet, error)

GetReceiptRuleSet gets an existing ReceiptRuleSet 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 NewReceiptRuleSet 

func NewReceiptRuleSet(ctx *pulumi.Context,
	name string, args *ReceiptRuleSetArgs, opts ...pulumi.ResourceOption) (*ReceiptRuleSet, error)

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

func (*ReceiptRuleSet) ElementType 

func (*ReceiptRuleSet) ElementType() reflect.Type

func (*ReceiptRuleSet) ToReceiptRuleSetOutput 

func (i *ReceiptRuleSet) ToReceiptRuleSetOutput() ReceiptRuleSetOutput

func (*ReceiptRuleSet) ToReceiptRuleSetOutputWithContext 

func (i *ReceiptRuleSet) ToReceiptRuleSetOutputWithContext(ctx context.Context) ReceiptRuleSetOutput

type ReceiptRuleSetArgs 

type ReceiptRuleSetArgs struct {
	// Name of the rule set.
	RuleSetName pulumi.StringInput
}

The set of arguments for constructing a ReceiptRuleSet resource.

func (ReceiptRuleSetArgs) ElementType 

func (ReceiptRuleSetArgs) ElementType() reflect.Type

type ReceiptRuleSetArray 

type ReceiptRuleSetArray []ReceiptRuleSetInput

func (ReceiptRuleSetArray) ElementType 

func (ReceiptRuleSetArray) ElementType() reflect.Type

func (ReceiptRuleSetArray) ToReceiptRuleSetArrayOutput 

func (i ReceiptRuleSetArray) ToReceiptRuleSetArrayOutput() ReceiptRuleSetArrayOutput

func (ReceiptRuleSetArray) ToReceiptRuleSetArrayOutputWithContext 

func (i ReceiptRuleSetArray) ToReceiptRuleSetArrayOutputWithContext(ctx context.Context) ReceiptRuleSetArrayOutput

type ReceiptRuleSetArrayInput 

type ReceiptRuleSetArrayInput interface {
	pulumi.Input

	ToReceiptRuleSetArrayOutput() ReceiptRuleSetArrayOutput
	ToReceiptRuleSetArrayOutputWithContext(context.Context) ReceiptRuleSetArrayOutput
}

ReceiptRuleSetArrayInput is an input type that accepts ReceiptRuleSetArray and ReceiptRuleSetArrayOutput values. You can construct a concrete instance of `ReceiptRuleSetArrayInput` via: 

ReceiptRuleSetArray{ ReceiptRuleSetArgs{...} }

type ReceiptRuleSetArrayOutput 

type ReceiptRuleSetArrayOutput struct{ *pulumi.OutputState }

func (ReceiptRuleSetArrayOutput) ElementType 

func (ReceiptRuleSetArrayOutput) ElementType() reflect.Type

func (ReceiptRuleSetArrayOutput) Index 

func (o ReceiptRuleSetArrayOutput) Index(i pulumi.IntInput) ReceiptRuleSetOutput

func (ReceiptRuleSetArrayOutput) ToReceiptRuleSetArrayOutput 

func (o ReceiptRuleSetArrayOutput) ToReceiptRuleSetArrayOutput() ReceiptRuleSetArrayOutput

func (ReceiptRuleSetArrayOutput) ToReceiptRuleSetArrayOutputWithContext 

func (o ReceiptRuleSetArrayOutput) ToReceiptRuleSetArrayOutputWithContext(ctx context.Context) ReceiptRuleSetArrayOutput

type ReceiptRuleSetInput 

type ReceiptRuleSetInput interface {
	pulumi.Input

	ToReceiptRuleSetOutput() ReceiptRuleSetOutput
	ToReceiptRuleSetOutputWithContext(ctx context.Context) ReceiptRuleSetOutput
}

type ReceiptRuleSetMap 

type ReceiptRuleSetMap map[string]ReceiptRuleSetInput

func (ReceiptRuleSetMap) ElementType 

func (ReceiptRuleSetMap) ElementType() reflect.Type

func (ReceiptRuleSetMap) ToReceiptRuleSetMapOutput 

func (i ReceiptRuleSetMap) ToReceiptRuleSetMapOutput() ReceiptRuleSetMapOutput

func (ReceiptRuleSetMap) ToReceiptRuleSetMapOutputWithContext 

func (i ReceiptRuleSetMap) ToReceiptRuleSetMapOutputWithContext(ctx context.Context) ReceiptRuleSetMapOutput

type ReceiptRuleSetMapInput 

type ReceiptRuleSetMapInput interface {
	pulumi.Input

	ToReceiptRuleSetMapOutput() ReceiptRuleSetMapOutput
	ToReceiptRuleSetMapOutputWithContext(context.Context) ReceiptRuleSetMapOutput
}

ReceiptRuleSetMapInput is an input type that accepts ReceiptRuleSetMap and ReceiptRuleSetMapOutput values. You can construct a concrete instance of `ReceiptRuleSetMapInput` via: 

ReceiptRuleSetMap{ "key": ReceiptRuleSetArgs{...} }

type ReceiptRuleSetMapOutput 

type ReceiptRuleSetMapOutput struct{ *pulumi.OutputState }

func (ReceiptRuleSetMapOutput) ElementType 

func (ReceiptRuleSetMapOutput) ElementType() reflect.Type

func (ReceiptRuleSetMapOutput) MapIndex 

func (o ReceiptRuleSetMapOutput) MapIndex(k pulumi.StringInput) ReceiptRuleSetOutput

func (ReceiptRuleSetMapOutput) ToReceiptRuleSetMapOutput 

func (o ReceiptRuleSetMapOutput) ToReceiptRuleSetMapOutput() ReceiptRuleSetMapOutput

func (ReceiptRuleSetMapOutput) ToReceiptRuleSetMapOutputWithContext 

func (o ReceiptRuleSetMapOutput) ToReceiptRuleSetMapOutputWithContext(ctx context.Context) ReceiptRuleSetMapOutput

type ReceiptRuleSetOutput 

type ReceiptRuleSetOutput struct{ *pulumi.OutputState }

func (ReceiptRuleSetOutput) Arn 

func (o ReceiptRuleSetOutput) Arn() pulumi.StringOutput

SES receipt rule set ARN.

func (ReceiptRuleSetOutput) ElementType 

func (ReceiptRuleSetOutput) ElementType() reflect.Type

func (ReceiptRuleSetOutput) RuleSetName 

func (o ReceiptRuleSetOutput) RuleSetName() pulumi.StringOutput

Name of the rule set.

func (ReceiptRuleSetOutput) ToReceiptRuleSetOutput 

func (o ReceiptRuleSetOutput) ToReceiptRuleSetOutput() ReceiptRuleSetOutput

func (ReceiptRuleSetOutput) ToReceiptRuleSetOutputWithContext 

func (o ReceiptRuleSetOutput) ToReceiptRuleSetOutputWithContext(ctx context.Context) ReceiptRuleSetOutput

type ReceiptRuleSetState 

type ReceiptRuleSetState struct {
	// SES receipt rule set ARN.
	Arn pulumi.StringPtrInput
	// Name of the rule set.
	RuleSetName pulumi.StringPtrInput
}

func (ReceiptRuleSetState) ElementType 

func (ReceiptRuleSetState) ElementType() reflect.Type

type ReceiptRuleSnsAction 

type ReceiptRuleSnsAction struct {
	// The encoding to use for the email within the Amazon SNS notification. Default value is `UTF-8`.
	Encoding *string `pulumi:"encoding"`
	// The position of the action in the receipt rule
	Position int `pulumi:"position"`
	// The ARN of an SNS topic to notify
	TopicArn string `pulumi:"topicArn"`
}

type ReceiptRuleSnsActionArgs 

type ReceiptRuleSnsActionArgs struct {
	// The encoding to use for the email within the Amazon SNS notification. Default value is `UTF-8`.
	Encoding pulumi.StringPtrInput `pulumi:"encoding"`
	// The position of the action in the receipt rule
	Position pulumi.IntInput `pulumi:"position"`
	// The ARN of an SNS topic to notify
	TopicArn pulumi.StringInput `pulumi:"topicArn"`
}

func (ReceiptRuleSnsActionArgs) ElementType 

func (ReceiptRuleSnsActionArgs) ElementType() reflect.Type

func (ReceiptRuleSnsActionArgs) ToReceiptRuleSnsActionOutput 

func (i ReceiptRuleSnsActionArgs) ToReceiptRuleSnsActionOutput() ReceiptRuleSnsActionOutput

func (ReceiptRuleSnsActionArgs) ToReceiptRuleSnsActionOutputWithContext 

func (i ReceiptRuleSnsActionArgs) ToReceiptRuleSnsActionOutputWithContext(ctx context.Context) ReceiptRuleSnsActionOutput

type ReceiptRuleSnsActionArray 

type ReceiptRuleSnsActionArray []ReceiptRuleSnsActionInput

func (ReceiptRuleSnsActionArray) ElementType 

func (ReceiptRuleSnsActionArray) ElementType() reflect.Type

func (ReceiptRuleSnsActionArray) ToReceiptRuleSnsActionArrayOutput 

func (i ReceiptRuleSnsActionArray) ToReceiptRuleSnsActionArrayOutput() ReceiptRuleSnsActionArrayOutput

func (ReceiptRuleSnsActionArray) ToReceiptRuleSnsActionArrayOutputWithContext 

func (i ReceiptRuleSnsActionArray) ToReceiptRuleSnsActionArrayOutputWithContext(ctx context.Context) ReceiptRuleSnsActionArrayOutput

type ReceiptRuleSnsActionArrayInput 

type ReceiptRuleSnsActionArrayInput interface {
	pulumi.Input

	ToReceiptRuleSnsActionArrayOutput() ReceiptRuleSnsActionArrayOutput
	ToReceiptRuleSnsActionArrayOutputWithContext(context.Context) ReceiptRuleSnsActionArrayOutput
}

ReceiptRuleSnsActionArrayInput is an input type that accepts ReceiptRuleSnsActionArray and ReceiptRuleSnsActionArrayOutput values. You can construct a concrete instance of `ReceiptRuleSnsActionArrayInput` via: 

ReceiptRuleSnsActionArray{ ReceiptRuleSnsActionArgs{...} }

type ReceiptRuleSnsActionArrayOutput 

type ReceiptRuleSnsActionArrayOutput struct{ *pulumi.OutputState }

func (ReceiptRuleSnsActionArrayOutput) ElementType 

func (ReceiptRuleSnsActionArrayOutput) ElementType() reflect.Type

func (ReceiptRuleSnsActionArrayOutput) Index 

func (o ReceiptRuleSnsActionArrayOutput) Index(i pulumi.IntInput) ReceiptRuleSnsActionOutput

func (ReceiptRuleSnsActionArrayOutput) ToReceiptRuleSnsActionArrayOutput 

func (o ReceiptRuleSnsActionArrayOutput) ToReceiptRuleSnsActionArrayOutput() ReceiptRuleSnsActionArrayOutput

func (ReceiptRuleSnsActionArrayOutput) ToReceiptRuleSnsActionArrayOutputWithContext 

func (o ReceiptRuleSnsActionArrayOutput) ToReceiptRuleSnsActionArrayOutputWithContext(ctx context.Context) ReceiptRuleSnsActionArrayOutput

type ReceiptRuleSnsActionInput 

type ReceiptRuleSnsActionInput interface {
	pulumi.Input

	ToReceiptRuleSnsActionOutput() ReceiptRuleSnsActionOutput
	ToReceiptRuleSnsActionOutputWithContext(context.Context) ReceiptRuleSnsActionOutput
}

ReceiptRuleSnsActionInput is an input type that accepts ReceiptRuleSnsActionArgs and ReceiptRuleSnsActionOutput values. You can construct a concrete instance of `ReceiptRuleSnsActionInput` via: 

ReceiptRuleSnsActionArgs{...}

type ReceiptRuleSnsActionOutput 

type ReceiptRuleSnsActionOutput struct{ *pulumi.OutputState }

func (ReceiptRuleSnsActionOutput) ElementType 

func (ReceiptRuleSnsActionOutput) ElementType() reflect.Type

func (ReceiptRuleSnsActionOutput) Encoding 

func (o ReceiptRuleSnsActionOutput) Encoding() pulumi.StringPtrOutput

The encoding to use for the email within the Amazon SNS notification. Default value is `UTF-8`.

func (ReceiptRuleSnsActionOutput) Position 

func (o ReceiptRuleSnsActionOutput) Position() pulumi.IntOutput

The position of the action in the receipt rule

func (ReceiptRuleSnsActionOutput) ToReceiptRuleSnsActionOutput 

func (o ReceiptRuleSnsActionOutput) ToReceiptRuleSnsActionOutput() ReceiptRuleSnsActionOutput

func (ReceiptRuleSnsActionOutput) ToReceiptRuleSnsActionOutputWithContext 

func (o ReceiptRuleSnsActionOutput) ToReceiptRuleSnsActionOutputWithContext(ctx context.Context) ReceiptRuleSnsActionOutput

func (ReceiptRuleSnsActionOutput) TopicArn 

func (o ReceiptRuleSnsActionOutput) TopicArn() pulumi.StringOutput

The ARN of an SNS topic to notify

type ReceiptRuleState 

type ReceiptRuleState struct {
	// A list of Add Header Action blocks. Documented below.
	AddHeaderActions ReceiptRuleAddHeaderActionArrayInput
	// The name of the rule to place this rule after
	After pulumi.StringPtrInput
	// The SES receipt rule ARN.
	Arn pulumi.StringPtrInput
	// A list of Bounce Action blocks. Documented below.
	BounceActions ReceiptRuleBounceActionArrayInput
	// If true, the rule will be enabled
	Enabled pulumi.BoolPtrInput
	// A list of Lambda Action blocks. Documented below.
	LambdaActions ReceiptRuleLambdaActionArrayInput
	// The name of the rule
	Name pulumi.StringPtrInput
	// A list of email addresses
	Recipients pulumi.StringArrayInput
	// The name of the rule set
	RuleSetName pulumi.StringPtrInput
	// A list of S3 Action blocks. Documented below.
	S3Actions ReceiptRuleS3ActionArrayInput
	// If true, incoming emails will be scanned for spam and viruses
	ScanEnabled pulumi.BoolPtrInput
	// A list of SNS Action blocks. Documented below.
	SnsActions ReceiptRuleSnsActionArrayInput
	// A list of Stop Action blocks. Documented below.
	StopActions ReceiptRuleStopActionArrayInput
	// `Require` or `Optional`
	TlsPolicy pulumi.StringPtrInput
	// A list of WorkMail Action blocks. Documented below.
	WorkmailActions ReceiptRuleWorkmailActionArrayInput
}

func (ReceiptRuleState) ElementType 

func (ReceiptRuleState) ElementType() reflect.Type

type ReceiptRuleStopAction 

type ReceiptRuleStopAction struct {
	// The position of the action in the receipt rule
	Position int `pulumi:"position"`
	// The scope to apply. The only acceptable value is `RuleSet`.
	Scope string `pulumi:"scope"`
	// The ARN of an SNS topic to notify
	TopicArn *string `pulumi:"topicArn"`
}

type ReceiptRuleStopActionArgs 

type ReceiptRuleStopActionArgs struct {
	// The position of the action in the receipt rule
	Position pulumi.IntInput `pulumi:"position"`
	// The scope to apply. The only acceptable value is `RuleSet`.
	Scope pulumi.StringInput `pulumi:"scope"`
	// The ARN of an SNS topic to notify
	TopicArn pulumi.StringPtrInput `pulumi:"topicArn"`
}

func (ReceiptRuleStopActionArgs) ElementType 

func (ReceiptRuleStopActionArgs) ElementType() reflect.Type

func (ReceiptRuleStopActionArgs) ToReceiptRuleStopActionOutput 

func (i ReceiptRuleStopActionArgs) ToReceiptRuleStopActionOutput() ReceiptRuleStopActionOutput

func (ReceiptRuleStopActionArgs) ToReceiptRuleStopActionOutputWithContext 

func (i ReceiptRuleStopActionArgs) ToReceiptRuleStopActionOutputWithContext(ctx context.Context) ReceiptRuleStopActionOutput

type ReceiptRuleStopActionArray 

type ReceiptRuleStopActionArray []ReceiptRuleStopActionInput

func (ReceiptRuleStopActionArray) ElementType 

func (ReceiptRuleStopActionArray) ElementType() reflect.Type

func (ReceiptRuleStopActionArray) ToReceiptRuleStopActionArrayOutput 

func (i ReceiptRuleStopActionArray) ToReceiptRuleStopActionArrayOutput() ReceiptRuleStopActionArrayOutput

func (ReceiptRuleStopActionArray) ToReceiptRuleStopActionArrayOutputWithContext 

func (i ReceiptRuleStopActionArray) ToReceiptRuleStopActionArrayOutputWithContext(ctx context.Context) ReceiptRuleStopActionArrayOutput

type ReceiptRuleStopActionArrayInput 

type ReceiptRuleStopActionArrayInput interface {
	pulumi.Input

	ToReceiptRuleStopActionArrayOutput() ReceiptRuleStopActionArrayOutput
	ToReceiptRuleStopActionArrayOutputWithContext(context.Context) ReceiptRuleStopActionArrayOutput
}

ReceiptRuleStopActionArrayInput is an input type that accepts ReceiptRuleStopActionArray and ReceiptRuleStopActionArrayOutput values. You can construct a concrete instance of `ReceiptRuleStopActionArrayInput` via: 

ReceiptRuleStopActionArray{ ReceiptRuleStopActionArgs{...} }

type ReceiptRuleStopActionArrayOutput 

type ReceiptRuleStopActionArrayOutput struct{ *pulumi.OutputState }

func (ReceiptRuleStopActionArrayOutput) ElementType 

func (ReceiptRuleStopActionArrayOutput) ElementType() reflect.Type

func (ReceiptRuleStopActionArrayOutput) Index 

func (o ReceiptRuleStopActionArrayOutput) Index(i pulumi.IntInput) ReceiptRuleStopActionOutput

func (ReceiptRuleStopActionArrayOutput) ToReceiptRuleStopActionArrayOutput 

func (o ReceiptRuleStopActionArrayOutput) ToReceiptRuleStopActionArrayOutput() ReceiptRuleStopActionArrayOutput

func (ReceiptRuleStopActionArrayOutput) ToReceiptRuleStopActionArrayOutputWithContext 

func (o ReceiptRuleStopActionArrayOutput) ToReceiptRuleStopActionArrayOutputWithContext(ctx context.Context) ReceiptRuleStopActionArrayOutput

type ReceiptRuleStopActionInput 

type ReceiptRuleStopActionInput interface {
	pulumi.Input

	ToReceiptRuleStopActionOutput() ReceiptRuleStopActionOutput
	ToReceiptRuleStopActionOutputWithContext(context.Context) ReceiptRuleStopActionOutput
}

ReceiptRuleStopActionInput is an input type that accepts ReceiptRuleStopActionArgs and ReceiptRuleStopActionOutput values. You can construct a concrete instance of `ReceiptRuleStopActionInput` via: 

ReceiptRuleStopActionArgs{...}

type ReceiptRuleStopActionOutput 

type ReceiptRuleStopActionOutput struct{ *pulumi.OutputState }

func (ReceiptRuleStopActionOutput) ElementType 

func (ReceiptRuleStopActionOutput) ElementType() reflect.Type

func (ReceiptRuleStopActionOutput) Position 

func (o ReceiptRuleStopActionOutput) Position() pulumi.IntOutput

The position of the action in the receipt rule

func (ReceiptRuleStopActionOutput) Scope 

func (o ReceiptRuleStopActionOutput) Scope() pulumi.StringOutput

The scope to apply. The only acceptable value is `RuleSet`.

func (ReceiptRuleStopActionOutput) ToReceiptRuleStopActionOutput 

func (o ReceiptRuleStopActionOutput) ToReceiptRuleStopActionOutput() ReceiptRuleStopActionOutput

func (ReceiptRuleStopActionOutput) ToReceiptRuleStopActionOutputWithContext 

func (o ReceiptRuleStopActionOutput) ToReceiptRuleStopActionOutputWithContext(ctx context.Context) ReceiptRuleStopActionOutput

func (ReceiptRuleStopActionOutput) TopicArn 

func (o ReceiptRuleStopActionOutput) TopicArn() pulumi.StringPtrOutput

The ARN of an SNS topic to notify

type ReceiptRuleWorkmailAction 

type ReceiptRuleWorkmailAction struct {
	// The ARN of the WorkMail organization
	OrganizationArn string `pulumi:"organizationArn"`
	// The position of the action in the receipt rule
	Position int `pulumi:"position"`
	// The ARN of an SNS topic to notify
	TopicArn *string `pulumi:"topicArn"`
}

type ReceiptRuleWorkmailActionArgs 

type ReceiptRuleWorkmailActionArgs struct {
	// The ARN of the WorkMail organization
	OrganizationArn pulumi.StringInput `pulumi:"organizationArn"`
	// The position of the action in the receipt rule
	Position pulumi.IntInput `pulumi:"position"`
	// The ARN of an SNS topic to notify
	TopicArn pulumi.StringPtrInput `pulumi:"topicArn"`
}

func (ReceiptRuleWorkmailActionArgs) ElementType 

func (ReceiptRuleWorkmailActionArgs) ElementType() reflect.Type

func (ReceiptRuleWorkmailActionArgs) ToReceiptRuleWorkmailActionOutput 

func (i ReceiptRuleWorkmailActionArgs) ToReceiptRuleWorkmailActionOutput() ReceiptRuleWorkmailActionOutput

func (ReceiptRuleWorkmailActionArgs) ToReceiptRuleWorkmailActionOutputWithContext 

func (i ReceiptRuleWorkmailActionArgs) ToReceiptRuleWorkmailActionOutputWithContext(ctx context.Context) ReceiptRuleWorkmailActionOutput

type ReceiptRuleWorkmailActionArray 

type ReceiptRuleWorkmailActionArray []ReceiptRuleWorkmailActionInput

func (ReceiptRuleWorkmailActionArray) ElementType 

func (ReceiptRuleWorkmailActionArray) ElementType() reflect.Type

func (ReceiptRuleWorkmailActionArray) ToReceiptRuleWorkmailActionArrayOutput 

func (i ReceiptRuleWorkmailActionArray) ToReceiptRuleWorkmailActionArrayOutput() ReceiptRuleWorkmailActionArrayOutput

func (ReceiptRuleWorkmailActionArray) ToReceiptRuleWorkmailActionArrayOutputWithContext 

func (i ReceiptRuleWorkmailActionArray) ToReceiptRuleWorkmailActionArrayOutputWithContext(ctx context.Context) ReceiptRuleWorkmailActionArrayOutput

type ReceiptRuleWorkmailActionArrayInput 

type ReceiptRuleWorkmailActionArrayInput interface {
	pulumi.Input

	ToReceiptRuleWorkmailActionArrayOutput() ReceiptRuleWorkmailActionArrayOutput
	ToReceiptRuleWorkmailActionArrayOutputWithContext(context.Context) ReceiptRuleWorkmailActionArrayOutput
}

ReceiptRuleWorkmailActionArrayInput is an input type that accepts ReceiptRuleWorkmailActionArray and ReceiptRuleWorkmailActionArrayOutput values. You can construct a concrete instance of `ReceiptRuleWorkmailActionArrayInput` via: 

ReceiptRuleWorkmailActionArray{ ReceiptRuleWorkmailActionArgs{...} }

type ReceiptRuleWorkmailActionArrayOutput 

type ReceiptRuleWorkmailActionArrayOutput struct{ *pulumi.OutputState }

func (ReceiptRuleWorkmailActionArrayOutput) ElementType 

func (ReceiptRuleWorkmailActionArrayOutput) ElementType() reflect.Type

func (ReceiptRuleWorkmailActionArrayOutput) Index 

func (o ReceiptRuleWorkmailActionArrayOutput) Index(i pulumi.IntInput) ReceiptRuleWorkmailActionOutput

func (ReceiptRuleWorkmailActionArrayOutput) ToReceiptRuleWorkmailActionArrayOutput 

func (o ReceiptRuleWorkmailActionArrayOutput) ToReceiptRuleWorkmailActionArrayOutput() ReceiptRuleWorkmailActionArrayOutput

func (ReceiptRuleWorkmailActionArrayOutput) ToReceiptRuleWorkmailActionArrayOutputWithContext 

func (o ReceiptRuleWorkmailActionArrayOutput) ToReceiptRuleWorkmailActionArrayOutputWithContext(ctx context.Context) ReceiptRuleWorkmailActionArrayOutput

type ReceiptRuleWorkmailActionInput 

type ReceiptRuleWorkmailActionInput interface {
	pulumi.Input

	ToReceiptRuleWorkmailActionOutput() ReceiptRuleWorkmailActionOutput
	ToReceiptRuleWorkmailActionOutputWithContext(context.Context) ReceiptRuleWorkmailActionOutput
}

ReceiptRuleWorkmailActionInput is an input type that accepts ReceiptRuleWorkmailActionArgs and ReceiptRuleWorkmailActionOutput values. You can construct a concrete instance of `ReceiptRuleWorkmailActionInput` via: 

ReceiptRuleWorkmailActionArgs{...}

type ReceiptRuleWorkmailActionOutput 

type ReceiptRuleWorkmailActionOutput struct{ *pulumi.OutputState }

func (ReceiptRuleWorkmailActionOutput) ElementType 

func (ReceiptRuleWorkmailActionOutput) ElementType() reflect.Type

func (ReceiptRuleWorkmailActionOutput) OrganizationArn 

func (o ReceiptRuleWorkmailActionOutput) OrganizationArn() pulumi.StringOutput

The ARN of the WorkMail organization

func (ReceiptRuleWorkmailActionOutput) Position 

func (o ReceiptRuleWorkmailActionOutput) Position() pulumi.IntOutput

The position of the action in the receipt rule

func (ReceiptRuleWorkmailActionOutput) ToReceiptRuleWorkmailActionOutput 

func (o ReceiptRuleWorkmailActionOutput) ToReceiptRuleWorkmailActionOutput() ReceiptRuleWorkmailActionOutput

func (ReceiptRuleWorkmailActionOutput) ToReceiptRuleWorkmailActionOutputWithContext 

func (o ReceiptRuleWorkmailActionOutput) ToReceiptRuleWorkmailActionOutputWithContext(ctx context.Context) ReceiptRuleWorkmailActionOutput

func (ReceiptRuleWorkmailActionOutput) TopicArn 

func (o ReceiptRuleWorkmailActionOutput) TopicArn() pulumi.StringPtrOutput

The ARN of an SNS topic to notify

type Template 

type Template struct {
	pulumi.CustomResourceState

	// The ARN of the SES template
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The HTML body of the email. Must be less than 500KB in size, including both the text and HTML parts.
	Html pulumi.StringPtrOutput `pulumi:"html"`
	// The name of the template. Cannot exceed 64 characters. You will refer to this name when you send email.
	Name pulumi.StringOutput `pulumi:"name"`
	// The subject line of the email.
	Subject pulumi.StringPtrOutput `pulumi:"subject"`
	// The email body that will be visible to recipients whose email clients do not display HTML. Must be less than 500KB in size, including both the text and HTML parts.
	Text pulumi.StringPtrOutput `pulumi:"text"`
}

Provides a resource to create a SES template.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ses.NewTemplate(ctx, "myTemplate", &ses.TemplateArgs{
			Html:    pulumi.String("<h1>Hello {{name}},</h1><p>Your favorite animal is {{favoriteanimal}}.</p>"),
			Subject: pulumi.String("Greetings, {{name}}!"),
			Text:    pulumi.String("Hello {{name}},\nYour favorite animal is {{favoriteanimal}}.\n"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

SES templates can be imported using the template name, e.g.,

```sh 

$ pulumi import aws:ses/template:Template MyTemplate MyTemplate

```

func GetTemplate 

func GetTemplate(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *TemplateState, opts ...pulumi.ResourceOption) (*Template, error)

GetTemplate gets an existing Template 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 NewTemplate 

func NewTemplate(ctx *pulumi.Context,
	name string, args *TemplateArgs, opts ...pulumi.ResourceOption) (*Template, error)

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

func (*Template) ElementType 

func (*Template) ElementType() reflect.Type

func (*Template) ToTemplateOutput 

func (i *Template) ToTemplateOutput() TemplateOutput

func (*Template) ToTemplateOutputWithContext 

func (i *Template) ToTemplateOutputWithContext(ctx context.Context) TemplateOutput

type TemplateArgs 

type TemplateArgs struct {
	// The HTML body of the email. Must be less than 500KB in size, including both the text and HTML parts.
	Html pulumi.StringPtrInput
	// The name of the template. Cannot exceed 64 characters. You will refer to this name when you send email.
	Name pulumi.StringPtrInput
	// The subject line of the email.
	Subject pulumi.StringPtrInput
	// The email body that will be visible to recipients whose email clients do not display HTML. Must be less than 500KB in size, including both the text and HTML parts.
	Text pulumi.StringPtrInput
}

The set of arguments for constructing a Template resource.

func (TemplateArgs) ElementType 

func (TemplateArgs) ElementType() reflect.Type

type TemplateArray 

type TemplateArray []TemplateInput

func (TemplateArray) ElementType 

func (TemplateArray) ElementType() reflect.Type

func (TemplateArray) ToTemplateArrayOutput 

func (i TemplateArray) ToTemplateArrayOutput() TemplateArrayOutput

func (TemplateArray) ToTemplateArrayOutputWithContext 

func (i TemplateArray) ToTemplateArrayOutputWithContext(ctx context.Context) TemplateArrayOutput

type TemplateArrayInput 

type TemplateArrayInput interface {
	pulumi.Input

	ToTemplateArrayOutput() TemplateArrayOutput
	ToTemplateArrayOutputWithContext(context.Context) TemplateArrayOutput
}

TemplateArrayInput is an input type that accepts TemplateArray and TemplateArrayOutput values. You can construct a concrete instance of `TemplateArrayInput` via: 

TemplateArray{ TemplateArgs{...} }

type TemplateArrayOutput 

type TemplateArrayOutput struct{ *pulumi.OutputState }

func (TemplateArrayOutput) ElementType 

func (TemplateArrayOutput) ElementType() reflect.Type

func (TemplateArrayOutput) Index 

func (o TemplateArrayOutput) Index(i pulumi.IntInput) TemplateOutput

func (TemplateArrayOutput) ToTemplateArrayOutput 

func (o TemplateArrayOutput) ToTemplateArrayOutput() TemplateArrayOutput

func (TemplateArrayOutput) ToTemplateArrayOutputWithContext 

func (o TemplateArrayOutput) ToTemplateArrayOutputWithContext(ctx context.Context) TemplateArrayOutput

type TemplateInput 

type TemplateInput interface {
	pulumi.Input

	ToTemplateOutput() TemplateOutput
	ToTemplateOutputWithContext(ctx context.Context) TemplateOutput
}

type TemplateMap 

type TemplateMap map[string]TemplateInput

func (TemplateMap) ElementType 

func (TemplateMap) ElementType() reflect.Type

func (TemplateMap) ToTemplateMapOutput 

func (i TemplateMap) ToTemplateMapOutput() TemplateMapOutput

func (TemplateMap) ToTemplateMapOutputWithContext 

func (i TemplateMap) ToTemplateMapOutputWithContext(ctx context.Context) TemplateMapOutput

type TemplateMapInput 

type TemplateMapInput interface {
	pulumi.Input

	ToTemplateMapOutput() TemplateMapOutput
	ToTemplateMapOutputWithContext(context.Context) TemplateMapOutput
}

TemplateMapInput is an input type that accepts TemplateMap and TemplateMapOutput values. You can construct a concrete instance of `TemplateMapInput` via: 

TemplateMap{ "key": TemplateArgs{...} }

type TemplateMapOutput 

type TemplateMapOutput struct{ *pulumi.OutputState }

func (TemplateMapOutput) ElementType 

func (TemplateMapOutput) ElementType() reflect.Type

func (TemplateMapOutput) MapIndex 

func (o TemplateMapOutput) MapIndex(k pulumi.StringInput) TemplateOutput

func (TemplateMapOutput) ToTemplateMapOutput 

func (o TemplateMapOutput) ToTemplateMapOutput() TemplateMapOutput

func (TemplateMapOutput) ToTemplateMapOutputWithContext 

func (o TemplateMapOutput) ToTemplateMapOutputWithContext(ctx context.Context) TemplateMapOutput

type TemplateOutput 

type TemplateOutput struct{ *pulumi.OutputState }

func (TemplateOutput) Arn 

func (o TemplateOutput) Arn() pulumi.StringOutput

The ARN of the SES template

func (TemplateOutput) ElementType 

func (TemplateOutput) ElementType() reflect.Type

func (TemplateOutput) Html 

func (o TemplateOutput) Html() pulumi.StringPtrOutput

The HTML body of the email. Must be less than 500KB in size, including both the text and HTML parts.

func (TemplateOutput) Name 

func (o TemplateOutput) Name() pulumi.StringOutput

The name of the template. Cannot exceed 64 characters. You will refer to this name when you send email.

func (TemplateOutput) Subject 

func (o TemplateOutput) Subject() pulumi.StringPtrOutput

The subject line of the email.

func (TemplateOutput) Text 

func (o TemplateOutput) Text() pulumi.StringPtrOutput

The email body that will be visible to recipients whose email clients do not display HTML. Must be less than 500KB in size, including both the text and HTML parts.

func (TemplateOutput) ToTemplateOutput 

func (o TemplateOutput) ToTemplateOutput() TemplateOutput

func (TemplateOutput) ToTemplateOutputWithContext 

func (o TemplateOutput) ToTemplateOutputWithContext(ctx context.Context) TemplateOutput

type TemplateState 

type TemplateState struct {
	// The ARN of the SES template
	Arn pulumi.StringPtrInput
	// The HTML body of the email. Must be less than 500KB in size, including both the text and HTML parts.
	Html pulumi.StringPtrInput
	// The name of the template. Cannot exceed 64 characters. You will refer to this name when you send email.
	Name pulumi.StringPtrInput
	// The subject line of the email.
	Subject pulumi.StringPtrInput
	// The email body that will be visible to recipients whose email clients do not display HTML. Must be less than 500KB in size, including both the text and HTML parts.
	Text pulumi.StringPtrInput
}

func (TemplateState) ElementType 

func (TemplateState) ElementType() reflect.Type

Source Files

View all Source files

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.