dlm

package
v6.10.0 Latest Latest
Warning

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

 Go to latest Published: Nov 21, 2023 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type LifecyclePolicy 

type LifecyclePolicy struct {
	pulumi.CustomResourceState

	// Amazon Resource Name (ARN) of the DLM Lifecycle Policy.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// A description for the DLM lifecycle policy.
	Description pulumi.StringOutput `pulumi:"description"`
	// The ARN of an IAM role that is able to be assumed by the DLM service.
	ExecutionRoleArn pulumi.StringOutput `pulumi:"executionRoleArn"`
	// See the `policyDetails` configuration block. Max of 1.
	PolicyDetails LifecyclePolicyPolicyDetailsOutput `pulumi:"policyDetails"`
	// Whether the lifecycle policy should be enabled or disabled. `ENABLED` or `DISABLED` are valid values. Defaults to `ENABLED`.
	State pulumi.StringPtrOutput `pulumi:"state"`
	// Key-value map of resource tags. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	//
	// Deprecated: Please use `tags` instead.
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
}

Provides a [Data Lifecycle Manager (DLM) lifecycle policy](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/snapshot-lifecycle.html) for managing snapshots.

## Example Usage ### Example Event Based Policy Usage

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		current, err := aws.GetCallerIdentity(ctx, nil, nil)
		if err != nil {
			return err
		}
		_, err = dlm.NewLifecyclePolicy(ctx, "exampleLifecyclePolicy", &dlm.LifecyclePolicyArgs{
			Description:      pulumi.String("tf-acc-basic"),
			ExecutionRoleArn: pulumi.Any(aws_iam_role.Example.Arn),
			PolicyDetails: &dlm.LifecyclePolicyPolicyDetailsArgs{
				PolicyType: pulumi.String("EVENT_BASED_POLICY"),
				Action: &dlm.LifecyclePolicyPolicyDetailsActionArgs{
					Name: pulumi.String("tf-acc-basic"),
					CrossRegionCopies: dlm.LifecyclePolicyPolicyDetailsActionCrossRegionCopyArray{
						&dlm.LifecyclePolicyPolicyDetailsActionCrossRegionCopyArgs{
							EncryptionConfiguration: nil,
							RetainRule: &dlm.LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleArgs{
								Interval:     pulumi.Int(15),
								IntervalUnit: pulumi.String("MONTHS"),
							},
							Target: pulumi.String("us-east-1"),
						},
					},
				},
				EventSource: &dlm.LifecyclePolicyPolicyDetailsEventSourceArgs{
					Type: pulumi.String("MANAGED_CWE"),
					Parameters: &dlm.LifecyclePolicyPolicyDetailsEventSourceParametersArgs{
						DescriptionRegex: pulumi.String("^.*Created for policy: policy-1234567890abcdef0.*$"),
						EventType:        pulumi.String("shareSnapshot"),
						SnapshotOwners: pulumi.StringArray{
							*pulumi.String(current.AccountId),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		examplePolicy, err := iam.LookupPolicy(ctx, &iam.LookupPolicyArgs{
			Name: pulumi.StringRef("AWSDataLifecycleManagerServiceRole"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = iam.NewRolePolicyAttachment(ctx, "exampleRolePolicyAttachment", &iam.RolePolicyAttachmentArgs{
			Role:      pulumi.Any(aws_iam_role.Example.Id),
			PolicyArn: *pulumi.String(examplePolicy.Arn),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Using `pulumi import`, import DLM lifecycle policies using their policy ID. For example:

```sh 

$ pulumi import aws:dlm/lifecyclePolicy:LifecyclePolicy example policy-abcdef12345678901

```

func GetLifecyclePolicy 

func GetLifecyclePolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *LifecyclePolicyState, opts ...pulumi.ResourceOption) (*LifecyclePolicy, error)

GetLifecyclePolicy gets an existing LifecyclePolicy 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 NewLifecyclePolicy 

func NewLifecyclePolicy(ctx *pulumi.Context,
	name string, args *LifecyclePolicyArgs, opts ...pulumi.ResourceOption) (*LifecyclePolicy, error)

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

func (*LifecyclePolicy) ElementType 

func (*LifecyclePolicy) ElementType() reflect.Type

func (*LifecyclePolicy) ToLifecyclePolicyOutput 

func (i *LifecyclePolicy) ToLifecyclePolicyOutput() LifecyclePolicyOutput

func (*LifecyclePolicy) ToLifecyclePolicyOutputWithContext 

func (i *LifecyclePolicy) ToLifecyclePolicyOutputWithContext(ctx context.Context) LifecyclePolicyOutput

type LifecyclePolicyArgs 

type LifecyclePolicyArgs struct {
	// A description for the DLM lifecycle policy.
	Description pulumi.StringInput
	// The ARN of an IAM role that is able to be assumed by the DLM service.
	ExecutionRoleArn pulumi.StringInput
	// See the `policyDetails` configuration block. Max of 1.
	PolicyDetails LifecyclePolicyPolicyDetailsInput
	// Whether the lifecycle policy should be enabled or disabled. `ENABLED` or `DISABLED` are valid values. Defaults to `ENABLED`.
	State pulumi.StringPtrInput
	// Key-value map of resource tags. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a LifecyclePolicy resource.

func (LifecyclePolicyArgs) ElementType 

func (LifecyclePolicyArgs) ElementType() reflect.Type

type LifecyclePolicyArray 

type LifecyclePolicyArray []LifecyclePolicyInput

func (LifecyclePolicyArray) ElementType 

func (LifecyclePolicyArray) ElementType() reflect.Type

func (LifecyclePolicyArray) ToLifecyclePolicyArrayOutput 

func (i LifecyclePolicyArray) ToLifecyclePolicyArrayOutput() LifecyclePolicyArrayOutput

func (LifecyclePolicyArray) ToLifecyclePolicyArrayOutputWithContext 

func (i LifecyclePolicyArray) ToLifecyclePolicyArrayOutputWithContext(ctx context.Context) LifecyclePolicyArrayOutput

type LifecyclePolicyArrayInput 

type LifecyclePolicyArrayInput interface {
	pulumi.Input

	ToLifecyclePolicyArrayOutput() LifecyclePolicyArrayOutput
	ToLifecyclePolicyArrayOutputWithContext(context.Context) LifecyclePolicyArrayOutput
}

LifecyclePolicyArrayInput is an input type that accepts LifecyclePolicyArray and LifecyclePolicyArrayOutput values. You can construct a concrete instance of `LifecyclePolicyArrayInput` via: 

LifecyclePolicyArray{ LifecyclePolicyArgs{...} }

type LifecyclePolicyArrayOutput 

type LifecyclePolicyArrayOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyArrayOutput) ElementType 

func (LifecyclePolicyArrayOutput) ElementType() reflect.Type

func (LifecyclePolicyArrayOutput) Index 

func (o LifecyclePolicyArrayOutput) Index(i pulumi.IntInput) LifecyclePolicyOutput

func (LifecyclePolicyArrayOutput) ToLifecyclePolicyArrayOutput 

func (o LifecyclePolicyArrayOutput) ToLifecyclePolicyArrayOutput() LifecyclePolicyArrayOutput

func (LifecyclePolicyArrayOutput) ToLifecyclePolicyArrayOutputWithContext 

func (o LifecyclePolicyArrayOutput) ToLifecyclePolicyArrayOutputWithContext(ctx context.Context) LifecyclePolicyArrayOutput

type LifecyclePolicyInput 

type LifecyclePolicyInput interface {
	pulumi.Input

	ToLifecyclePolicyOutput() LifecyclePolicyOutput
	ToLifecyclePolicyOutputWithContext(ctx context.Context) LifecyclePolicyOutput
}

type LifecyclePolicyMap 

type LifecyclePolicyMap map[string]LifecyclePolicyInput

func (LifecyclePolicyMap) ElementType 

func (LifecyclePolicyMap) ElementType() reflect.Type

func (LifecyclePolicyMap) ToLifecyclePolicyMapOutput 

func (i LifecyclePolicyMap) ToLifecyclePolicyMapOutput() LifecyclePolicyMapOutput

func (LifecyclePolicyMap) ToLifecyclePolicyMapOutputWithContext 

func (i LifecyclePolicyMap) ToLifecyclePolicyMapOutputWithContext(ctx context.Context) LifecyclePolicyMapOutput

type LifecyclePolicyMapInput 

type LifecyclePolicyMapInput interface {
	pulumi.Input

	ToLifecyclePolicyMapOutput() LifecyclePolicyMapOutput
	ToLifecyclePolicyMapOutputWithContext(context.Context) LifecyclePolicyMapOutput
}

LifecyclePolicyMapInput is an input type that accepts LifecyclePolicyMap and LifecyclePolicyMapOutput values. You can construct a concrete instance of `LifecyclePolicyMapInput` via: 

LifecyclePolicyMap{ "key": LifecyclePolicyArgs{...} }

type LifecyclePolicyMapOutput 

type LifecyclePolicyMapOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyMapOutput) ElementType 

func (LifecyclePolicyMapOutput) ElementType() reflect.Type

func (LifecyclePolicyMapOutput) MapIndex 

func (o LifecyclePolicyMapOutput) MapIndex(k pulumi.StringInput) LifecyclePolicyOutput

func (LifecyclePolicyMapOutput) ToLifecyclePolicyMapOutput 

func (o LifecyclePolicyMapOutput) ToLifecyclePolicyMapOutput() LifecyclePolicyMapOutput

func (LifecyclePolicyMapOutput) ToLifecyclePolicyMapOutputWithContext 

func (o LifecyclePolicyMapOutput) ToLifecyclePolicyMapOutputWithContext(ctx context.Context) LifecyclePolicyMapOutput

type LifecyclePolicyOutput 

type LifecyclePolicyOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyOutput) Arn 

func (o LifecyclePolicyOutput) Arn() pulumi.StringOutput

Amazon Resource Name (ARN) of the DLM Lifecycle Policy.

func (LifecyclePolicyOutput) Description 

func (o LifecyclePolicyOutput) Description() pulumi.StringOutput

A description for the DLM lifecycle policy.

func (LifecyclePolicyOutput) ElementType 

func (LifecyclePolicyOutput) ElementType() reflect.Type

func (LifecyclePolicyOutput) ExecutionRoleArn 

func (o LifecyclePolicyOutput) ExecutionRoleArn() pulumi.StringOutput

The ARN of an IAM role that is able to be assumed by the DLM service.

func (LifecyclePolicyOutput) PolicyDetails 

func (o LifecyclePolicyOutput) PolicyDetails() LifecyclePolicyPolicyDetailsOutput

See the `policyDetails` configuration block. Max of 1.

func (LifecyclePolicyOutput) State 

func (o LifecyclePolicyOutput) State() pulumi.StringPtrOutput

Whether the lifecycle policy should be enabled or disabled. `ENABLED` or `DISABLED` are valid values. Defaults to `ENABLED`.

func (LifecyclePolicyOutput) Tags 

func (o LifecyclePolicyOutput) Tags() pulumi.StringMapOutput

Key-value map of resource tags. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.

func (LifecyclePolicyOutput) TagsAll deprecated 

func (o LifecyclePolicyOutput) TagsAll() pulumi.StringMapOutput

A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.

Deprecated: Please use `tags` instead.

func (LifecyclePolicyOutput) ToLifecyclePolicyOutput 

func (o LifecyclePolicyOutput) ToLifecyclePolicyOutput() LifecyclePolicyOutput

func (LifecyclePolicyOutput) ToLifecyclePolicyOutputWithContext 

func (o LifecyclePolicyOutput) ToLifecyclePolicyOutputWithContext(ctx context.Context) LifecyclePolicyOutput

type LifecyclePolicyPolicyDetails 

type LifecyclePolicyPolicyDetails struct {
	// The actions to be performed when the event-based policy is triggered. You can specify only one action per policy. This parameter is required for event-based policies only. If you are creating a snapshot or AMI policy, omit this parameter. See the `action` configuration block.
	Action *LifecyclePolicyPolicyDetailsAction `pulumi:"action"`
	// The event that triggers the event-based policy. This parameter is required for event-based policies only. If you are creating a snapshot or AMI policy, omit this parameter. See the `eventSource` configuration block.
	EventSource *LifecyclePolicyPolicyDetailsEventSource `pulumi:"eventSource"`
	// Information about the event. See the `parameters` configuration block.
	Parameters *LifecyclePolicyPolicyDetailsParameters `pulumi:"parameters"`
	// The valid target resource types and actions a policy can manage. Specify `EBS_SNAPSHOT_MANAGEMENT` to create a lifecycle policy that manages the lifecycle of Amazon EBS snapshots. Specify `IMAGE_MANAGEMENT` to create a lifecycle policy that manages the lifecycle of EBS-backed AMIs. Specify `EVENT_BASED_POLICY` to create an event-based policy that performs specific actions when a defined event occurs in your AWS account. Default value is `EBS_SNAPSHOT_MANAGEMENT`.
	PolicyType *string `pulumi:"policyType"`
	// The location of the resources to backup. If the source resources are located in an AWS Region, specify `CLOUD`. If the source resources are located on an Outpost in your account, specify `OUTPOST`. If you specify `OUTPOST`, Amazon Data Lifecycle Manager backs up all resources of the specified type with matching target tags across all of the Outposts in your account. Valid values are `CLOUD` and `OUTPOST`.
	ResourceLocations *string `pulumi:"resourceLocations"`
	// A list of resource types that should be targeted by the lifecycle policy. Valid values are `VOLUME` and `INSTANCE`.
	ResourceTypes []string `pulumi:"resourceTypes"`
	// See the `schedule` configuration block.
	Schedules []LifecyclePolicyPolicyDetailsSchedule `pulumi:"schedules"`
	// A map of tag keys and their values. Any resources that match the `resourceTypes` and are tagged with _any_ of these tags will be targeted.
	//
	// > Note: You cannot have overlapping lifecycle policies that share the same `targetTags`. Pulumi is unable to detect this at plan time but it will fail during apply.
	TargetTags map[string]string `pulumi:"targetTags"`
}

type LifecyclePolicyPolicyDetailsAction 

type LifecyclePolicyPolicyDetailsAction struct {
	// The rule for copying shared snapshots across Regions. See the `crossRegionCopy` configuration block.
	CrossRegionCopies []LifecyclePolicyPolicyDetailsActionCrossRegionCopy `pulumi:"crossRegionCopies"`
	// A descriptive name for the action.
	Name string `pulumi:"name"`
}

type LifecyclePolicyPolicyDetailsActionArgs 

type LifecyclePolicyPolicyDetailsActionArgs struct {
	// The rule for copying shared snapshots across Regions. See the `crossRegionCopy` configuration block.
	CrossRegionCopies LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayInput `pulumi:"crossRegionCopies"`
	// A descriptive name for the action.
	Name pulumi.StringInput `pulumi:"name"`
}

func (LifecyclePolicyPolicyDetailsActionArgs) ElementType 

func (LifecyclePolicyPolicyDetailsActionArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsActionArgs) ToLifecyclePolicyPolicyDetailsActionOutput 

func (i LifecyclePolicyPolicyDetailsActionArgs) ToLifecyclePolicyPolicyDetailsActionOutput() LifecyclePolicyPolicyDetailsActionOutput

func (LifecyclePolicyPolicyDetailsActionArgs) ToLifecyclePolicyPolicyDetailsActionOutputWithContext 

func (i LifecyclePolicyPolicyDetailsActionArgs) ToLifecyclePolicyPolicyDetailsActionOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsActionOutput

func (LifecyclePolicyPolicyDetailsActionArgs) ToLifecyclePolicyPolicyDetailsActionPtrOutput 

func (i LifecyclePolicyPolicyDetailsActionArgs) ToLifecyclePolicyPolicyDetailsActionPtrOutput() LifecyclePolicyPolicyDetailsActionPtrOutput

func (LifecyclePolicyPolicyDetailsActionArgs) ToLifecyclePolicyPolicyDetailsActionPtrOutputWithContext 

func (i LifecyclePolicyPolicyDetailsActionArgs) ToLifecyclePolicyPolicyDetailsActionPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsActionPtrOutput

type LifecyclePolicyPolicyDetailsActionCrossRegionCopy 

type LifecyclePolicyPolicyDetailsActionCrossRegionCopy struct {
	// The encryption settings for the copied snapshot. See the `encryptionConfiguration` block. Max of 1 per action.
	EncryptionConfiguration LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfiguration `pulumi:"encryptionConfiguration"`
	// Specifies the retention rule for cross-Region snapshot copies. See the `retainRule` block. Max of 1 per action.
	RetainRule *LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRule `pulumi:"retainRule"`
	// The target Region or the Amazon Resource Name (ARN) of the target Outpost for the snapshot copies.
	Target string `pulumi:"target"`
}

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyArgs 

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyArgs struct {
	// The encryption settings for the copied snapshot. See the `encryptionConfiguration` block. Max of 1 per action.
	EncryptionConfiguration LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationInput `pulumi:"encryptionConfiguration"`
	// Specifies the retention rule for cross-Region snapshot copies. See the `retainRule` block. Max of 1 per action.
	RetainRule LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrInput `pulumi:"retainRule"`
	// The target Region or the Amazon Resource Name (ARN) of the target Outpost for the snapshot copies.
	Target pulumi.StringInput `pulumi:"target"`
}

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyArgs) ElementType 

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyArgs) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput 

func (i LifecyclePolicyPolicyDetailsActionCrossRegionCopyArgs) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput() LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyArgs) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyOutputWithContext 

func (i LifecyclePolicyPolicyDetailsActionCrossRegionCopyArgs) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyArray 

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyArray []LifecyclePolicyPolicyDetailsActionCrossRegionCopyInput

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyArray) ElementType 

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyArray) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyArray) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput 

func (i LifecyclePolicyPolicyDetailsActionCrossRegionCopyArray) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput() LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyArray) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutputWithContext 

func (i LifecyclePolicyPolicyDetailsActionCrossRegionCopyArray) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayInput 

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput() LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput
	ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput
}

LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayInput is an input type that accepts LifecyclePolicyPolicyDetailsActionCrossRegionCopyArray and LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayInput` via: 

LifecyclePolicyPolicyDetailsActionCrossRegionCopyArray{ LifecyclePolicyPolicyDetailsActionCrossRegionCopyArgs{...} }

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput 

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput) ElementType 

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput) Index 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput) Index(i pulumi.IntInput) LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput() LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutputWithContext 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfiguration 

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfiguration struct {
	// The Amazon Resource Name (ARN) of the AWS KMS customer master key (CMK) to use for EBS encryption. If this argument is not specified, the default KMS key for the account is used.
	CmkArn *string `pulumi:"cmkArn"`
	// To encrypt a copy of an unencrypted snapshot if encryption by default is not enabled, enable encryption using this parameter. Copies of encrypted snapshots are encrypted, even if this parameter is false or if encryption by default is not enabled.
	Encrypted *bool `pulumi:"encrypted"`
}

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationArgs 

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationArgs struct {
	// The Amazon Resource Name (ARN) of the AWS KMS customer master key (CMK) to use for EBS encryption. If this argument is not specified, the default KMS key for the account is used.
	CmkArn pulumi.StringPtrInput `pulumi:"cmkArn"`
	// To encrypt a copy of an unencrypted snapshot if encryption by default is not enabled, enable encryption using this parameter. Copies of encrypted snapshots are encrypted, even if this parameter is false or if encryption by default is not enabled.
	Encrypted pulumi.BoolPtrInput `pulumi:"encrypted"`
}

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationArgs) ElementType 

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationArgs) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput 

func (i LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationArgs) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput() LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationArgs) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutputWithContext 

func (i LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationArgs) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationInput 

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput() LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput
	ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput
}

LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationInput is an input type that accepts LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationArgs and LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationInput` via: 

LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationArgs{...}

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput 

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput) CmkArn 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput) CmkArn() pulumi.StringPtrOutput

The Amazon Resource Name (ARN) of the AWS KMS customer master key (CMK) to use for EBS encryption. If this argument is not specified, the default KMS key for the account is used.

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput) ElementType 

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput) Encrypted 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput) Encrypted() pulumi.BoolPtrOutput

To encrypt a copy of an unencrypted snapshot if encryption by default is not enabled, enable encryption using this parameter. Copies of encrypted snapshots are encrypted, even if this parameter is false or if encryption by default is not enabled.

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput() LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutputWithContext 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyInput 

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput() LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput
	ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput
}

LifecyclePolicyPolicyDetailsActionCrossRegionCopyInput is an input type that accepts LifecyclePolicyPolicyDetailsActionCrossRegionCopyArgs and LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsActionCrossRegionCopyInput` via: 

LifecyclePolicyPolicyDetailsActionCrossRegionCopyArgs{...}

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput 

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput) ElementType 

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput) EncryptionConfiguration 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput) EncryptionConfiguration() LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput

The encryption settings for the copied snapshot. See the `encryptionConfiguration` block. Max of 1 per action.

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput) RetainRule 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput) RetainRule() LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput

Specifies the retention rule for cross-Region snapshot copies. See the `retainRule` block. Max of 1 per action.

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput) Target 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput) Target() pulumi.StringOutput

The target Region or the Amazon Resource Name (ARN) of the target Outpost for the snapshot copies.

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput() LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyOutputWithContext 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRule 

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRule struct {
	// How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.
	Interval int `pulumi:"interval"`
	// The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.
	IntervalUnit string `pulumi:"intervalUnit"`
}

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleArgs 

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleArgs struct {
	// How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.
	Interval pulumi.IntInput `pulumi:"interval"`
	// The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.
	IntervalUnit pulumi.StringInput `pulumi:"intervalUnit"`
}

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleArgs) ElementType 

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleArgs) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput 

func (i LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleArgs) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput() LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleArgs) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutputWithContext 

func (i LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleArgs) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleArgs) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput 

func (i LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleArgs) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput() LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleArgs) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutputWithContext 

func (i LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleArgs) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleInput 

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput() LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput
	ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput
}

LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleInput is an input type that accepts LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleArgs and LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleInput` via: 

LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleArgs{...}

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput 

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput) ElementType 

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput) Interval 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput) Interval() pulumi.IntOutput

How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput) IntervalUnit() pulumi.StringOutput

The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput() LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutputWithContext 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput() LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrInput 

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput() LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput
	ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput
}

LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrInput is an input type that accepts LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleArgs, LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtr and LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrInput` via: 

        LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleArgs{...}

or:

        nil

func LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtr 

func LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtr(v *LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleArgs) LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrInput

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput 

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput) Elem 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput) Elem() LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput) ElementType 

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput) Interval 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput) Interval() pulumi.IntPtrOutput

How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput) IntervalUnit() pulumi.StringPtrOutput

The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput() LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput

type LifecyclePolicyPolicyDetailsActionInput 

type LifecyclePolicyPolicyDetailsActionInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsActionOutput() LifecyclePolicyPolicyDetailsActionOutput
	ToLifecyclePolicyPolicyDetailsActionOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsActionOutput
}

LifecyclePolicyPolicyDetailsActionInput is an input type that accepts LifecyclePolicyPolicyDetailsActionArgs and LifecyclePolicyPolicyDetailsActionOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsActionInput` via: 

LifecyclePolicyPolicyDetailsActionArgs{...}

type LifecyclePolicyPolicyDetailsActionOutput 

type LifecyclePolicyPolicyDetailsActionOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsActionOutput) CrossRegionCopies 

func (o LifecyclePolicyPolicyDetailsActionOutput) CrossRegionCopies() LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput

The rule for copying shared snapshots across Regions. See the `crossRegionCopy` configuration block.

func (LifecyclePolicyPolicyDetailsActionOutput) ElementType 

func (LifecyclePolicyPolicyDetailsActionOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsActionOutput) Name 

func (o LifecyclePolicyPolicyDetailsActionOutput) Name() pulumi.StringOutput

A descriptive name for the action.

func (LifecyclePolicyPolicyDetailsActionOutput) ToLifecyclePolicyPolicyDetailsActionOutput 

func (o LifecyclePolicyPolicyDetailsActionOutput) ToLifecyclePolicyPolicyDetailsActionOutput() LifecyclePolicyPolicyDetailsActionOutput

func (LifecyclePolicyPolicyDetailsActionOutput) ToLifecyclePolicyPolicyDetailsActionOutputWithContext 

func (o LifecyclePolicyPolicyDetailsActionOutput) ToLifecyclePolicyPolicyDetailsActionOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsActionOutput

func (LifecyclePolicyPolicyDetailsActionOutput) ToLifecyclePolicyPolicyDetailsActionPtrOutput 

func (o LifecyclePolicyPolicyDetailsActionOutput) ToLifecyclePolicyPolicyDetailsActionPtrOutput() LifecyclePolicyPolicyDetailsActionPtrOutput

func (LifecyclePolicyPolicyDetailsActionOutput) ToLifecyclePolicyPolicyDetailsActionPtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsActionOutput) ToLifecyclePolicyPolicyDetailsActionPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsActionPtrOutput

type LifecyclePolicyPolicyDetailsActionPtrInput 

type LifecyclePolicyPolicyDetailsActionPtrInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsActionPtrOutput() LifecyclePolicyPolicyDetailsActionPtrOutput
	ToLifecyclePolicyPolicyDetailsActionPtrOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsActionPtrOutput
}

LifecyclePolicyPolicyDetailsActionPtrInput is an input type that accepts LifecyclePolicyPolicyDetailsActionArgs, LifecyclePolicyPolicyDetailsActionPtr and LifecyclePolicyPolicyDetailsActionPtrOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsActionPtrInput` via: 

        LifecyclePolicyPolicyDetailsActionArgs{...}

or:

        nil

func LifecyclePolicyPolicyDetailsActionPtr 

func LifecyclePolicyPolicyDetailsActionPtr(v *LifecyclePolicyPolicyDetailsActionArgs) LifecyclePolicyPolicyDetailsActionPtrInput

type LifecyclePolicyPolicyDetailsActionPtrOutput 

type LifecyclePolicyPolicyDetailsActionPtrOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsActionPtrOutput) CrossRegionCopies 

func (o LifecyclePolicyPolicyDetailsActionPtrOutput) CrossRegionCopies() LifecyclePolicyPolicyDetailsActionCrossRegionCopyArrayOutput

The rule for copying shared snapshots across Regions. See the `crossRegionCopy` configuration block.

func (LifecyclePolicyPolicyDetailsActionPtrOutput) Elem 

func (o LifecyclePolicyPolicyDetailsActionPtrOutput) Elem() LifecyclePolicyPolicyDetailsActionOutput

func (LifecyclePolicyPolicyDetailsActionPtrOutput) ElementType 

func (LifecyclePolicyPolicyDetailsActionPtrOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsActionPtrOutput) Name 

func (o LifecyclePolicyPolicyDetailsActionPtrOutput) Name() pulumi.StringPtrOutput

A descriptive name for the action.

func (LifecyclePolicyPolicyDetailsActionPtrOutput) ToLifecyclePolicyPolicyDetailsActionPtrOutput 

func (o LifecyclePolicyPolicyDetailsActionPtrOutput) ToLifecyclePolicyPolicyDetailsActionPtrOutput() LifecyclePolicyPolicyDetailsActionPtrOutput

func (LifecyclePolicyPolicyDetailsActionPtrOutput) ToLifecyclePolicyPolicyDetailsActionPtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsActionPtrOutput) ToLifecyclePolicyPolicyDetailsActionPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsActionPtrOutput

type LifecyclePolicyPolicyDetailsArgs 

type LifecyclePolicyPolicyDetailsArgs struct {
	// The actions to be performed when the event-based policy is triggered. You can specify only one action per policy. This parameter is required for event-based policies only. If you are creating a snapshot or AMI policy, omit this parameter. See the `action` configuration block.
	Action LifecyclePolicyPolicyDetailsActionPtrInput `pulumi:"action"`
	// The event that triggers the event-based policy. This parameter is required for event-based policies only. If you are creating a snapshot or AMI policy, omit this parameter. See the `eventSource` configuration block.
	EventSource LifecyclePolicyPolicyDetailsEventSourcePtrInput `pulumi:"eventSource"`
	// Information about the event. See the `parameters` configuration block.
	Parameters LifecyclePolicyPolicyDetailsParametersPtrInput `pulumi:"parameters"`
	// The valid target resource types and actions a policy can manage. Specify `EBS_SNAPSHOT_MANAGEMENT` to create a lifecycle policy that manages the lifecycle of Amazon EBS snapshots. Specify `IMAGE_MANAGEMENT` to create a lifecycle policy that manages the lifecycle of EBS-backed AMIs. Specify `EVENT_BASED_POLICY` to create an event-based policy that performs specific actions when a defined event occurs in your AWS account. Default value is `EBS_SNAPSHOT_MANAGEMENT`.
	PolicyType pulumi.StringPtrInput `pulumi:"policyType"`
	// The location of the resources to backup. If the source resources are located in an AWS Region, specify `CLOUD`. If the source resources are located on an Outpost in your account, specify `OUTPOST`. If you specify `OUTPOST`, Amazon Data Lifecycle Manager backs up all resources of the specified type with matching target tags across all of the Outposts in your account. Valid values are `CLOUD` and `OUTPOST`.
	ResourceLocations pulumi.StringPtrInput `pulumi:"resourceLocations"`
	// A list of resource types that should be targeted by the lifecycle policy. Valid values are `VOLUME` and `INSTANCE`.
	ResourceTypes pulumi.StringArrayInput `pulumi:"resourceTypes"`
	// See the `schedule` configuration block.
	Schedules LifecyclePolicyPolicyDetailsScheduleArrayInput `pulumi:"schedules"`
	// A map of tag keys and their values. Any resources that match the `resourceTypes` and are tagged with _any_ of these tags will be targeted.
	//
	// > Note: You cannot have overlapping lifecycle policies that share the same `targetTags`. Pulumi is unable to detect this at plan time but it will fail during apply.
	TargetTags pulumi.StringMapInput `pulumi:"targetTags"`
}

func (LifecyclePolicyPolicyDetailsArgs) ElementType 

func (LifecyclePolicyPolicyDetailsArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsArgs) ToLifecyclePolicyPolicyDetailsOutput 

func (i LifecyclePolicyPolicyDetailsArgs) ToLifecyclePolicyPolicyDetailsOutput() LifecyclePolicyPolicyDetailsOutput

func (LifecyclePolicyPolicyDetailsArgs) ToLifecyclePolicyPolicyDetailsOutputWithContext 

func (i LifecyclePolicyPolicyDetailsArgs) ToLifecyclePolicyPolicyDetailsOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsOutput

func (LifecyclePolicyPolicyDetailsArgs) ToLifecyclePolicyPolicyDetailsPtrOutput 

func (i LifecyclePolicyPolicyDetailsArgs) ToLifecyclePolicyPolicyDetailsPtrOutput() LifecyclePolicyPolicyDetailsPtrOutput

func (LifecyclePolicyPolicyDetailsArgs) ToLifecyclePolicyPolicyDetailsPtrOutputWithContext 

func (i LifecyclePolicyPolicyDetailsArgs) ToLifecyclePolicyPolicyDetailsPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsPtrOutput

type LifecyclePolicyPolicyDetailsEventSource 

type LifecyclePolicyPolicyDetailsEventSource struct {
	// Information about the event. See the `parameters` configuration block.
	Parameters LifecyclePolicyPolicyDetailsEventSourceParameters `pulumi:"parameters"`
	// The source of the event. Currently only managed CloudWatch Events rules are supported. Valid values are `MANAGED_CWE`.
	Type string `pulumi:"type"`
}

type LifecyclePolicyPolicyDetailsEventSourceArgs 

type LifecyclePolicyPolicyDetailsEventSourceArgs struct {
	// Information about the event. See the `parameters` configuration block.
	Parameters LifecyclePolicyPolicyDetailsEventSourceParametersInput `pulumi:"parameters"`
	// The source of the event. Currently only managed CloudWatch Events rules are supported. Valid values are `MANAGED_CWE`.
	Type pulumi.StringInput `pulumi:"type"`
}

func (LifecyclePolicyPolicyDetailsEventSourceArgs) ElementType 

func (LifecyclePolicyPolicyDetailsEventSourceArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsEventSourceArgs) ToLifecyclePolicyPolicyDetailsEventSourceOutput 

func (i LifecyclePolicyPolicyDetailsEventSourceArgs) ToLifecyclePolicyPolicyDetailsEventSourceOutput() LifecyclePolicyPolicyDetailsEventSourceOutput

func (LifecyclePolicyPolicyDetailsEventSourceArgs) ToLifecyclePolicyPolicyDetailsEventSourceOutputWithContext 

func (i LifecyclePolicyPolicyDetailsEventSourceArgs) ToLifecyclePolicyPolicyDetailsEventSourceOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsEventSourceOutput

func (LifecyclePolicyPolicyDetailsEventSourceArgs) ToLifecyclePolicyPolicyDetailsEventSourcePtrOutput 

func (i LifecyclePolicyPolicyDetailsEventSourceArgs) ToLifecyclePolicyPolicyDetailsEventSourcePtrOutput() LifecyclePolicyPolicyDetailsEventSourcePtrOutput

func (LifecyclePolicyPolicyDetailsEventSourceArgs) ToLifecyclePolicyPolicyDetailsEventSourcePtrOutputWithContext 

func (i LifecyclePolicyPolicyDetailsEventSourceArgs) ToLifecyclePolicyPolicyDetailsEventSourcePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsEventSourcePtrOutput

type LifecyclePolicyPolicyDetailsEventSourceInput 

type LifecyclePolicyPolicyDetailsEventSourceInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsEventSourceOutput() LifecyclePolicyPolicyDetailsEventSourceOutput
	ToLifecyclePolicyPolicyDetailsEventSourceOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsEventSourceOutput
}

LifecyclePolicyPolicyDetailsEventSourceInput is an input type that accepts LifecyclePolicyPolicyDetailsEventSourceArgs and LifecyclePolicyPolicyDetailsEventSourceOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsEventSourceInput` via: 

LifecyclePolicyPolicyDetailsEventSourceArgs{...}

type LifecyclePolicyPolicyDetailsEventSourceOutput 

type LifecyclePolicyPolicyDetailsEventSourceOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsEventSourceOutput) ElementType 

func (LifecyclePolicyPolicyDetailsEventSourceOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsEventSourceOutput) Parameters 

func (o LifecyclePolicyPolicyDetailsEventSourceOutput) Parameters() LifecyclePolicyPolicyDetailsEventSourceParametersOutput

Information about the event. See the `parameters` configuration block.

func (LifecyclePolicyPolicyDetailsEventSourceOutput) ToLifecyclePolicyPolicyDetailsEventSourceOutput 

func (o LifecyclePolicyPolicyDetailsEventSourceOutput) ToLifecyclePolicyPolicyDetailsEventSourceOutput() LifecyclePolicyPolicyDetailsEventSourceOutput

func (LifecyclePolicyPolicyDetailsEventSourceOutput) ToLifecyclePolicyPolicyDetailsEventSourceOutputWithContext 

func (o LifecyclePolicyPolicyDetailsEventSourceOutput) ToLifecyclePolicyPolicyDetailsEventSourceOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsEventSourceOutput

func (LifecyclePolicyPolicyDetailsEventSourceOutput) ToLifecyclePolicyPolicyDetailsEventSourcePtrOutput 

func (o LifecyclePolicyPolicyDetailsEventSourceOutput) ToLifecyclePolicyPolicyDetailsEventSourcePtrOutput() LifecyclePolicyPolicyDetailsEventSourcePtrOutput

func (LifecyclePolicyPolicyDetailsEventSourceOutput) ToLifecyclePolicyPolicyDetailsEventSourcePtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsEventSourceOutput) ToLifecyclePolicyPolicyDetailsEventSourcePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsEventSourcePtrOutput

func (LifecyclePolicyPolicyDetailsEventSourceOutput) Type 

func (o LifecyclePolicyPolicyDetailsEventSourceOutput) Type() pulumi.StringOutput

The source of the event. Currently only managed CloudWatch Events rules are supported. Valid values are `MANAGED_CWE`.

type LifecyclePolicyPolicyDetailsEventSourceParameters 

type LifecyclePolicyPolicyDetailsEventSourceParameters struct {
	// The snapshot description that can trigger the policy. The description pattern is specified using a regular expression. The policy runs only if a snapshot with a description that matches the specified pattern is shared with your account.
	DescriptionRegex string `pulumi:"descriptionRegex"`
	// The type of event. Currently, only `shareSnapshot` events are supported.
	EventType string `pulumi:"eventType"`
	// The IDs of the AWS accounts that can trigger policy by sharing snapshots with your account. The policy only runs if one of the specified AWS accounts shares a snapshot with your account.
	SnapshotOwners []string `pulumi:"snapshotOwners"`
}

type LifecyclePolicyPolicyDetailsEventSourceParametersArgs 

type LifecyclePolicyPolicyDetailsEventSourceParametersArgs struct {
	// The snapshot description that can trigger the policy. The description pattern is specified using a regular expression. The policy runs only if a snapshot with a description that matches the specified pattern is shared with your account.
	DescriptionRegex pulumi.StringInput `pulumi:"descriptionRegex"`
	// The type of event. Currently, only `shareSnapshot` events are supported.
	EventType pulumi.StringInput `pulumi:"eventType"`
	// The IDs of the AWS accounts that can trigger policy by sharing snapshots with your account. The policy only runs if one of the specified AWS accounts shares a snapshot with your account.
	SnapshotOwners pulumi.StringArrayInput `pulumi:"snapshotOwners"`
}

func (LifecyclePolicyPolicyDetailsEventSourceParametersArgs) ElementType 

func (LifecyclePolicyPolicyDetailsEventSourceParametersArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsEventSourceParametersArgs) ToLifecyclePolicyPolicyDetailsEventSourceParametersOutput 

func (i LifecyclePolicyPolicyDetailsEventSourceParametersArgs) ToLifecyclePolicyPolicyDetailsEventSourceParametersOutput() LifecyclePolicyPolicyDetailsEventSourceParametersOutput

func (LifecyclePolicyPolicyDetailsEventSourceParametersArgs) ToLifecyclePolicyPolicyDetailsEventSourceParametersOutputWithContext 

func (i LifecyclePolicyPolicyDetailsEventSourceParametersArgs) ToLifecyclePolicyPolicyDetailsEventSourceParametersOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsEventSourceParametersOutput

func (LifecyclePolicyPolicyDetailsEventSourceParametersArgs) ToLifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput 

func (i LifecyclePolicyPolicyDetailsEventSourceParametersArgs) ToLifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput() LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput

func (LifecyclePolicyPolicyDetailsEventSourceParametersArgs) ToLifecyclePolicyPolicyDetailsEventSourceParametersPtrOutputWithContext 

func (i LifecyclePolicyPolicyDetailsEventSourceParametersArgs) ToLifecyclePolicyPolicyDetailsEventSourceParametersPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput

type LifecyclePolicyPolicyDetailsEventSourceParametersInput 

type LifecyclePolicyPolicyDetailsEventSourceParametersInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsEventSourceParametersOutput() LifecyclePolicyPolicyDetailsEventSourceParametersOutput
	ToLifecyclePolicyPolicyDetailsEventSourceParametersOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsEventSourceParametersOutput
}

LifecyclePolicyPolicyDetailsEventSourceParametersInput is an input type that accepts LifecyclePolicyPolicyDetailsEventSourceParametersArgs and LifecyclePolicyPolicyDetailsEventSourceParametersOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsEventSourceParametersInput` via: 

LifecyclePolicyPolicyDetailsEventSourceParametersArgs{...}

type LifecyclePolicyPolicyDetailsEventSourceParametersOutput 

type LifecyclePolicyPolicyDetailsEventSourceParametersOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsEventSourceParametersOutput) DescriptionRegex 

func (o LifecyclePolicyPolicyDetailsEventSourceParametersOutput) DescriptionRegex() pulumi.StringOutput

The snapshot description that can trigger the policy. The description pattern is specified using a regular expression. The policy runs only if a snapshot with a description that matches the specified pattern is shared with your account.

func (LifecyclePolicyPolicyDetailsEventSourceParametersOutput) ElementType 

func (LifecyclePolicyPolicyDetailsEventSourceParametersOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsEventSourceParametersOutput) EventType 

func (o LifecyclePolicyPolicyDetailsEventSourceParametersOutput) EventType() pulumi.StringOutput

The type of event. Currently, only `shareSnapshot` events are supported.

func (LifecyclePolicyPolicyDetailsEventSourceParametersOutput) SnapshotOwners 

func (o LifecyclePolicyPolicyDetailsEventSourceParametersOutput) SnapshotOwners() pulumi.StringArrayOutput

The IDs of the AWS accounts that can trigger policy by sharing snapshots with your account. The policy only runs if one of the specified AWS accounts shares a snapshot with your account.

func (LifecyclePolicyPolicyDetailsEventSourceParametersOutput) ToLifecyclePolicyPolicyDetailsEventSourceParametersOutput 

func (o LifecyclePolicyPolicyDetailsEventSourceParametersOutput) ToLifecyclePolicyPolicyDetailsEventSourceParametersOutput() LifecyclePolicyPolicyDetailsEventSourceParametersOutput

func (LifecyclePolicyPolicyDetailsEventSourceParametersOutput) ToLifecyclePolicyPolicyDetailsEventSourceParametersOutputWithContext 

func (o LifecyclePolicyPolicyDetailsEventSourceParametersOutput) ToLifecyclePolicyPolicyDetailsEventSourceParametersOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsEventSourceParametersOutput

func (LifecyclePolicyPolicyDetailsEventSourceParametersOutput) ToLifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput 

func (o LifecyclePolicyPolicyDetailsEventSourceParametersOutput) ToLifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput() LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput

func (LifecyclePolicyPolicyDetailsEventSourceParametersOutput) ToLifecyclePolicyPolicyDetailsEventSourceParametersPtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsEventSourceParametersOutput) ToLifecyclePolicyPolicyDetailsEventSourceParametersPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput

type LifecyclePolicyPolicyDetailsEventSourceParametersPtrInput 

type LifecyclePolicyPolicyDetailsEventSourceParametersPtrInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput() LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput
	ToLifecyclePolicyPolicyDetailsEventSourceParametersPtrOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput
}

LifecyclePolicyPolicyDetailsEventSourceParametersPtrInput is an input type that accepts LifecyclePolicyPolicyDetailsEventSourceParametersArgs, LifecyclePolicyPolicyDetailsEventSourceParametersPtr and LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsEventSourceParametersPtrInput` via: 

        LifecyclePolicyPolicyDetailsEventSourceParametersArgs{...}

or:

        nil

func LifecyclePolicyPolicyDetailsEventSourceParametersPtr 

func LifecyclePolicyPolicyDetailsEventSourceParametersPtr(v *LifecyclePolicyPolicyDetailsEventSourceParametersArgs) LifecyclePolicyPolicyDetailsEventSourceParametersPtrInput

type LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput 

type LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput) DescriptionRegex 

func (o LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput) DescriptionRegex() pulumi.StringPtrOutput

The snapshot description that can trigger the policy. The description pattern is specified using a regular expression. The policy runs only if a snapshot with a description that matches the specified pattern is shared with your account.

func (LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput) Elem 

func (o LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput) Elem() LifecyclePolicyPolicyDetailsEventSourceParametersOutput

func (LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput) ElementType 

func (LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput) EventType 

func (o LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput) EventType() pulumi.StringPtrOutput

The type of event. Currently, only `shareSnapshot` events are supported.

func (LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput) SnapshotOwners 

func (o LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput) SnapshotOwners() pulumi.StringArrayOutput

The IDs of the AWS accounts that can trigger policy by sharing snapshots with your account. The policy only runs if one of the specified AWS accounts shares a snapshot with your account.

func (LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput) ToLifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput 

func (o LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput) ToLifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput() LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput

func (LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput) ToLifecyclePolicyPolicyDetailsEventSourceParametersPtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput) ToLifecyclePolicyPolicyDetailsEventSourceParametersPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput

type LifecyclePolicyPolicyDetailsEventSourcePtrInput 

type LifecyclePolicyPolicyDetailsEventSourcePtrInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsEventSourcePtrOutput() LifecyclePolicyPolicyDetailsEventSourcePtrOutput
	ToLifecyclePolicyPolicyDetailsEventSourcePtrOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsEventSourcePtrOutput
}

LifecyclePolicyPolicyDetailsEventSourcePtrInput is an input type that accepts LifecyclePolicyPolicyDetailsEventSourceArgs, LifecyclePolicyPolicyDetailsEventSourcePtr and LifecyclePolicyPolicyDetailsEventSourcePtrOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsEventSourcePtrInput` via: 

        LifecyclePolicyPolicyDetailsEventSourceArgs{...}

or:

        nil

func LifecyclePolicyPolicyDetailsEventSourcePtr 

func LifecyclePolicyPolicyDetailsEventSourcePtr(v *LifecyclePolicyPolicyDetailsEventSourceArgs) LifecyclePolicyPolicyDetailsEventSourcePtrInput

type LifecyclePolicyPolicyDetailsEventSourcePtrOutput 

type LifecyclePolicyPolicyDetailsEventSourcePtrOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsEventSourcePtrOutput) Elem 

func (o LifecyclePolicyPolicyDetailsEventSourcePtrOutput) Elem() LifecyclePolicyPolicyDetailsEventSourceOutput

func (LifecyclePolicyPolicyDetailsEventSourcePtrOutput) ElementType 

func (LifecyclePolicyPolicyDetailsEventSourcePtrOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsEventSourcePtrOutput) Parameters 

func (o LifecyclePolicyPolicyDetailsEventSourcePtrOutput) Parameters() LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput

Information about the event. See the `parameters` configuration block.

func (LifecyclePolicyPolicyDetailsEventSourcePtrOutput) ToLifecyclePolicyPolicyDetailsEventSourcePtrOutput 

func (o LifecyclePolicyPolicyDetailsEventSourcePtrOutput) ToLifecyclePolicyPolicyDetailsEventSourcePtrOutput() LifecyclePolicyPolicyDetailsEventSourcePtrOutput

func (LifecyclePolicyPolicyDetailsEventSourcePtrOutput) ToLifecyclePolicyPolicyDetailsEventSourcePtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsEventSourcePtrOutput) ToLifecyclePolicyPolicyDetailsEventSourcePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsEventSourcePtrOutput

func (LifecyclePolicyPolicyDetailsEventSourcePtrOutput) Type 

func (o LifecyclePolicyPolicyDetailsEventSourcePtrOutput) Type() pulumi.StringPtrOutput

The source of the event. Currently only managed CloudWatch Events rules are supported. Valid values are `MANAGED_CWE`.

type LifecyclePolicyPolicyDetailsInput 

type LifecyclePolicyPolicyDetailsInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsOutput() LifecyclePolicyPolicyDetailsOutput
	ToLifecyclePolicyPolicyDetailsOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsOutput
}

LifecyclePolicyPolicyDetailsInput is an input type that accepts LifecyclePolicyPolicyDetailsArgs and LifecyclePolicyPolicyDetailsOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsInput` via: 

LifecyclePolicyPolicyDetailsArgs{...}

type LifecyclePolicyPolicyDetailsOutput 

type LifecyclePolicyPolicyDetailsOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsOutput) Action 

func (o LifecyclePolicyPolicyDetailsOutput) Action() LifecyclePolicyPolicyDetailsActionPtrOutput

The actions to be performed when the event-based policy is triggered. You can specify only one action per policy. This parameter is required for event-based policies only. If you are creating a snapshot or AMI policy, omit this parameter. See the `action` configuration block.

func (LifecyclePolicyPolicyDetailsOutput) ElementType 

func (LifecyclePolicyPolicyDetailsOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsOutput) EventSource 

func (o LifecyclePolicyPolicyDetailsOutput) EventSource() LifecyclePolicyPolicyDetailsEventSourcePtrOutput

The event that triggers the event-based policy. This parameter is required for event-based policies only. If you are creating a snapshot or AMI policy, omit this parameter. See the `eventSource` configuration block.

func (LifecyclePolicyPolicyDetailsOutput) Parameters 

func (o LifecyclePolicyPolicyDetailsOutput) Parameters() LifecyclePolicyPolicyDetailsParametersPtrOutput

Information about the event. See the `parameters` configuration block.

func (LifecyclePolicyPolicyDetailsOutput) PolicyType 

func (o LifecyclePolicyPolicyDetailsOutput) PolicyType() pulumi.StringPtrOutput

The valid target resource types and actions a policy can manage. Specify `EBS_SNAPSHOT_MANAGEMENT` to create a lifecycle policy that manages the lifecycle of Amazon EBS snapshots. Specify `IMAGE_MANAGEMENT` to create a lifecycle policy that manages the lifecycle of EBS-backed AMIs. Specify `EVENT_BASED_POLICY` to create an event-based policy that performs specific actions when a defined event occurs in your AWS account. Default value is `EBS_SNAPSHOT_MANAGEMENT`.

func (LifecyclePolicyPolicyDetailsOutput) ResourceLocations 

func (o LifecyclePolicyPolicyDetailsOutput) ResourceLocations() pulumi.StringPtrOutput

The location of the resources to backup. If the source resources are located in an AWS Region, specify `CLOUD`. If the source resources are located on an Outpost in your account, specify `OUTPOST`. If you specify `OUTPOST`, Amazon Data Lifecycle Manager backs up all resources of the specified type with matching target tags across all of the Outposts in your account. Valid values are `CLOUD` and `OUTPOST`.

func (LifecyclePolicyPolicyDetailsOutput) ResourceTypes 

func (o LifecyclePolicyPolicyDetailsOutput) ResourceTypes() pulumi.StringArrayOutput

A list of resource types that should be targeted by the lifecycle policy. Valid values are `VOLUME` and `INSTANCE`.

func (LifecyclePolicyPolicyDetailsOutput) Schedules 

func (o LifecyclePolicyPolicyDetailsOutput) Schedules() LifecyclePolicyPolicyDetailsScheduleArrayOutput

See the `schedule` configuration block.

func (LifecyclePolicyPolicyDetailsOutput) TargetTags 

func (o LifecyclePolicyPolicyDetailsOutput) TargetTags() pulumi.StringMapOutput

A map of tag keys and their values. Any resources that match the `resourceTypes` and are tagged with _any_ of these tags will be targeted.

> Note: You cannot have overlapping lifecycle policies that share the same `targetTags`. Pulumi is unable to detect this at plan time but it will fail during apply.

func (LifecyclePolicyPolicyDetailsOutput) ToLifecyclePolicyPolicyDetailsOutput 

func (o LifecyclePolicyPolicyDetailsOutput) ToLifecyclePolicyPolicyDetailsOutput() LifecyclePolicyPolicyDetailsOutput

func (LifecyclePolicyPolicyDetailsOutput) ToLifecyclePolicyPolicyDetailsOutputWithContext 

func (o LifecyclePolicyPolicyDetailsOutput) ToLifecyclePolicyPolicyDetailsOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsOutput

func (LifecyclePolicyPolicyDetailsOutput) ToLifecyclePolicyPolicyDetailsPtrOutput 

func (o LifecyclePolicyPolicyDetailsOutput) ToLifecyclePolicyPolicyDetailsPtrOutput() LifecyclePolicyPolicyDetailsPtrOutput

func (LifecyclePolicyPolicyDetailsOutput) ToLifecyclePolicyPolicyDetailsPtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsOutput) ToLifecyclePolicyPolicyDetailsPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsPtrOutput

type LifecyclePolicyPolicyDetailsParameters 

type LifecyclePolicyPolicyDetailsParameters struct {
	// Indicates whether to exclude the root volume from snapshots created using CreateSnapshots. The default is `false`.
	ExcludeBootVolume *bool `pulumi:"excludeBootVolume"`
	// Applies to AMI lifecycle policies only. Indicates whether targeted instances are rebooted when the lifecycle policy runs. `true` indicates that targeted instances are not rebooted when the policy runs. `false` indicates that target instances are rebooted when the policy runs. The default is `true` (instances are not rebooted).
	NoReboot *bool `pulumi:"noReboot"`
}

type LifecyclePolicyPolicyDetailsParametersArgs 

type LifecyclePolicyPolicyDetailsParametersArgs struct {
	// Indicates whether to exclude the root volume from snapshots created using CreateSnapshots. The default is `false`.
	ExcludeBootVolume pulumi.BoolPtrInput `pulumi:"excludeBootVolume"`
	// Applies to AMI lifecycle policies only. Indicates whether targeted instances are rebooted when the lifecycle policy runs. `true` indicates that targeted instances are not rebooted when the policy runs. `false` indicates that target instances are rebooted when the policy runs. The default is `true` (instances are not rebooted).
	NoReboot pulumi.BoolPtrInput `pulumi:"noReboot"`
}

func (LifecyclePolicyPolicyDetailsParametersArgs) ElementType 

func (LifecyclePolicyPolicyDetailsParametersArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsParametersArgs) ToLifecyclePolicyPolicyDetailsParametersOutput 

func (i LifecyclePolicyPolicyDetailsParametersArgs) ToLifecyclePolicyPolicyDetailsParametersOutput() LifecyclePolicyPolicyDetailsParametersOutput

func (LifecyclePolicyPolicyDetailsParametersArgs) ToLifecyclePolicyPolicyDetailsParametersOutputWithContext 

func (i LifecyclePolicyPolicyDetailsParametersArgs) ToLifecyclePolicyPolicyDetailsParametersOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsParametersOutput

func (LifecyclePolicyPolicyDetailsParametersArgs) ToLifecyclePolicyPolicyDetailsParametersPtrOutput 

func (i LifecyclePolicyPolicyDetailsParametersArgs) ToLifecyclePolicyPolicyDetailsParametersPtrOutput() LifecyclePolicyPolicyDetailsParametersPtrOutput

func (LifecyclePolicyPolicyDetailsParametersArgs) ToLifecyclePolicyPolicyDetailsParametersPtrOutputWithContext 

func (i LifecyclePolicyPolicyDetailsParametersArgs) ToLifecyclePolicyPolicyDetailsParametersPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsParametersPtrOutput

type LifecyclePolicyPolicyDetailsParametersInput 

type LifecyclePolicyPolicyDetailsParametersInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsParametersOutput() LifecyclePolicyPolicyDetailsParametersOutput
	ToLifecyclePolicyPolicyDetailsParametersOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsParametersOutput
}

LifecyclePolicyPolicyDetailsParametersInput is an input type that accepts LifecyclePolicyPolicyDetailsParametersArgs and LifecyclePolicyPolicyDetailsParametersOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsParametersInput` via: 

LifecyclePolicyPolicyDetailsParametersArgs{...}

type LifecyclePolicyPolicyDetailsParametersOutput 

type LifecyclePolicyPolicyDetailsParametersOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsParametersOutput) ElementType 

func (LifecyclePolicyPolicyDetailsParametersOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsParametersOutput) ExcludeBootVolume 

func (o LifecyclePolicyPolicyDetailsParametersOutput) ExcludeBootVolume() pulumi.BoolPtrOutput

Indicates whether to exclude the root volume from snapshots created using CreateSnapshots. The default is `false`.

func (LifecyclePolicyPolicyDetailsParametersOutput) NoReboot 

func (o LifecyclePolicyPolicyDetailsParametersOutput) NoReboot() pulumi.BoolPtrOutput

Applies to AMI lifecycle policies only. Indicates whether targeted instances are rebooted when the lifecycle policy runs. `true` indicates that targeted instances are not rebooted when the policy runs. `false` indicates that target instances are rebooted when the policy runs. The default is `true` (instances are not rebooted).

func (LifecyclePolicyPolicyDetailsParametersOutput) ToLifecyclePolicyPolicyDetailsParametersOutput 

func (o LifecyclePolicyPolicyDetailsParametersOutput) ToLifecyclePolicyPolicyDetailsParametersOutput() LifecyclePolicyPolicyDetailsParametersOutput

func (LifecyclePolicyPolicyDetailsParametersOutput) ToLifecyclePolicyPolicyDetailsParametersOutputWithContext 

func (o LifecyclePolicyPolicyDetailsParametersOutput) ToLifecyclePolicyPolicyDetailsParametersOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsParametersOutput

func (LifecyclePolicyPolicyDetailsParametersOutput) ToLifecyclePolicyPolicyDetailsParametersPtrOutput 

func (o LifecyclePolicyPolicyDetailsParametersOutput) ToLifecyclePolicyPolicyDetailsParametersPtrOutput() LifecyclePolicyPolicyDetailsParametersPtrOutput

func (LifecyclePolicyPolicyDetailsParametersOutput) ToLifecyclePolicyPolicyDetailsParametersPtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsParametersOutput) ToLifecyclePolicyPolicyDetailsParametersPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsParametersPtrOutput

type LifecyclePolicyPolicyDetailsParametersPtrInput 

type LifecyclePolicyPolicyDetailsParametersPtrInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsParametersPtrOutput() LifecyclePolicyPolicyDetailsParametersPtrOutput
	ToLifecyclePolicyPolicyDetailsParametersPtrOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsParametersPtrOutput
}

LifecyclePolicyPolicyDetailsParametersPtrInput is an input type that accepts LifecyclePolicyPolicyDetailsParametersArgs, LifecyclePolicyPolicyDetailsParametersPtr and LifecyclePolicyPolicyDetailsParametersPtrOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsParametersPtrInput` via: 

        LifecyclePolicyPolicyDetailsParametersArgs{...}

or:

        nil

func LifecyclePolicyPolicyDetailsParametersPtr 

func LifecyclePolicyPolicyDetailsParametersPtr(v *LifecyclePolicyPolicyDetailsParametersArgs) LifecyclePolicyPolicyDetailsParametersPtrInput

type LifecyclePolicyPolicyDetailsParametersPtrOutput 

type LifecyclePolicyPolicyDetailsParametersPtrOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsParametersPtrOutput) Elem 

func (o LifecyclePolicyPolicyDetailsParametersPtrOutput) Elem() LifecyclePolicyPolicyDetailsParametersOutput

func (LifecyclePolicyPolicyDetailsParametersPtrOutput) ElementType 

func (LifecyclePolicyPolicyDetailsParametersPtrOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsParametersPtrOutput) ExcludeBootVolume 

func (o LifecyclePolicyPolicyDetailsParametersPtrOutput) ExcludeBootVolume() pulumi.BoolPtrOutput

Indicates whether to exclude the root volume from snapshots created using CreateSnapshots. The default is `false`.

func (LifecyclePolicyPolicyDetailsParametersPtrOutput) NoReboot 

func (o LifecyclePolicyPolicyDetailsParametersPtrOutput) NoReboot() pulumi.BoolPtrOutput

Applies to AMI lifecycle policies only. Indicates whether targeted instances are rebooted when the lifecycle policy runs. `true` indicates that targeted instances are not rebooted when the policy runs. `false` indicates that target instances are rebooted when the policy runs. The default is `true` (instances are not rebooted).

func (LifecyclePolicyPolicyDetailsParametersPtrOutput) ToLifecyclePolicyPolicyDetailsParametersPtrOutput 

func (o LifecyclePolicyPolicyDetailsParametersPtrOutput) ToLifecyclePolicyPolicyDetailsParametersPtrOutput() LifecyclePolicyPolicyDetailsParametersPtrOutput

func (LifecyclePolicyPolicyDetailsParametersPtrOutput) ToLifecyclePolicyPolicyDetailsParametersPtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsParametersPtrOutput) ToLifecyclePolicyPolicyDetailsParametersPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsParametersPtrOutput

type LifecyclePolicyPolicyDetailsPtrInput 

type LifecyclePolicyPolicyDetailsPtrInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsPtrOutput() LifecyclePolicyPolicyDetailsPtrOutput
	ToLifecyclePolicyPolicyDetailsPtrOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsPtrOutput
}

LifecyclePolicyPolicyDetailsPtrInput is an input type that accepts LifecyclePolicyPolicyDetailsArgs, LifecyclePolicyPolicyDetailsPtr and LifecyclePolicyPolicyDetailsPtrOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsPtrInput` via: 

        LifecyclePolicyPolicyDetailsArgs{...}

or:

        nil

func LifecyclePolicyPolicyDetailsPtr 

func LifecyclePolicyPolicyDetailsPtr(v *LifecyclePolicyPolicyDetailsArgs) LifecyclePolicyPolicyDetailsPtrInput

type LifecyclePolicyPolicyDetailsPtrOutput 

type LifecyclePolicyPolicyDetailsPtrOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsPtrOutput) Action 

func (o LifecyclePolicyPolicyDetailsPtrOutput) Action() LifecyclePolicyPolicyDetailsActionPtrOutput

The actions to be performed when the event-based policy is triggered. You can specify only one action per policy. This parameter is required for event-based policies only. If you are creating a snapshot or AMI policy, omit this parameter. See the `action` configuration block.

func (LifecyclePolicyPolicyDetailsPtrOutput) Elem 

func (o LifecyclePolicyPolicyDetailsPtrOutput) Elem() LifecyclePolicyPolicyDetailsOutput

func (LifecyclePolicyPolicyDetailsPtrOutput) ElementType 

func (LifecyclePolicyPolicyDetailsPtrOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsPtrOutput) EventSource 

func (o LifecyclePolicyPolicyDetailsPtrOutput) EventSource() LifecyclePolicyPolicyDetailsEventSourcePtrOutput

The event that triggers the event-based policy. This parameter is required for event-based policies only. If you are creating a snapshot or AMI policy, omit this parameter. See the `eventSource` configuration block.

func (LifecyclePolicyPolicyDetailsPtrOutput) Parameters 

func (o LifecyclePolicyPolicyDetailsPtrOutput) Parameters() LifecyclePolicyPolicyDetailsParametersPtrOutput

Information about the event. See the `parameters` configuration block.

func (LifecyclePolicyPolicyDetailsPtrOutput) PolicyType 

func (o LifecyclePolicyPolicyDetailsPtrOutput) PolicyType() pulumi.StringPtrOutput

The valid target resource types and actions a policy can manage. Specify `EBS_SNAPSHOT_MANAGEMENT` to create a lifecycle policy that manages the lifecycle of Amazon EBS snapshots. Specify `IMAGE_MANAGEMENT` to create a lifecycle policy that manages the lifecycle of EBS-backed AMIs. Specify `EVENT_BASED_POLICY` to create an event-based policy that performs specific actions when a defined event occurs in your AWS account. Default value is `EBS_SNAPSHOT_MANAGEMENT`.

func (LifecyclePolicyPolicyDetailsPtrOutput) ResourceLocations 

func (o LifecyclePolicyPolicyDetailsPtrOutput) ResourceLocations() pulumi.StringPtrOutput

The location of the resources to backup. If the source resources are located in an AWS Region, specify `CLOUD`. If the source resources are located on an Outpost in your account, specify `OUTPOST`. If you specify `OUTPOST`, Amazon Data Lifecycle Manager backs up all resources of the specified type with matching target tags across all of the Outposts in your account. Valid values are `CLOUD` and `OUTPOST`.

func (LifecyclePolicyPolicyDetailsPtrOutput) ResourceTypes 

func (o LifecyclePolicyPolicyDetailsPtrOutput) ResourceTypes() pulumi.StringArrayOutput

A list of resource types that should be targeted by the lifecycle policy. Valid values are `VOLUME` and `INSTANCE`.

func (LifecyclePolicyPolicyDetailsPtrOutput) Schedules 

func (o LifecyclePolicyPolicyDetailsPtrOutput) Schedules() LifecyclePolicyPolicyDetailsScheduleArrayOutput

See the `schedule` configuration block.

func (LifecyclePolicyPolicyDetailsPtrOutput) TargetTags 

func (o LifecyclePolicyPolicyDetailsPtrOutput) TargetTags() pulumi.StringMapOutput

A map of tag keys and their values. Any resources that match the `resourceTypes` and are tagged with _any_ of these tags will be targeted.

> Note: You cannot have overlapping lifecycle policies that share the same `targetTags`. Pulumi is unable to detect this at plan time but it will fail during apply.

func (LifecyclePolicyPolicyDetailsPtrOutput) ToLifecyclePolicyPolicyDetailsPtrOutput 

func (o LifecyclePolicyPolicyDetailsPtrOutput) ToLifecyclePolicyPolicyDetailsPtrOutput() LifecyclePolicyPolicyDetailsPtrOutput

func (LifecyclePolicyPolicyDetailsPtrOutput) ToLifecyclePolicyPolicyDetailsPtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsPtrOutput) ToLifecyclePolicyPolicyDetailsPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsPtrOutput

type LifecyclePolicyPolicyDetailsSchedule 

type LifecyclePolicyPolicyDetailsSchedule struct {
	// Whether to copy all user-defined tags from the source snapshot to the cross-region snapshot copy.
	CopyTags *bool `pulumi:"copyTags"`
	// See the `createRule` block. Max of 1 per schedule.
	CreateRule LifecyclePolicyPolicyDetailsScheduleCreateRule `pulumi:"createRule"`
	// See the `crossRegionCopyRule` block. Max of 3 per schedule.
	CrossRegionCopyRules []LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRule `pulumi:"crossRegionCopyRules"`
	// The AMI deprecation rule for cross-Region AMI copies created by the rule. See the `deprecateRule` block.
	DeprecateRule *LifecyclePolicyPolicyDetailsScheduleDeprecateRule `pulumi:"deprecateRule"`
	// See the `fastRestoreRule` block. Max of 1 per schedule.
	FastRestoreRule *LifecyclePolicyPolicyDetailsScheduleFastRestoreRule `pulumi:"fastRestoreRule"`
	// A descriptive name for the action.
	Name string `pulumi:"name"`
	// Specifies the retention rule for cross-Region snapshot copies. See the `retainRule` block. Max of 1 per action.
	RetainRule LifecyclePolicyPolicyDetailsScheduleRetainRule `pulumi:"retainRule"`
	// See the `shareRule` block. Max of 1 per schedule.
	ShareRule *LifecyclePolicyPolicyDetailsScheduleShareRule `pulumi:"shareRule"`
	// A map of tag keys and their values. DLM lifecycle policies will already tag the snapshot with the tags on the volume. This configuration adds extra tags on top of these.
	TagsToAdd map[string]string `pulumi:"tagsToAdd"`
	// A map of tag keys and variable values, where the values are determined when the policy is executed. Only `$(instance-id)` or `$(timestamp)` are valid values. Can only be used when `resourceTypes` is `INSTANCE`.
	VariableTags map[string]string `pulumi:"variableTags"`
}

type LifecyclePolicyPolicyDetailsScheduleArgs 

type LifecyclePolicyPolicyDetailsScheduleArgs struct {
	// Whether to copy all user-defined tags from the source snapshot to the cross-region snapshot copy.
	CopyTags pulumi.BoolPtrInput `pulumi:"copyTags"`
	// See the `createRule` block. Max of 1 per schedule.
	CreateRule LifecyclePolicyPolicyDetailsScheduleCreateRuleInput `pulumi:"createRule"`
	// See the `crossRegionCopyRule` block. Max of 3 per schedule.
	CrossRegionCopyRules LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayInput `pulumi:"crossRegionCopyRules"`
	// The AMI deprecation rule for cross-Region AMI copies created by the rule. See the `deprecateRule` block.
	DeprecateRule LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrInput `pulumi:"deprecateRule"`
	// See the `fastRestoreRule` block. Max of 1 per schedule.
	FastRestoreRule LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrInput `pulumi:"fastRestoreRule"`
	// A descriptive name for the action.
	Name pulumi.StringInput `pulumi:"name"`
	// Specifies the retention rule for cross-Region snapshot copies. See the `retainRule` block. Max of 1 per action.
	RetainRule LifecyclePolicyPolicyDetailsScheduleRetainRuleInput `pulumi:"retainRule"`
	// See the `shareRule` block. Max of 1 per schedule.
	ShareRule LifecyclePolicyPolicyDetailsScheduleShareRulePtrInput `pulumi:"shareRule"`
	// A map of tag keys and their values. DLM lifecycle policies will already tag the snapshot with the tags on the volume. This configuration adds extra tags on top of these.
	TagsToAdd pulumi.StringMapInput `pulumi:"tagsToAdd"`
	// A map of tag keys and variable values, where the values are determined when the policy is executed. Only `$(instance-id)` or `$(timestamp)` are valid values. Can only be used when `resourceTypes` is `INSTANCE`.
	VariableTags pulumi.StringMapInput `pulumi:"variableTags"`
}

func (LifecyclePolicyPolicyDetailsScheduleArgs) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleArgs) ToLifecyclePolicyPolicyDetailsScheduleOutput 

func (i LifecyclePolicyPolicyDetailsScheduleArgs) ToLifecyclePolicyPolicyDetailsScheduleOutput() LifecyclePolicyPolicyDetailsScheduleOutput

func (LifecyclePolicyPolicyDetailsScheduleArgs) ToLifecyclePolicyPolicyDetailsScheduleOutputWithContext 

func (i LifecyclePolicyPolicyDetailsScheduleArgs) ToLifecyclePolicyPolicyDetailsScheduleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleOutput

type LifecyclePolicyPolicyDetailsScheduleArray 

type LifecyclePolicyPolicyDetailsScheduleArray []LifecyclePolicyPolicyDetailsScheduleInput

func (LifecyclePolicyPolicyDetailsScheduleArray) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleArray) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleArray) ToLifecyclePolicyPolicyDetailsScheduleArrayOutput 

func (i LifecyclePolicyPolicyDetailsScheduleArray) ToLifecyclePolicyPolicyDetailsScheduleArrayOutput() LifecyclePolicyPolicyDetailsScheduleArrayOutput

func (LifecyclePolicyPolicyDetailsScheduleArray) ToLifecyclePolicyPolicyDetailsScheduleArrayOutputWithContext 

func (i LifecyclePolicyPolicyDetailsScheduleArray) ToLifecyclePolicyPolicyDetailsScheduleArrayOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleArrayOutput

type LifecyclePolicyPolicyDetailsScheduleArrayInput 

type LifecyclePolicyPolicyDetailsScheduleArrayInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleArrayOutput() LifecyclePolicyPolicyDetailsScheduleArrayOutput
	ToLifecyclePolicyPolicyDetailsScheduleArrayOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleArrayOutput
}

LifecyclePolicyPolicyDetailsScheduleArrayInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleArray and LifecyclePolicyPolicyDetailsScheduleArrayOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleArrayInput` via: 

LifecyclePolicyPolicyDetailsScheduleArray{ LifecyclePolicyPolicyDetailsScheduleArgs{...} }

type LifecyclePolicyPolicyDetailsScheduleArrayOutput 

type LifecyclePolicyPolicyDetailsScheduleArrayOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleArrayOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleArrayOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleArrayOutput) Index 

func (o LifecyclePolicyPolicyDetailsScheduleArrayOutput) Index(i pulumi.IntInput) LifecyclePolicyPolicyDetailsScheduleOutput

func (LifecyclePolicyPolicyDetailsScheduleArrayOutput) ToLifecyclePolicyPolicyDetailsScheduleArrayOutput 

func (o LifecyclePolicyPolicyDetailsScheduleArrayOutput) ToLifecyclePolicyPolicyDetailsScheduleArrayOutput() LifecyclePolicyPolicyDetailsScheduleArrayOutput

func (LifecyclePolicyPolicyDetailsScheduleArrayOutput) ToLifecyclePolicyPolicyDetailsScheduleArrayOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleArrayOutput) ToLifecyclePolicyPolicyDetailsScheduleArrayOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleArrayOutput

type LifecyclePolicyPolicyDetailsScheduleCreateRule 

type LifecyclePolicyPolicyDetailsScheduleCreateRule struct {
	// The schedule, as a Cron expression. The schedule interval must be between 1 hour and 1 year. Conflicts with `interval`, `intervalUnit`, and `times`.
	CronExpression *string `pulumi:"cronExpression"`
	// How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.
	Interval *int `pulumi:"interval"`
	// The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.
	IntervalUnit *string `pulumi:"intervalUnit"`
	// Specifies the destination for snapshots created by the policy. To create snapshots in the same Region as the source resource, specify `CLOUD`. To create snapshots on the same Outpost as the source resource, specify `OUTPOST_LOCAL`. If you omit this parameter, `CLOUD` is used by default. If the policy targets resources in an AWS Region, then you must create snapshots in the same Region as the source resource. If the policy targets resources on an Outpost, then you can create snapshots on the same Outpost as the source resource, or in the Region of that Outpost. Valid values are `CLOUD` and `OUTPOST_LOCAL`.
	Location *string `pulumi:"location"`
	// A list of times in 24 hour clock format that sets when the lifecycle policy should be evaluated. Max of 1. Conflicts with `cronExpression`. Must be set if `interval` is set.
	Times *string `pulumi:"times"`
}

type LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs 

type LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs struct {
	// The schedule, as a Cron expression. The schedule interval must be between 1 hour and 1 year. Conflicts with `interval`, `intervalUnit`, and `times`.
	CronExpression pulumi.StringPtrInput `pulumi:"cronExpression"`
	// How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.
	Interval pulumi.IntPtrInput `pulumi:"interval"`
	// The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.
	IntervalUnit pulumi.StringPtrInput `pulumi:"intervalUnit"`
	// Specifies the destination for snapshots created by the policy. To create snapshots in the same Region as the source resource, specify `CLOUD`. To create snapshots on the same Outpost as the source resource, specify `OUTPOST_LOCAL`. If you omit this parameter, `CLOUD` is used by default. If the policy targets resources in an AWS Region, then you must create snapshots in the same Region as the source resource. If the policy targets resources on an Outpost, then you can create snapshots on the same Outpost as the source resource, or in the Region of that Outpost. Valid values are `CLOUD` and `OUTPOST_LOCAL`.
	Location pulumi.StringPtrInput `pulumi:"location"`
	// A list of times in 24 hour clock format that sets when the lifecycle policy should be evaluated. Max of 1. Conflicts with `cronExpression`. Must be set if `interval` is set.
	Times pulumi.StringPtrInput `pulumi:"times"`
}

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleOutput 

func (i LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleOutput() LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleOutputWithContext 

func (i LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput

type LifecyclePolicyPolicyDetailsScheduleCreateRuleInput 

type LifecyclePolicyPolicyDetailsScheduleCreateRuleInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleCreateRuleOutput() LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput
	ToLifecyclePolicyPolicyDetailsScheduleCreateRuleOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput
}

LifecyclePolicyPolicyDetailsScheduleCreateRuleInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs and LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleCreateRuleInput` via: 

LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs{...}

type LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput 

type LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) CronExpression 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) CronExpression() pulumi.StringPtrOutput

The schedule, as a Cron expression. The schedule interval must be between 1 hour and 1 year. Conflicts with `interval`, `intervalUnit`, and `times`.

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) Interval 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) Interval() pulumi.IntPtrOutput

How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) IntervalUnit() pulumi.StringPtrOutput

The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) Location 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) Location() pulumi.StringPtrOutput

Specifies the destination for snapshots created by the policy. To create snapshots in the same Region as the source resource, specify `CLOUD`. To create snapshots on the same Outpost as the source resource, specify `OUTPOST_LOCAL`. If you omit this parameter, `CLOUD` is used by default. If the policy targets resources in an AWS Region, then you must create snapshots in the same Region as the source resource. If the policy targets resources on an Outpost, then you can create snapshots on the same Outpost as the source resource, or in the Region of that Outpost. Valid values are `CLOUD` and `OUTPOST_LOCAL`.

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) Times 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) Times() pulumi.StringPtrOutput

A list of times in 24 hour clock format that sets when the lifecycle policy should be evaluated. Max of 1. Conflicts with `cronExpression`. Must be set if `interval` is set.

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleOutput 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleOutput() LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRule 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRule struct {
	// The Amazon Resource Name (ARN) of the AWS KMS customer master key (CMK) to use for EBS encryption. If this argument is not specified, the default KMS key for the account is used.
	CmkArn *string `pulumi:"cmkArn"`
	// Whether to copy all user-defined tags from the source snapshot to the cross-region snapshot copy.
	CopyTags *bool `pulumi:"copyTags"`
	// The AMI deprecation rule for cross-Region AMI copies created by the rule. See the `deprecateRule` block.
	DeprecateRule *LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRule `pulumi:"deprecateRule"`
	// To encrypt a copy of an unencrypted snapshot if encryption by default is not enabled, enable encryption using this parameter. Copies of encrypted snapshots are encrypted, even if this parameter is false or if encryption by default is not enabled.
	Encrypted bool `pulumi:"encrypted"`
	// Specifies the retention rule for cross-Region snapshot copies. See the `retainRule` block. Max of 1 per action.
	RetainRule *LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRule `pulumi:"retainRule"`
	// The target Region or the Amazon Resource Name (ARN) of the target Outpost for the snapshot copies.
	Target string `pulumi:"target"`
}

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArgs 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArgs struct {
	// The Amazon Resource Name (ARN) of the AWS KMS customer master key (CMK) to use for EBS encryption. If this argument is not specified, the default KMS key for the account is used.
	CmkArn pulumi.StringPtrInput `pulumi:"cmkArn"`
	// Whether to copy all user-defined tags from the source snapshot to the cross-region snapshot copy.
	CopyTags pulumi.BoolPtrInput `pulumi:"copyTags"`
	// The AMI deprecation rule for cross-Region AMI copies created by the rule. See the `deprecateRule` block.
	DeprecateRule LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrInput `pulumi:"deprecateRule"`
	// To encrypt a copy of an unencrypted snapshot if encryption by default is not enabled, enable encryption using this parameter. Copies of encrypted snapshots are encrypted, even if this parameter is false or if encryption by default is not enabled.
	Encrypted pulumi.BoolInput `pulumi:"encrypted"`
	// Specifies the retention rule for cross-Region snapshot copies. See the `retainRule` block. Max of 1 per action.
	RetainRule LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrInput `pulumi:"retainRule"`
	// The target Region or the Amazon Resource Name (ARN) of the target Outpost for the snapshot copies.
	Target pulumi.StringInput `pulumi:"target"`
}

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArgs) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput 

func (i LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutputWithContext 

func (i LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArray 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArray []LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleInput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArray) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArray) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArray) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput 

func (i LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArray) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArray) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutputWithContext 

func (i LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArray) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayInput 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput
	ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput
}

LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArray and LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayInput` via: 

LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArray{ LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArgs{...} }

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput) Index 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput) Index(i pulumi.IntInput) LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRule 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRule struct {
	// How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.
	Interval int `pulumi:"interval"`
	// The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.
	IntervalUnit string `pulumi:"intervalUnit"`
}

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleArgs 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleArgs struct {
	// How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.
	Interval pulumi.IntInput `pulumi:"interval"`
	// The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.
	IntervalUnit pulumi.StringInput `pulumi:"intervalUnit"`
}

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleArgs) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput 

func (i LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutputWithContext 

func (i LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput 

func (i LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutputWithContext 

func (i LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleInput 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput
	ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput
}

LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleArgs and LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleInput` via: 

LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleArgs{...}

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput) Interval 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput) Interval() pulumi.IntOutput

How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput) IntervalUnit() pulumi.StringOutput

The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrInput 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput
	ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput
}

LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleArgs, LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtr and LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrInput` via: 

        LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleArgs{...}

or:

        nil

func LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtr 

func LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtr(v *LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleArgs) LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrInput

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput) Elem 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput) Elem() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput) Interval 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput) Interval() pulumi.IntPtrOutput

How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput) IntervalUnit() pulumi.StringPtrOutput

The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleInput 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput
	ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput
}

LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArgs and LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleInput` via: 

LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArgs{...}

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) CmkArn 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) CmkArn() pulumi.StringPtrOutput

The Amazon Resource Name (ARN) of the AWS KMS customer master key (CMK) to use for EBS encryption. If this argument is not specified, the default KMS key for the account is used.

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) CopyTags 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) CopyTags() pulumi.BoolPtrOutput

Whether to copy all user-defined tags from the source snapshot to the cross-region snapshot copy.

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) DeprecateRule 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) DeprecateRule() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput

The AMI deprecation rule for cross-Region AMI copies created by the rule. See the `deprecateRule` block.

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) Encrypted 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) Encrypted() pulumi.BoolOutput

To encrypt a copy of an unencrypted snapshot if encryption by default is not enabled, enable encryption using this parameter. Copies of encrypted snapshots are encrypted, even if this parameter is false or if encryption by default is not enabled.

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) RetainRule 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) RetainRule() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput

Specifies the retention rule for cross-Region snapshot copies. See the `retainRule` block. Max of 1 per action.

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) Target 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) Target() pulumi.StringOutput

The target Region or the Amazon Resource Name (ARN) of the target Outpost for the snapshot copies.

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRule 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRule struct {
	// How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.
	Interval int `pulumi:"interval"`
	// The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.
	IntervalUnit string `pulumi:"intervalUnit"`
}

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleArgs 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleArgs struct {
	// How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.
	Interval pulumi.IntInput `pulumi:"interval"`
	// The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.
	IntervalUnit pulumi.StringInput `pulumi:"intervalUnit"`
}

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleArgs) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput 

func (i LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutputWithContext 

func (i LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput 

func (i LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutputWithContext 

func (i LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleInput 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput
	ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput
}

LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleArgs and LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleInput` via: 

LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleArgs{...}

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput) Interval 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput) Interval() pulumi.IntOutput

How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput) IntervalUnit() pulumi.StringOutput

The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrInput 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput
	ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput
}

LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleArgs, LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtr and LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrInput` via: 

        LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleArgs{...}

or:

        nil

func LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtr 

func LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtr(v *LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleArgs) LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrInput

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput) Elem 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput) Elem() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput) Interval 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput) Interval() pulumi.IntPtrOutput

How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput) IntervalUnit() pulumi.StringPtrOutput

The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput

type LifecyclePolicyPolicyDetailsScheduleDeprecateRule 

type LifecyclePolicyPolicyDetailsScheduleDeprecateRule struct {
	// Specifies the number of oldest AMIs to deprecate. Must be an integer between `1` and `1000`. Conflicts with `interval` and `intervalUnit`.
	Count *int `pulumi:"count"`
	// How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.
	Interval *int `pulumi:"interval"`
	// The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.
	IntervalUnit *string `pulumi:"intervalUnit"`
}

type LifecyclePolicyPolicyDetailsScheduleDeprecateRuleArgs 

type LifecyclePolicyPolicyDetailsScheduleDeprecateRuleArgs struct {
	// Specifies the number of oldest AMIs to deprecate. Must be an integer between `1` and `1000`. Conflicts with `interval` and `intervalUnit`.
	Count pulumi.IntPtrInput `pulumi:"count"`
	// How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.
	Interval pulumi.IntPtrInput `pulumi:"interval"`
	// The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.
	IntervalUnit pulumi.StringPtrInput `pulumi:"intervalUnit"`
}

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRuleArgs) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRuleArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput 

func (i LifecyclePolicyPolicyDetailsScheduleDeprecateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput() LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutputWithContext 

func (i LifecyclePolicyPolicyDetailsScheduleDeprecateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput 

func (i LifecyclePolicyPolicyDetailsScheduleDeprecateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutputWithContext 

func (i LifecyclePolicyPolicyDetailsScheduleDeprecateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput

type LifecyclePolicyPolicyDetailsScheduleDeprecateRuleInput 

type LifecyclePolicyPolicyDetailsScheduleDeprecateRuleInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput() LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput
	ToLifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput
}

LifecyclePolicyPolicyDetailsScheduleDeprecateRuleInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleDeprecateRuleArgs and LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleDeprecateRuleInput` via: 

LifecyclePolicyPolicyDetailsScheduleDeprecateRuleArgs{...}

type LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput 

type LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput) Count 

func (o LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput) Count() pulumi.IntPtrOutput

Specifies the number of oldest AMIs to deprecate. Must be an integer between `1` and `1000`. Conflicts with `interval` and `intervalUnit`.

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput) Interval 

func (o LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput) Interval() pulumi.IntPtrOutput

How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput) IntervalUnit() pulumi.StringPtrOutput

The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput 

func (o LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput() LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput 

func (o LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput

type LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrInput 

type LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput
	ToLifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput
}

LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleDeprecateRuleArgs, LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtr and LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrInput` via: 

        LifecyclePolicyPolicyDetailsScheduleDeprecateRuleArgs{...}

or:

        nil

func LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtr 

func LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtr(v *LifecyclePolicyPolicyDetailsScheduleDeprecateRuleArgs) LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrInput

type LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput 

type LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput) Count 

func (o LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput) Count() pulumi.IntPtrOutput

Specifies the number of oldest AMIs to deprecate. Must be an integer between `1` and `1000`. Conflicts with `interval` and `intervalUnit`.

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput) Elem 

func (o LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput) Elem() LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput) Interval 

func (o LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput) Interval() pulumi.IntPtrOutput

How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput) IntervalUnit() pulumi.StringPtrOutput

The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput 

func (o LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput

type LifecyclePolicyPolicyDetailsScheduleFastRestoreRule 

type LifecyclePolicyPolicyDetailsScheduleFastRestoreRule struct {
	// The Availability Zones in which to enable fast snapshot restore.
	AvailabilityZones []string `pulumi:"availabilityZones"`
	// Specifies the number of oldest AMIs to deprecate. Must be an integer between `1` and `1000`. Conflicts with `interval` and `intervalUnit`.
	Count *int `pulumi:"count"`
	// How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.
	Interval *int `pulumi:"interval"`
	// The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.
	IntervalUnit *string `pulumi:"intervalUnit"`
}

type LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleArgs 

type LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleArgs struct {
	// The Availability Zones in which to enable fast snapshot restore.
	AvailabilityZones pulumi.StringArrayInput `pulumi:"availabilityZones"`
	// Specifies the number of oldest AMIs to deprecate. Must be an integer between `1` and `1000`. Conflicts with `interval` and `intervalUnit`.
	Count pulumi.IntPtrInput `pulumi:"count"`
	// How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.
	Interval pulumi.IntPtrInput `pulumi:"interval"`
	// The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.
	IntervalUnit pulumi.StringPtrInput `pulumi:"intervalUnit"`
}

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleArgs) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput 

func (i LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput() LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutputWithContext 

func (i LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput 

func (i LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutputWithContext 

func (i LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput

type LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleInput 

type LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput() LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput
	ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput
}

LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleArgs and LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleInput` via: 

LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleArgs{...}

type LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput 

type LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) AvailabilityZones 

func (o LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) AvailabilityZones() pulumi.StringArrayOutput

The Availability Zones in which to enable fast snapshot restore.

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) Count 

func (o LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) Count() pulumi.IntPtrOutput

Specifies the number of oldest AMIs to deprecate. Must be an integer between `1` and `1000`. Conflicts with `interval` and `intervalUnit`.

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) Interval 

func (o LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) Interval() pulumi.IntPtrOutput

How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) IntervalUnit() pulumi.StringPtrOutput

The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput 

func (o LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput() LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput 

func (o LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput

type LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrInput 

type LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput
	ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput
}

LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleArgs, LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtr and LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrInput` via: 

        LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleArgs{...}

or:

        nil

func LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtr 

func LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtr(v *LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleArgs) LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrInput

type LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput 

type LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput) AvailabilityZones 

func (o LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput) AvailabilityZones() pulumi.StringArrayOutput

The Availability Zones in which to enable fast snapshot restore.

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput) Count 

func (o LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput) Count() pulumi.IntPtrOutput

Specifies the number of oldest AMIs to deprecate. Must be an integer between `1` and `1000`. Conflicts with `interval` and `intervalUnit`.

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput) Elem 

func (o LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput) Elem() LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput) Interval 

func (o LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput) Interval() pulumi.IntPtrOutput

How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput) IntervalUnit() pulumi.StringPtrOutput

The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput 

func (o LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput

type LifecyclePolicyPolicyDetailsScheduleInput 

type LifecyclePolicyPolicyDetailsScheduleInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleOutput() LifecyclePolicyPolicyDetailsScheduleOutput
	ToLifecyclePolicyPolicyDetailsScheduleOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleOutput
}

LifecyclePolicyPolicyDetailsScheduleInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleArgs and LifecyclePolicyPolicyDetailsScheduleOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleInput` via: 

LifecyclePolicyPolicyDetailsScheduleArgs{...}

type LifecyclePolicyPolicyDetailsScheduleOutput 

type LifecyclePolicyPolicyDetailsScheduleOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleOutput) CopyTags 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) CopyTags() pulumi.BoolPtrOutput

Whether to copy all user-defined tags from the source snapshot to the cross-region snapshot copy.

func (LifecyclePolicyPolicyDetailsScheduleOutput) CreateRule 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) CreateRule() LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput

See the `createRule` block. Max of 1 per schedule.

func (LifecyclePolicyPolicyDetailsScheduleOutput) CrossRegionCopyRules 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) CrossRegionCopyRules() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput

See the `crossRegionCopyRule` block. Max of 3 per schedule.

func (LifecyclePolicyPolicyDetailsScheduleOutput) DeprecateRule 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) DeprecateRule() LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput

The AMI deprecation rule for cross-Region AMI copies created by the rule. See the `deprecateRule` block.

func (LifecyclePolicyPolicyDetailsScheduleOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleOutput) FastRestoreRule 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) FastRestoreRule() LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput

See the `fastRestoreRule` block. Max of 1 per schedule.

func (LifecyclePolicyPolicyDetailsScheduleOutput) Name 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) Name() pulumi.StringOutput

A descriptive name for the action.

func (LifecyclePolicyPolicyDetailsScheduleOutput) RetainRule 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) RetainRule() LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput

Specifies the retention rule for cross-Region snapshot copies. See the `retainRule` block. Max of 1 per action.

func (LifecyclePolicyPolicyDetailsScheduleOutput) ShareRule 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) ShareRule() LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput

See the `shareRule` block. Max of 1 per schedule.

func (LifecyclePolicyPolicyDetailsScheduleOutput) TagsToAdd 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) TagsToAdd() pulumi.StringMapOutput

A map of tag keys and their values. DLM lifecycle policies will already tag the snapshot with the tags on the volume. This configuration adds extra tags on top of these.

func (LifecyclePolicyPolicyDetailsScheduleOutput) ToLifecyclePolicyPolicyDetailsScheduleOutput 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) ToLifecyclePolicyPolicyDetailsScheduleOutput() LifecyclePolicyPolicyDetailsScheduleOutput

func (LifecyclePolicyPolicyDetailsScheduleOutput) ToLifecyclePolicyPolicyDetailsScheduleOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) ToLifecyclePolicyPolicyDetailsScheduleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleOutput

func (LifecyclePolicyPolicyDetailsScheduleOutput) VariableTags 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) VariableTags() pulumi.StringMapOutput

A map of tag keys and variable values, where the values are determined when the policy is executed. Only `$(instance-id)` or `$(timestamp)` are valid values. Can only be used when `resourceTypes` is `INSTANCE`.

type LifecyclePolicyPolicyDetailsScheduleRetainRule 

type LifecyclePolicyPolicyDetailsScheduleRetainRule struct {
	// Specifies the number of oldest AMIs to deprecate. Must be an integer between `1` and `1000`. Conflicts with `interval` and `intervalUnit`.
	Count *int `pulumi:"count"`
	// How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.
	Interval *int `pulumi:"interval"`
	// The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.
	IntervalUnit *string `pulumi:"intervalUnit"`
}

type LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs 

type LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs struct {
	// Specifies the number of oldest AMIs to deprecate. Must be an integer between `1` and `1000`. Conflicts with `interval` and `intervalUnit`.
	Count pulumi.IntPtrInput `pulumi:"count"`
	// How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.
	Interval pulumi.IntPtrInput `pulumi:"interval"`
	// The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.
	IntervalUnit pulumi.StringPtrInput `pulumi:"intervalUnit"`
}

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleRetainRuleOutput 

func (i LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleRetainRuleOutput() LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleRetainRuleOutputWithContext 

func (i LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleRetainRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput

type LifecyclePolicyPolicyDetailsScheduleRetainRuleInput 

type LifecyclePolicyPolicyDetailsScheduleRetainRuleInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleRetainRuleOutput() LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput
	ToLifecyclePolicyPolicyDetailsScheduleRetainRuleOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput
}

LifecyclePolicyPolicyDetailsScheduleRetainRuleInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs and LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleRetainRuleInput` via: 

LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs{...}

type LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput 

type LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) Count 

func (o LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) Count() pulumi.IntPtrOutput

Specifies the number of oldest AMIs to deprecate. Must be an integer between `1` and `1000`. Conflicts with `interval` and `intervalUnit`.

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) Interval 

func (o LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) Interval() pulumi.IntPtrOutput

How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values. Conflicts with `cronExpression`. If set, `intervalUnit` and `times` must also be set.

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) IntervalUnit() pulumi.StringPtrOutput

The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value. Conflicts with `cronExpression`. Must be set if `interval` is set.

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleRetainRuleOutput 

func (o LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleRetainRuleOutput() LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleRetainRuleOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleRetainRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput

type LifecyclePolicyPolicyDetailsScheduleShareRule 

type LifecyclePolicyPolicyDetailsScheduleShareRule struct {
	// The IDs of the AWS accounts with which to share the snapshots.
	TargetAccounts      []string `pulumi:"targetAccounts"`
	UnshareInterval     *int     `pulumi:"unshareInterval"`
	UnshareIntervalUnit *string  `pulumi:"unshareIntervalUnit"`
}

type LifecyclePolicyPolicyDetailsScheduleShareRuleArgs 

type LifecyclePolicyPolicyDetailsScheduleShareRuleArgs struct {
	// The IDs of the AWS accounts with which to share the snapshots.
	TargetAccounts      pulumi.StringArrayInput `pulumi:"targetAccounts"`
	UnshareInterval     pulumi.IntPtrInput      `pulumi:"unshareInterval"`
	UnshareIntervalUnit pulumi.StringPtrInput   `pulumi:"unshareIntervalUnit"`
}

func (LifecyclePolicyPolicyDetailsScheduleShareRuleArgs) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleShareRuleArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleShareRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleShareRuleOutput 

func (i LifecyclePolicyPolicyDetailsScheduleShareRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleShareRuleOutput() LifecyclePolicyPolicyDetailsScheduleShareRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleShareRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleShareRuleOutputWithContext 

func (i LifecyclePolicyPolicyDetailsScheduleShareRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleShareRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleShareRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleShareRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput 

func (i LifecyclePolicyPolicyDetailsScheduleShareRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleShareRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleShareRulePtrOutputWithContext 

func (i LifecyclePolicyPolicyDetailsScheduleShareRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleShareRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput

type LifecyclePolicyPolicyDetailsScheduleShareRuleInput 

type LifecyclePolicyPolicyDetailsScheduleShareRuleInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleShareRuleOutput() LifecyclePolicyPolicyDetailsScheduleShareRuleOutput
	ToLifecyclePolicyPolicyDetailsScheduleShareRuleOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleShareRuleOutput
}

LifecyclePolicyPolicyDetailsScheduleShareRuleInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleShareRuleArgs and LifecyclePolicyPolicyDetailsScheduleShareRuleOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleShareRuleInput` via: 

LifecyclePolicyPolicyDetailsScheduleShareRuleArgs{...}

type LifecyclePolicyPolicyDetailsScheduleShareRuleOutput 

type LifecyclePolicyPolicyDetailsScheduleShareRuleOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) TargetAccounts 

func (o LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) TargetAccounts() pulumi.StringArrayOutput

The IDs of the AWS accounts with which to share the snapshots.

func (LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleShareRuleOutput 

func (o LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleShareRuleOutput() LifecyclePolicyPolicyDetailsScheduleShareRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleShareRuleOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleShareRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleShareRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput 

func (o LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleShareRulePtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleShareRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) UnshareInterval 

func (o LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) UnshareInterval() pulumi.IntPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) UnshareIntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) UnshareIntervalUnit() pulumi.StringPtrOutput

type LifecyclePolicyPolicyDetailsScheduleShareRulePtrInput 

type LifecyclePolicyPolicyDetailsScheduleShareRulePtrInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput
	ToLifecyclePolicyPolicyDetailsScheduleShareRulePtrOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput
}

LifecyclePolicyPolicyDetailsScheduleShareRulePtrInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleShareRuleArgs, LifecyclePolicyPolicyDetailsScheduleShareRulePtr and LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleShareRulePtrInput` via: 

        LifecyclePolicyPolicyDetailsScheduleShareRuleArgs{...}

or:

        nil

func LifecyclePolicyPolicyDetailsScheduleShareRulePtr 

func LifecyclePolicyPolicyDetailsScheduleShareRulePtr(v *LifecyclePolicyPolicyDetailsScheduleShareRuleArgs) LifecyclePolicyPolicyDetailsScheduleShareRulePtrInput

type LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput 

type LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) Elem 

func (o LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) Elem() LifecyclePolicyPolicyDetailsScheduleShareRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) TargetAccounts 

func (o LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) TargetAccounts() pulumi.StringArrayOutput

The IDs of the AWS accounts with which to share the snapshots.

func (LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput 

func (o LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleShareRulePtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleShareRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) UnshareInterval 

func (o LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) UnshareInterval() pulumi.IntPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) UnshareIntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) UnshareIntervalUnit() pulumi.StringPtrOutput

type LifecyclePolicyState 

type LifecyclePolicyState struct {
	// Amazon Resource Name (ARN) of the DLM Lifecycle Policy.
	Arn pulumi.StringPtrInput
	// A description for the DLM lifecycle policy.
	Description pulumi.StringPtrInput
	// The ARN of an IAM role that is able to be assumed by the DLM service.
	ExecutionRoleArn pulumi.StringPtrInput
	// See the `policyDetails` configuration block. Max of 1.
	PolicyDetails LifecyclePolicyPolicyDetailsPtrInput
	// Whether the lifecycle policy should be enabled or disabled. `ENABLED` or `DISABLED` are valid values. Defaults to `ENABLED`.
	State pulumi.StringPtrInput
	// Key-value map of resource tags. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	//
	// Deprecated: Please use `tags` instead.
	TagsAll pulumi.StringMapInput
}

func (LifecyclePolicyState) ElementType 

func (LifecyclePolicyState) 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.