ses

package
v2.13.1 Latest Latest
Warning

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

 Go to latest Published: Jul 22, 2020 License: Apache-2.0 Imports: 4 Imported by: 0

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 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/v2/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v2/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
	})
}

```

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.

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 ActiveReceiptRuleSetState 

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

func (ActiveReceiptRuleSetState) ElementType 

func (ActiveReceiptRuleSetState) ElementType() reflect.Type

type ConfgurationSet deprecated 

type ConfgurationSet struct {
	pulumi.CustomResourceState

	Name pulumi.StringOutput `pulumi:"name"`
}

Deprecated: aws.ses.ConfgurationSet has been deprecated in favor of aws.ses.ConfigurationSet

func GetConfgurationSet 

func GetConfgurationSet(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ConfgurationSetState, opts ...pulumi.ResourceOption) (*ConfgurationSet, error)

GetConfgurationSet gets an existing ConfgurationSet 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 NewConfgurationSet 

func NewConfgurationSet(ctx *pulumi.Context,
	name string, args *ConfgurationSetArgs, opts ...pulumi.ResourceOption) (*ConfgurationSet, error)

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

type ConfgurationSetArgs 

type ConfgurationSetArgs struct {
	Name pulumi.StringPtrInput
}

The set of arguments for constructing a ConfgurationSet resource.

func (ConfgurationSetArgs) ElementType 

func (ConfgurationSetArgs) ElementType() reflect.Type

type ConfgurationSetState 

type ConfgurationSetState struct {
	Name pulumi.StringPtrInput
}

func (ConfgurationSetState) ElementType 

func (ConfgurationSetState) ElementType() reflect.Type

type ConfigurationSet 

type ConfigurationSet struct {
	pulumi.CustomResourceState

	// The name of the configuration set
	Name pulumi.StringOutput `pulumi:"name"`
}

Provides an SES configuration set resource

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v2/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

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

```

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.

type ConfigurationSetArgs 

type ConfigurationSetArgs struct {
	// The name of the configuration set
	Name pulumi.StringPtrInput
}

The set of arguments for constructing a ConfigurationSet resource.

func (ConfigurationSetArgs) ElementType 

func (ConfigurationSetArgs) ElementType() reflect.Type

type ConfigurationSetState 

type ConfigurationSetState struct {
	// The name of the configuration set
	Name pulumi.StringPtrInput
}

func (ConfigurationSetState) ElementType 

func (ConfigurationSetState) ElementType() reflect.Type

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 `ses.DomainIdentity` resource.

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.

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 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 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/verify-domains.html).
	VerificationToken pulumi.StringOutput `pulumi:"verificationToken"`
}

Provides an SES domain identity resource

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v2/go/aws/route53"
"github.com/pulumi/pulumi-aws/sdk/v2/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v2/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{
			Name: pulumi.String("_amazonses.example.com"),
			Records: pulumi.StringArray{
				example.VerificationToken,
			},
			Ttl:    pulumi.Int(600),
			Type:   pulumi.String("TXT"),
			ZoneId: pulumi.String("ABCDEFGHIJ123"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

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.

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 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 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/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/v2/go/aws/route53"
"github.com/pulumi/pulumi-aws/sdk/v2/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v2/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{
			Name: example.ID().ApplyT(func(id string) (string, error) {
				return fmt.Sprintf("%v%v", "_amazonses.", id), nil
			}).(pulumi.StringOutput),
			Records: pulumi.StringArray{
				example.VerificationToken,
			},
			Ttl:    pulumi.Int(600),
			Type:   pulumi.String("TXT"),
			ZoneId: pulumi.String(aws_route53_zone.Example.Zone_id),
		})
		if err != nil {
			return err
		}
		_, err = ses.NewDomainIdentityVerification(ctx, "exampleVerification", &ses.DomainIdentityVerificationArgs{
			Domain: example.ID(),
		}, pulumi.DependsOn([]pulumi.Resource{
			"aws_route53_record.example_amazonses_verification_record",
		}))
		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.

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 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/v2/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v2/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
	})
}

```

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.

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 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

	// 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
	SnsDestination EventDestinationSnsDestinationPtrOutput `pulumi:"snsDestination"`
}

Provides an SES event destination

## Example Usage ### CloudWatch Destination

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v2/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

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

``` ### Kinesis Destination

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v2/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

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

``` ### SNS Destination

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v2/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

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

```

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.

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
	SnsDestination EventDestinationSnsDestinationPtrInput
}

The set of arguments for constructing a EventDestination resource.

func (EventDestinationArgs) ElementType 

func (EventDestinationArgs) ElementType() reflect.Type

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. It can be either `"messageTag"` or `"emailHeader"`
	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. It can be either `"messageTag"` or `"emailHeader"`
	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. It can be either `"messageTag"` or `"emailHeader"`

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 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 {
	// 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
	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/v2/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

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

```

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.

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 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/v2/go/aws/iam"
"github.com/pulumi/pulumi-aws/sdk/v2/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v2/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
		}
		_, err = ses.NewIdentityPolicy(ctx, "exampleIdentityPolicy", &ses.IdentityPolicyArgs{
			Identity: exampleDomainIdentity.Arn,
			Policy: examplePolicyDocument.ApplyT(func(examplePolicyDocument iam.GetPolicyDocumentResult) (string, error) {
				return examplePolicyDocument.Json, nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

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.

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 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 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 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)
	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/DeveloperGuide/mail-from-set.html) for more information.

## Example Usage

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v2/go/aws/route53"
"github.com/pulumi/pulumi-aws/sdk/v2/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v2/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("%v%v", "bounce.", domain), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		_, err = route53.NewRecord(ctx, "exampleSesDomainMailFromMx", &route53.RecordArgs{
			Name: exampleMailFrom.MailFromDomain,
			Records: pulumi.StringArray{
				pulumi.String("10 feedback-smtp.us-east-1.amazonses.com"),
			},
			Ttl:    pulumi.Int(600),
			Type:   pulumi.String("MX"),
			ZoneId: pulumi.String(aws_route53_zone.Example.Id),
		})
		if err != nil {
			return err
		}
		_, err = route53.NewRecord(ctx, "exampleSesDomainMailFromTxt", &route53.RecordArgs{
			Name: exampleMailFrom.MailFromDomain,
			Records: pulumi.StringArray{
				pulumi.String("v=spf1 include:amazonses.com -all"),
			},
			Ttl:    pulumi.Int(600),
			Type:   pulumi.String("TXT"),
			ZoneId: pulumi.String(aws_route53_zone.Example.Id),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

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.

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 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)
	MailFromDomain pulumi.StringInput
}

The set of arguments for constructing a MailFrom resource.

func (MailFromArgs) ElementType 

func (MailFromArgs) ElementType() reflect.Type

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 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)
	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/v2/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v2/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
	})
}

```

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.

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 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"`
	// A list of Bounce Action blocks. Documented below.
	BounceActions ReceiptRuleBounceActionArrayOutput `pulumi:"bounceActions"`
	// If true, the rule will be enabled
	Enabled pulumi.BoolOutput `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.BoolOutput `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/v2/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v2/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
	})
}

```

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.

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 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 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 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

	// The 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/v2/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v2/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
	})
}

```

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.

type ReceiptRuleSetArgs 

type ReceiptRuleSetArgs struct {
	// The 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 ReceiptRuleSetState 

type ReceiptRuleSetState struct {
	// The name of the rule set
	RuleSetName pulumi.StringPtrInput
}

func (ReceiptRuleSetState) ElementType 

func (ReceiptRuleSetState) ElementType() reflect.Type

type ReceiptRuleSnsAction 

type ReceiptRuleSnsAction struct {
	// 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 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) 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
	// 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
	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
	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

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 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 ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v2/go/aws/ses"
"github.com/pulumi/pulumi/sdk/v2/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(fmt.Sprintf("%v%v", "Hello {{name}},\n", "Your favorite animal is {{favoriteanimal}}.\n")),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

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.

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 TemplateState 

type TemplateState 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
}

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.