dlm

package
v7.9.0 Latest Latest
Warning

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

 Go to latest Published: Oct 22, 2025 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"`
	// Specify the type of default policy to create. valid values are `VOLUME` or `INSTANCE`.
	DefaultPolicy pulumi.StringPtrOutput `pulumi:"defaultPolicy"`
	// 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"`
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringOutput `pulumi:"region"`
	// 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.
	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

### Basic

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		assumeRole, err := iam.GetPolicyDocument(ctx, &iam.GetPolicyDocumentArgs{
			Statements: []iam.GetPolicyDocumentStatement{
				{
					Effect: pulumi.StringRef("Allow"),
					Principals: []iam.GetPolicyDocumentStatementPrincipal{
						{
							Type: "Service",
							Identifiers: []string{
								"dlm.amazonaws.com",
							},
						},
					},
					Actions: []string{
						"sts:AssumeRole",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		dlmLifecycleRole, err := iam.NewRole(ctx, "dlm_lifecycle_role", &iam.RoleArgs{
			Name:             pulumi.String("dlm-lifecycle-role"),
			AssumeRolePolicy: pulumi.String(assumeRole.Json),
		})
		if err != nil {
			return err
		}
		dlmLifecycle, err := iam.GetPolicyDocument(ctx, &iam.GetPolicyDocumentArgs{
			Statements: []iam.GetPolicyDocumentStatement{
				{
					Effect: pulumi.StringRef("Allow"),
					Actions: []string{
						"ec2:CreateSnapshot",
						"ec2:CreateSnapshots",
						"ec2:DeleteSnapshot",
						"ec2:DescribeInstances",
						"ec2:DescribeVolumes",
						"ec2:DescribeSnapshots",
					},
					Resources: []string{
						"*",
					},
				},
				{
					Effect: pulumi.StringRef("Allow"),
					Actions: []string{
						"ec2:CreateTags",
					},
					Resources: []string{
						"arn:aws:ec2:*::snapshot/*",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = iam.NewRolePolicy(ctx, "dlm_lifecycle", &iam.RolePolicyArgs{
			Name:   pulumi.String("dlm-lifecycle-policy"),
			Role:   dlmLifecycleRole.ID(),
			Policy: pulumi.String(dlmLifecycle.Json),
		})
		if err != nil {
			return err
		}
		_, err = dlm.NewLifecyclePolicy(ctx, "example", &dlm.LifecyclePolicyArgs{
			Description:      pulumi.String("example DLM lifecycle policy"),
			ExecutionRoleArn: dlmLifecycleRole.Arn,
			State:            pulumi.String("ENABLED"),
			PolicyDetails: &dlm.LifecyclePolicyPolicyDetailsArgs{
				ResourceTypes: pulumi.StringArray{
					pulumi.String("VOLUME"),
				},
				Schedules: dlm.LifecyclePolicyPolicyDetailsScheduleArray{
					&dlm.LifecyclePolicyPolicyDetailsScheduleArgs{
						Name: pulumi.String("2 weeks of daily snapshots"),
						CreateRule: &dlm.LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs{
							Interval:     pulumi.Int(24),
							IntervalUnit: pulumi.String("HOURS"),
							Times:        pulumi.String("23:45"),
						},
						RetainRule: &dlm.LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs{
							Count: pulumi.Int(14),
						},
						TagsToAdd: pulumi.StringMap{
							"SnapshotCreator": pulumi.String("DLM"),
						},
						CopyTags: pulumi.Bool(false),
					},
				},
				TargetTags: pulumi.StringMap{
					"Snapshot": pulumi.String("true"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

### Example Default Policy

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dlm.NewLifecyclePolicy(ctx, "example", &dlm.LifecyclePolicyArgs{
			Description:      pulumi.String("tf-acc-basic"),
			ExecutionRoleArn: pulumi.Any(exampleAwsIamRole.Arn),
			DefaultPolicy:    pulumi.String("VOLUME"),
			PolicyDetails: &dlm.LifecyclePolicyPolicyDetailsArgs{
				CreateInterval: pulumi.Int(5),
				ResourceType:   pulumi.String("VOLUME"),
				PolicyLanguage: pulumi.String("SIMPLIFIED"),
				Exclusions: &dlm.LifecyclePolicyPolicyDetailsExclusionsArgs{
					ExcludeBootVolumes: pulumi.Bool(false),
					ExcludeTags: pulumi.StringMap{
						"test": pulumi.String("exclude"),
					},
					ExcludeVolumeTypes: pulumi.StringArray{
						pulumi.String("gp2"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

### Example Cross-Region Snapshot Copy Usage

```go package main

import ( 

"fmt"

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// ...other configuration...
		current, err := aws.GetCallerIdentity(ctx, &aws.GetCallerIdentityArgs{}, nil)
		if err != nil {
			return err
		}
		key, err := iam.GetPolicyDocument(ctx, &iam.GetPolicyDocumentArgs{
			Statements: []iam.GetPolicyDocumentStatement{
				{
					Sid:    pulumi.StringRef("Enable IAM User Permissions"),
					Effect: pulumi.StringRef("Allow"),
					Principals: []iam.GetPolicyDocumentStatementPrincipal{
						{
							Type: "AWS",
							Identifiers: []string{
								fmt.Sprintf("arn:aws:iam::%v:root", current.AccountId),
							},
						},
					},
					Actions: []string{
						"kms:*",
					},
					Resources: []string{
						"*",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		dlmCrossRegionCopyCmk, err := kms.NewKey(ctx, "dlm_cross_region_copy_cmk", &kms.KeyArgs{
			Description: pulumi.String("Example Alternate Region KMS Key"),
			Policy:      pulumi.String(key.Json),
		})
		if err != nil {
			return err
		}
		_, err = dlm.NewLifecyclePolicy(ctx, "example", &dlm.LifecyclePolicyArgs{
			Description:      pulumi.String("example DLM lifecycle policy"),
			ExecutionRoleArn: pulumi.Any(dlmLifecycleRole.Arn),
			State:            pulumi.String("ENABLED"),
			PolicyDetails: &dlm.LifecyclePolicyPolicyDetailsArgs{
				ResourceTypes: pulumi.StringArray{
					pulumi.String("VOLUME"),
				},
				Schedules: dlm.LifecyclePolicyPolicyDetailsScheduleArray{
					&dlm.LifecyclePolicyPolicyDetailsScheduleArgs{
						Name: pulumi.String("2 weeks of daily snapshots"),
						CreateRule: &dlm.LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs{
							Interval:     pulumi.Int(24),
							IntervalUnit: pulumi.String("HOURS"),
							Times:        pulumi.String("23:45"),
						},
						RetainRule: &dlm.LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs{
							Count: pulumi.Int(14),
						},
						TagsToAdd: pulumi.StringMap{
							"SnapshotCreator": pulumi.String("DLM"),
						},
						CopyTags: pulumi.Bool(false),
						CrossRegionCopyRules: dlm.LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArray{
							&dlm.LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArgs{
								Target:    pulumi.String("us-west-2"),
								Encrypted: pulumi.Bool(true),
								CmkArn:    dlmCrossRegionCopyCmk.Arn,
								CopyTags:  pulumi.Bool(true),
								RetainRule: &dlm.LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleArgs{
									Interval:     pulumi.Int(30),
									IntervalUnit: pulumi.String("DAYS"),
								},
							},
						},
					},
				},
				TargetTags: pulumi.StringMap{
					"Snapshot": pulumi.String("true"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

### Example Event Based Policy Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v7/go/aws"
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/dlm"
"github.com/pulumi/pulumi-aws/sdk/v7/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, &aws.GetCallerIdentityArgs{}, nil)
		if err != nil {
			return err
		}
		_, err = dlm.NewLifecyclePolicy(ctx, "example", &dlm.LifecyclePolicyArgs{
			Description:      pulumi.String("tf-acc-basic"),
			ExecutionRoleArn: pulumi.Any(exampleAwsIamRole.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: &dlm.LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationArgs{},
							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
		}
		example, err := iam.LookupPolicy(ctx, &iam.LookupPolicyArgs{
			Name: pulumi.StringRef("AWSDataLifecycleManagerServiceRole"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = iam.NewRolePolicyAttachment(ctx, "example", &iam.RolePolicyAttachmentArgs{
			Role:      pulumi.Any(exampleAwsIamRole.Id),
			PolicyArn: pulumi.String(example.Arn),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

### Example Post/Pre Scripts

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := iam.LookupPolicy(ctx, &iam.LookupPolicyArgs{
			Name: pulumi.StringRef("AWSDataLifecycleManagerSSMFullAccess"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = iam.NewRolePolicyAttachment(ctx, "example", &iam.RolePolicyAttachmentArgs{
			Role:      pulumi.Any(testAwsIamRole.Id),
			PolicyArn: pulumi.Any(exampleAwsIamPolicy.Arn),
		})
		if err != nil {
			return err
		}
		_, err = dlm.NewLifecyclePolicy(ctx, "example", &dlm.LifecyclePolicyArgs{
			Description:      pulumi.String("tf-acc-basic"),
			ExecutionRoleArn: pulumi.Any(exampleAwsIamRole.Arn),
			PolicyDetails: &dlm.LifecyclePolicyPolicyDetailsArgs{
				ResourceTypes: pulumi.StringArray{
					pulumi.String("INSTANCE"),
				},
				Schedules: dlm.LifecyclePolicyPolicyDetailsScheduleArray{
					&dlm.LifecyclePolicyPolicyDetailsScheduleArgs{
						Name: pulumi.String("Windows VSS"),
						CreateRule: &dlm.LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs{
							Interval: pulumi.Int(12),
							Scripts: &dlm.LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsArgs{
								ExecuteOperationOnScriptFailure: pulumi.Bool(false),
								ExecutionHandler:                pulumi.String("AWS_VSS_BACKUP"),
								MaximumRetryCount:               pulumi.Int(2),
							},
						},
						RetainRule: &dlm.LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs{
							Count: pulumi.Int(10),
						},
					},
				},
				TargetTags: pulumi.StringMap{
					"tag1": pulumi.String("Windows"),
				},
			},
		})
		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 {
	// Specify the type of default policy to create. valid values are `VOLUME` or `INSTANCE`.
	DefaultPolicy pulumi.StringPtrInput
	// 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
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput
	// 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) DefaultPolicy added in v7.7.0 

func (o LifecyclePolicyOutput) DefaultPolicy() pulumi.StringPtrOutput

Specify the type of default policy to create. valid values are `VOLUME` or `INSTANCE`.

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

func (o LifecyclePolicyOutput) Region() pulumi.StringOutput

Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.

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 

func (o LifecyclePolicyOutput) TagsAll() pulumi.StringMapOutput

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

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"`
	CopyTags *bool                               `pulumi:"copyTags"`
	// How often the policy should run and create snapshots or AMIs. valid values range from `1` to `7`. Default value is `1`.
	CreateInterval *int `pulumi:"createInterval"`
	// 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"`
	// Specifies exclusion parameters for volumes or instances for which you do not want to create snapshots or AMIs.  See the `exclusions` configuration block.
	Exclusions *LifecyclePolicyPolicyDetailsExclusions `pulumi:"exclusions"`
	// snapshot or AMI retention behavior for the policy if the source volume or instance is deleted, or if the policy enters the error, disabled, or deleted state. Default value is `false`.
	ExtendDeletion *bool                                   `pulumi:"extendDeletion"`
	Parameters     *LifecyclePolicyPolicyDetailsParameters `pulumi:"parameters"`
	// Type of policy to create. `SIMPLIFIED` To create a default policy. `STANDARD` To create a custom policy.
	PolicyLanguage *string `pulumi:"policyLanguage"`
	// 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 the source resources are located in a Local Zone, specify `LOCAL_ZONE`. Valid values are `CLOUD`, `LOCAL_ZONE`, and `OUTPOST`.
	ResourceLocations *string `pulumi:"resourceLocations"`
	// Type of default policy to create. Valid values are `VOLUME` and `INSTANCE`.
	ResourceType *string `pulumi:"resourceType"`
	// A list of resource types that should be targeted by the lifecycle policy. Valid values are `VOLUME` and `INSTANCE`.
	ResourceTypes []string `pulumi:"resourceTypes"`
	// Specifies how long the policy should retain snapshots or AMIs before deleting them. valid values range from `2` to `14`. Default value is `7`.
	RetainInterval *int `pulumi:"retainInterval"`
	// 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. Required when `policyType` is `EBS_SNAPSHOT_MANAGEMENT` or `IMAGE_MANAGEMENT`. Must not be specified when `policyType` is `EVENT_BASED_POLICY`.
	//
	// > 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"`
	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"`
	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"`
	RetainRule              *LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRule             `pulumi:"retainRule"`
	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"`
	RetainRule              LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrInput           `pulumi:"retainRule"`
	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 {
	CmkArn    *string `pulumi:"cmkArn"`
	Encrypted *bool   `pulumi:"encrypted"`
}

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationArgs 

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationArgs struct {
	CmkArn    pulumi.StringPtrInput `pulumi:"cmkArn"`
	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

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput) ElementType 

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput) Encrypted 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfigurationOutput) Encrypted() pulumi.BoolPtrOutput

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

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput) Target 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput) Target() pulumi.StringOutput

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput() LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyOutput) ToLifecyclePolicyPolicyDetailsActionCrossRegionCopyOutputWithContext 

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

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRule 

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRule struct {
	Interval     int    `pulumi:"interval"`
	IntervalUnit string `pulumi:"intervalUnit"`
}

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleArgs 

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleArgs struct {
	Interval     pulumi.IntInput    `pulumi:"interval"`
	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

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleOutput) IntervalUnit() pulumi.StringOutput

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

func (LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRulePtrOutput) IntervalUnit() pulumi.StringPtrOutput

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

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

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"`
	CopyTags pulumi.BoolPtrInput                        `pulumi:"copyTags"`
	// How often the policy should run and create snapshots or AMIs. valid values range from `1` to `7`. Default value is `1`.
	CreateInterval pulumi.IntPtrInput `pulumi:"createInterval"`
	// 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"`
	// Specifies exclusion parameters for volumes or instances for which you do not want to create snapshots or AMIs.  See the `exclusions` configuration block.
	Exclusions LifecyclePolicyPolicyDetailsExclusionsPtrInput `pulumi:"exclusions"`
	// snapshot or AMI retention behavior for the policy if the source volume or instance is deleted, or if the policy enters the error, disabled, or deleted state. Default value is `false`.
	ExtendDeletion pulumi.BoolPtrInput                            `pulumi:"extendDeletion"`
	Parameters     LifecyclePolicyPolicyDetailsParametersPtrInput `pulumi:"parameters"`
	// Type of policy to create. `SIMPLIFIED` To create a default policy. `STANDARD` To create a custom policy.
	PolicyLanguage pulumi.StringPtrInput `pulumi:"policyLanguage"`
	// 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 the source resources are located in a Local Zone, specify `LOCAL_ZONE`. Valid values are `CLOUD`, `LOCAL_ZONE`, and `OUTPOST`.
	ResourceLocations pulumi.StringPtrInput `pulumi:"resourceLocations"`
	// Type of default policy to create. Valid values are `VOLUME` and `INSTANCE`.
	ResourceType pulumi.StringPtrInput `pulumi:"resourceType"`
	// A list of resource types that should be targeted by the lifecycle policy. Valid values are `VOLUME` and `INSTANCE`.
	ResourceTypes pulumi.StringArrayInput `pulumi:"resourceTypes"`
	// Specifies how long the policy should retain snapshots or AMIs before deleting them. valid values range from `2` to `14`. Default value is `7`.
	RetainInterval pulumi.IntPtrInput `pulumi:"retainInterval"`
	// 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. Required when `policyType` is `EBS_SNAPSHOT_MANAGEMENT` or `IMAGE_MANAGEMENT`. Must not be specified when `policyType` is `EVENT_BASED_POLICY`.
	//
	// > 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 {
	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 {
	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

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

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 LifecyclePolicyPolicyDetailsExclusions added in v7.7.0 

type LifecyclePolicyPolicyDetailsExclusions struct {
	// Indicates whether to exclude volumes that are attached to instances as the boot volume. To exclude boot volumes, specify `true`.
	ExcludeBootVolumes *bool `pulumi:"excludeBootVolumes"`
	// Map specifies whether to exclude volumes that have specific tags.
	ExcludeTags map[string]string `pulumi:"excludeTags"`
	// List specifies the volume types to exclude.
	ExcludeVolumeTypes []string `pulumi:"excludeVolumeTypes"`
}

type LifecyclePolicyPolicyDetailsExclusionsArgs added in v7.7.0 

type LifecyclePolicyPolicyDetailsExclusionsArgs struct {
	// Indicates whether to exclude volumes that are attached to instances as the boot volume. To exclude boot volumes, specify `true`.
	ExcludeBootVolumes pulumi.BoolPtrInput `pulumi:"excludeBootVolumes"`
	// Map specifies whether to exclude volumes that have specific tags.
	ExcludeTags pulumi.StringMapInput `pulumi:"excludeTags"`
	// List specifies the volume types to exclude.
	ExcludeVolumeTypes pulumi.StringArrayInput `pulumi:"excludeVolumeTypes"`
}

func (LifecyclePolicyPolicyDetailsExclusionsArgs) ElementType added in v7.7.0 

func (LifecyclePolicyPolicyDetailsExclusionsArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsExclusionsArgs) ToLifecyclePolicyPolicyDetailsExclusionsOutput added in v7.7.0 

func (i LifecyclePolicyPolicyDetailsExclusionsArgs) ToLifecyclePolicyPolicyDetailsExclusionsOutput() LifecyclePolicyPolicyDetailsExclusionsOutput

func (LifecyclePolicyPolicyDetailsExclusionsArgs) ToLifecyclePolicyPolicyDetailsExclusionsOutputWithContext added in v7.7.0 

func (i LifecyclePolicyPolicyDetailsExclusionsArgs) ToLifecyclePolicyPolicyDetailsExclusionsOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsExclusionsOutput

func (LifecyclePolicyPolicyDetailsExclusionsArgs) ToLifecyclePolicyPolicyDetailsExclusionsPtrOutput added in v7.7.0 

func (i LifecyclePolicyPolicyDetailsExclusionsArgs) ToLifecyclePolicyPolicyDetailsExclusionsPtrOutput() LifecyclePolicyPolicyDetailsExclusionsPtrOutput

func (LifecyclePolicyPolicyDetailsExclusionsArgs) ToLifecyclePolicyPolicyDetailsExclusionsPtrOutputWithContext added in v7.7.0 

func (i LifecyclePolicyPolicyDetailsExclusionsArgs) ToLifecyclePolicyPolicyDetailsExclusionsPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsExclusionsPtrOutput

type LifecyclePolicyPolicyDetailsExclusionsInput added in v7.7.0 

type LifecyclePolicyPolicyDetailsExclusionsInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsExclusionsOutput() LifecyclePolicyPolicyDetailsExclusionsOutput
	ToLifecyclePolicyPolicyDetailsExclusionsOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsExclusionsOutput
}

LifecyclePolicyPolicyDetailsExclusionsInput is an input type that accepts LifecyclePolicyPolicyDetailsExclusionsArgs and LifecyclePolicyPolicyDetailsExclusionsOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsExclusionsInput` via: 

LifecyclePolicyPolicyDetailsExclusionsArgs{...}

type LifecyclePolicyPolicyDetailsExclusionsOutput added in v7.7.0 

type LifecyclePolicyPolicyDetailsExclusionsOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsExclusionsOutput) ElementType added in v7.7.0 

func (LifecyclePolicyPolicyDetailsExclusionsOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsExclusionsOutput) ExcludeBootVolumes added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsExclusionsOutput) ExcludeBootVolumes() pulumi.BoolPtrOutput

Indicates whether to exclude volumes that are attached to instances as the boot volume. To exclude boot volumes, specify `true`.

func (LifecyclePolicyPolicyDetailsExclusionsOutput) ExcludeTags added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsExclusionsOutput) ExcludeTags() pulumi.StringMapOutput

Map specifies whether to exclude volumes that have specific tags.

func (LifecyclePolicyPolicyDetailsExclusionsOutput) ExcludeVolumeTypes added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsExclusionsOutput) ExcludeVolumeTypes() pulumi.StringArrayOutput

List specifies the volume types to exclude.

func (LifecyclePolicyPolicyDetailsExclusionsOutput) ToLifecyclePolicyPolicyDetailsExclusionsOutput added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsExclusionsOutput) ToLifecyclePolicyPolicyDetailsExclusionsOutput() LifecyclePolicyPolicyDetailsExclusionsOutput

func (LifecyclePolicyPolicyDetailsExclusionsOutput) ToLifecyclePolicyPolicyDetailsExclusionsOutputWithContext added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsExclusionsOutput) ToLifecyclePolicyPolicyDetailsExclusionsOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsExclusionsOutput

func (LifecyclePolicyPolicyDetailsExclusionsOutput) ToLifecyclePolicyPolicyDetailsExclusionsPtrOutput added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsExclusionsOutput) ToLifecyclePolicyPolicyDetailsExclusionsPtrOutput() LifecyclePolicyPolicyDetailsExclusionsPtrOutput

func (LifecyclePolicyPolicyDetailsExclusionsOutput) ToLifecyclePolicyPolicyDetailsExclusionsPtrOutputWithContext added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsExclusionsOutput) ToLifecyclePolicyPolicyDetailsExclusionsPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsExclusionsPtrOutput

type LifecyclePolicyPolicyDetailsExclusionsPtrInput added in v7.7.0 

type LifecyclePolicyPolicyDetailsExclusionsPtrInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsExclusionsPtrOutput() LifecyclePolicyPolicyDetailsExclusionsPtrOutput
	ToLifecyclePolicyPolicyDetailsExclusionsPtrOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsExclusionsPtrOutput
}

LifecyclePolicyPolicyDetailsExclusionsPtrInput is an input type that accepts LifecyclePolicyPolicyDetailsExclusionsArgs, LifecyclePolicyPolicyDetailsExclusionsPtr and LifecyclePolicyPolicyDetailsExclusionsPtrOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsExclusionsPtrInput` via: 

        LifecyclePolicyPolicyDetailsExclusionsArgs{...}

or:

        nil

func LifecyclePolicyPolicyDetailsExclusionsPtr added in v7.7.0 

func LifecyclePolicyPolicyDetailsExclusionsPtr(v *LifecyclePolicyPolicyDetailsExclusionsArgs) LifecyclePolicyPolicyDetailsExclusionsPtrInput

type LifecyclePolicyPolicyDetailsExclusionsPtrOutput added in v7.7.0 

type LifecyclePolicyPolicyDetailsExclusionsPtrOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsExclusionsPtrOutput) Elem added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsExclusionsPtrOutput) Elem() LifecyclePolicyPolicyDetailsExclusionsOutput

func (LifecyclePolicyPolicyDetailsExclusionsPtrOutput) ElementType added in v7.7.0 

func (LifecyclePolicyPolicyDetailsExclusionsPtrOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsExclusionsPtrOutput) ExcludeBootVolumes added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsExclusionsPtrOutput) ExcludeBootVolumes() pulumi.BoolPtrOutput

Indicates whether to exclude volumes that are attached to instances as the boot volume. To exclude boot volumes, specify `true`.

func (LifecyclePolicyPolicyDetailsExclusionsPtrOutput) ExcludeTags added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsExclusionsPtrOutput) ExcludeTags() pulumi.StringMapOutput

Map specifies whether to exclude volumes that have specific tags.

func (LifecyclePolicyPolicyDetailsExclusionsPtrOutput) ExcludeVolumeTypes added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsExclusionsPtrOutput) ExcludeVolumeTypes() pulumi.StringArrayOutput

List specifies the volume types to exclude.

func (LifecyclePolicyPolicyDetailsExclusionsPtrOutput) ToLifecyclePolicyPolicyDetailsExclusionsPtrOutput added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsExclusionsPtrOutput) ToLifecyclePolicyPolicyDetailsExclusionsPtrOutput() LifecyclePolicyPolicyDetailsExclusionsPtrOutput

func (LifecyclePolicyPolicyDetailsExclusionsPtrOutput) ToLifecyclePolicyPolicyDetailsExclusionsPtrOutputWithContext added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsExclusionsPtrOutput) ToLifecyclePolicyPolicyDetailsExclusionsPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsExclusionsPtrOutput

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) CopyTags added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsOutput) CopyTags() pulumi.BoolPtrOutput

func (LifecyclePolicyPolicyDetailsOutput) CreateInterval added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsOutput) CreateInterval() pulumi.IntPtrOutput

How often the policy should run and create snapshots or AMIs. valid values range from `1` to `7`. Default value is `1`.

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) Exclusions added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsOutput) Exclusions() LifecyclePolicyPolicyDetailsExclusionsPtrOutput

Specifies exclusion parameters for volumes or instances for which you do not want to create snapshots or AMIs. See the `exclusions` configuration block.

func (LifecyclePolicyPolicyDetailsOutput) ExtendDeletion added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsOutput) ExtendDeletion() pulumi.BoolPtrOutput

snapshot or AMI retention behavior for the policy if the source volume or instance is deleted, or if the policy enters the error, disabled, or deleted state. Default value is `false`.

func (LifecyclePolicyPolicyDetailsOutput) Parameters 

func (o LifecyclePolicyPolicyDetailsOutput) Parameters() LifecyclePolicyPolicyDetailsParametersPtrOutput

func (LifecyclePolicyPolicyDetailsOutput) PolicyLanguage added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsOutput) PolicyLanguage() pulumi.StringPtrOutput

Type of policy to create. `SIMPLIFIED` To create a default policy. `STANDARD` To create a custom policy.

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 the source resources are located in a Local Zone, specify `LOCAL_ZONE`. Valid values are `CLOUD`, `LOCAL_ZONE`, and `OUTPOST`.

func (LifecyclePolicyPolicyDetailsOutput) ResourceType added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsOutput) ResourceType() pulumi.StringPtrOutput

Type of default policy to create. Valid values are `VOLUME` and `INSTANCE`.

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) RetainInterval added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsOutput) RetainInterval() pulumi.IntPtrOutput

Specifies how long the policy should retain snapshots or AMIs before deleting them. valid values range from `2` to `14`. Default value is `7`.

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. Required when `policyType` is `EBS_SNAPSHOT_MANAGEMENT` or `IMAGE_MANAGEMENT`. Must not be specified when `policyType` is `EVENT_BASED_POLICY`.

> 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) CopyTags added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsPtrOutput) CopyTags() pulumi.BoolPtrOutput

func (LifecyclePolicyPolicyDetailsPtrOutput) CreateInterval added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsPtrOutput) CreateInterval() pulumi.IntPtrOutput

How often the policy should run and create snapshots or AMIs. valid values range from `1` to `7`. Default value is `1`.

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) Exclusions added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsPtrOutput) Exclusions() LifecyclePolicyPolicyDetailsExclusionsPtrOutput

Specifies exclusion parameters for volumes or instances for which you do not want to create snapshots or AMIs. See the `exclusions` configuration block.

func (LifecyclePolicyPolicyDetailsPtrOutput) ExtendDeletion added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsPtrOutput) ExtendDeletion() pulumi.BoolPtrOutput

snapshot or AMI retention behavior for the policy if the source volume or instance is deleted, or if the policy enters the error, disabled, or deleted state. Default value is `false`.

func (LifecyclePolicyPolicyDetailsPtrOutput) Parameters 

func (o LifecyclePolicyPolicyDetailsPtrOutput) Parameters() LifecyclePolicyPolicyDetailsParametersPtrOutput

func (LifecyclePolicyPolicyDetailsPtrOutput) PolicyLanguage added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsPtrOutput) PolicyLanguage() pulumi.StringPtrOutput

Type of policy to create. `SIMPLIFIED` To create a default policy. `STANDARD` To create a custom policy.

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 the source resources are located in a Local Zone, specify `LOCAL_ZONE`. Valid values are `CLOUD`, `LOCAL_ZONE`, and `OUTPOST`.

func (LifecyclePolicyPolicyDetailsPtrOutput) ResourceType added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsPtrOutput) ResourceType() pulumi.StringPtrOutput

Type of default policy to create. Valid values are `VOLUME` and `INSTANCE`.

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) RetainInterval added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsPtrOutput) RetainInterval() pulumi.IntPtrOutput

Specifies how long the policy should retain snapshots or AMIs before deleting them. valid values range from `2` to `14`. Default value is `7`.

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. Required when `policyType` is `EBS_SNAPSHOT_MANAGEMENT` or `IMAGE_MANAGEMENT`. Must not be specified when `policyType` is `EVENT_BASED_POLICY`.

> 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 {
	// Specifies a snapshot archiving rule for a schedule. See `archiveRule` block.
	ArchiveRule *LifecyclePolicyPolicyDetailsScheduleArchiveRule `pulumi:"archiveRule"`
	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"`
	DeprecateRule        *LifecyclePolicyPolicyDetailsScheduleDeprecateRule        `pulumi:"deprecateRule"`
	// See the `fastRestoreRule` block. Max of 1 per schedule.
	FastRestoreRule *LifecyclePolicyPolicyDetailsScheduleFastRestoreRule `pulumi:"fastRestoreRule"`
	Name            string                                               `pulumi:"name"`
	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 LifecyclePolicyPolicyDetailsScheduleArchiveRule added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleArchiveRule struct {
	// Information about the retention period for the snapshot archiving rule. See the `archiveRetainRule` block.
	ArchiveRetainRule LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRule `pulumi:"archiveRetainRule"`
}

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRule added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRule struct {
	// Information about retention period in the Amazon EBS Snapshots Archive. See the `retentionArchiveTier` block.
	RetentionArchiveTier LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTier `pulumi:"retentionArchiveTier"`
}

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleArgs added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleArgs struct {
	// Information about retention period in the Amazon EBS Snapshots Archive. See the `retentionArchiveTier` block.
	RetentionArchiveTier LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierInput `pulumi:"retentionArchiveTier"`
}

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleArgs) ElementType added in v7.7.0 

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput added in v7.7.0 

func (i LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput() LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutputWithContext added in v7.7.0 

func (i LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput added in v7.7.0 

func (i LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutputWithContext added in v7.7.0 

func (i LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleInput added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput() LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput
	ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput
}

LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleArgs and LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleInput` via: 

LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleArgs{...}

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput) ElementType added in v7.7.0 

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput) RetentionArchiveTier added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput) RetentionArchiveTier() LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput

Information about retention period in the Amazon EBS Snapshots Archive. See the `retentionArchiveTier` block.

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput() LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutputWithContext added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutputWithContext added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrInput added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput
	ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput
}

LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleArgs, LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtr and LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrInput` via: 

        LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleArgs{...}

or:

        nil

func LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtr added in v7.7.0 

func LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtr(v *LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleArgs) LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrInput

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput) Elem added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput) Elem() LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput) ElementType added in v7.7.0 

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput) RetentionArchiveTier added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput) RetentionArchiveTier() LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput

Information about retention period in the Amazon EBS Snapshots Archive. See the `retentionArchiveTier` block.

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutputWithContext added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTier added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTier struct {
	Count        *int    `pulumi:"count"`
	Interval     *int    `pulumi:"interval"`
	IntervalUnit *string `pulumi:"intervalUnit"`
}

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierArgs added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierArgs struct {
	Count        pulumi.IntPtrInput    `pulumi:"count"`
	Interval     pulumi.IntPtrInput    `pulumi:"interval"`
	IntervalUnit pulumi.StringPtrInput `pulumi:"intervalUnit"`
}

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierArgs) ElementType added in v7.7.0 

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput added in v7.7.0 

func (i LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput() LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutputWithContext added in v7.7.0 

func (i LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput added in v7.7.0 

func (i LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput() LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutputWithContext added in v7.7.0 

func (i LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierInput added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput() LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput
	ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput
}

LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierArgs and LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierInput` via: 

LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierArgs{...}

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput) Count added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput) Count() pulumi.IntPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput) ElementType added in v7.7.0 

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput) Interval added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput) Interval() pulumi.IntPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput) IntervalUnit added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput) IntervalUnit() pulumi.StringPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput() LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutputWithContext added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput() LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutputWithContext added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrInput added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput() LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput
	ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput
}

LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierArgs, LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtr and LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrInput` via: 

        LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierArgs{...}

or:

        nil

func LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtr added in v7.7.0 

func LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtr(v *LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierArgs) LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrInput

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput) Count added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput) Count() pulumi.IntPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput) Elem added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput) Elem() LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput) ElementType added in v7.7.0 

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput) Interval added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput) Interval() pulumi.IntPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput) IntervalUnit added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput) IntervalUnit() pulumi.StringPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput() LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutputWithContext added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleRetentionArchiveTierPtrOutput

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArgs added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleArgs struct {
	// Information about the retention period for the snapshot archiving rule. See the `archiveRetainRule` block.
	ArchiveRetainRule LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleInput `pulumi:"archiveRetainRule"`
}

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArgs) ElementType added in v7.7.0 

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput added in v7.7.0 

func (i LifecyclePolicyPolicyDetailsScheduleArchiveRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput() LifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleOutputWithContext added in v7.7.0 

func (i LifecyclePolicyPolicyDetailsScheduleArchiveRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput added in v7.7.0 

func (i LifecyclePolicyPolicyDetailsScheduleArchiveRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutputWithContext added in v7.7.0 

func (i LifecyclePolicyPolicyDetailsScheduleArchiveRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleInput added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput() LifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput
	ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput
}

LifecyclePolicyPolicyDetailsScheduleArchiveRuleInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleArchiveRuleArgs and LifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleArchiveRuleInput` via: 

LifecyclePolicyPolicyDetailsScheduleArchiveRuleArgs{...}

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput) ArchiveRetainRule added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput) ArchiveRetainRule() LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRuleOutput

Information about the retention period for the snapshot archiving rule. See the `archiveRetainRule` block.

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput) ElementType added in v7.7.0 

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput() LifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleOutputWithContext added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutputWithContext added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput

type LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrInput added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput
	ToLifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput
}

LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleArchiveRuleArgs, LifecyclePolicyPolicyDetailsScheduleArchiveRulePtr and LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrInput` via: 

        LifecyclePolicyPolicyDetailsScheduleArchiveRuleArgs{...}

or:

        nil

func LifecyclePolicyPolicyDetailsScheduleArchiveRulePtr added in v7.7.0 

func LifecyclePolicyPolicyDetailsScheduleArchiveRulePtr(v *LifecyclePolicyPolicyDetailsScheduleArchiveRuleArgs) LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrInput

type LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput) ArchiveRetainRule added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput) ArchiveRetainRule() LifecyclePolicyPolicyDetailsScheduleArchiveRuleArchiveRetainRulePtrOutput

Information about the retention period for the snapshot archiving rule. See the `archiveRetainRule` block.

func (LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput) Elem added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput) Elem() LifecyclePolicyPolicyDetailsScheduleArchiveRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput) ElementType added in v7.7.0 

func (LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutputWithContext added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput

type LifecyclePolicyPolicyDetailsScheduleArgs 

type LifecyclePolicyPolicyDetailsScheduleArgs struct {
	// Specifies a snapshot archiving rule for a schedule. See `archiveRule` block.
	ArchiveRule LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrInput `pulumi:"archiveRule"`
	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"`
	DeprecateRule        LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrInput         `pulumi:"deprecateRule"`
	// See the `fastRestoreRule` block. Max of 1 per schedule.
	FastRestoreRule LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrInput `pulumi:"fastRestoreRule"`
	Name            pulumi.StringInput                                          `pulumi:"name"`
	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"`
	Interval       *int    `pulumi:"interval"`
	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"`
	// Specifies pre and/or post scripts for a snapshot lifecycle policy that targets instances. Valid only when `resourceType` is INSTANCE. See the `scripts` configuration block.
	Scripts *LifecyclePolicyPolicyDetailsScheduleCreateRuleScripts `pulumi:"scripts"`
	// 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"`
	Interval       pulumi.IntPtrInput    `pulumi:"interval"`
	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"`
	// Specifies pre and/or post scripts for a snapshot lifecycle policy that targets instances. Valid only when `resourceType` is INSTANCE. See the `scripts` configuration block.
	Scripts LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrInput `pulumi:"scripts"`
	// 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

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) IntervalUnit() pulumi.StringPtrOutput

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) Scripts added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) Scripts() LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput

Specifies pre and/or post scripts for a snapshot lifecycle policy that targets instances. Valid only when `resourceType` is INSTANCE. See the `scripts` configuration block.

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 LifecyclePolicyPolicyDetailsScheduleCreateRuleScripts added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleCreateRuleScripts struct {
	// Indicates whether Amazon Data Lifecycle Manager should default to crash-consistent snapshots if the pre script fails. The default is `true`.
	ExecuteOperationOnScriptFailure *bool `pulumi:"executeOperationOnScriptFailure"`
	// The SSM document that includes the pre and/or post scripts to run. In case automating VSS backups, specify `AWS_VSS_BACKUP`. In case automating application-consistent snapshots for SAP HANA workloads, specify `AWSSystemsManagerSAP-CreateDLMSnapshotForSAPHANA`. If you are using a custom SSM document that you own, specify either the name or ARN of the SSM document.
	ExecutionHandler string `pulumi:"executionHandler"`
	// Indicates the service used to execute the pre and/or post scripts. If using custom SSM documents or automating application-consistent snapshots of SAP HANA workloads, specify `AWS_SYSTEMS_MANAGER`. In case automating VSS Backups, omit this parameter. The default is `AWS_SYSTEMS_MANAGER`.
	ExecutionHandlerService *string `pulumi:"executionHandlerService"`
	// Specifies a timeout period, in seconds, after which Amazon Data Lifecycle Manager fails the script run attempt if it has not completed. In case automating VSS Backups, omit this parameter. The default is `10`.
	ExecutionTimeout *int `pulumi:"executionTimeout"`
	// Specifies the number of times Amazon Data Lifecycle Manager should retry scripts that fail. Must be an integer between `0` and `3`. The default is `0`.
	MaximumRetryCount *int `pulumi:"maximumRetryCount"`
	// List to indicate which scripts Amazon Data Lifecycle Manager should run on target instances. Pre scripts run before Amazon Data Lifecycle Manager initiates snapshot creation. Post scripts run after Amazon Data Lifecycle Manager initiates snapshot creation. Valid values: `PRE` and `POST`. The default is `PRE` and `POST`
	Stages []string `pulumi:"stages"`
}

type LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsArgs added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsArgs struct {
	// Indicates whether Amazon Data Lifecycle Manager should default to crash-consistent snapshots if the pre script fails. The default is `true`.
	ExecuteOperationOnScriptFailure pulumi.BoolPtrInput `pulumi:"executeOperationOnScriptFailure"`
	// The SSM document that includes the pre and/or post scripts to run. In case automating VSS backups, specify `AWS_VSS_BACKUP`. In case automating application-consistent snapshots for SAP HANA workloads, specify `AWSSystemsManagerSAP-CreateDLMSnapshotForSAPHANA`. If you are using a custom SSM document that you own, specify either the name or ARN of the SSM document.
	ExecutionHandler pulumi.StringInput `pulumi:"executionHandler"`
	// Indicates the service used to execute the pre and/or post scripts. If using custom SSM documents or automating application-consistent snapshots of SAP HANA workloads, specify `AWS_SYSTEMS_MANAGER`. In case automating VSS Backups, omit this parameter. The default is `AWS_SYSTEMS_MANAGER`.
	ExecutionHandlerService pulumi.StringPtrInput `pulumi:"executionHandlerService"`
	// Specifies a timeout period, in seconds, after which Amazon Data Lifecycle Manager fails the script run attempt if it has not completed. In case automating VSS Backups, omit this parameter. The default is `10`.
	ExecutionTimeout pulumi.IntPtrInput `pulumi:"executionTimeout"`
	// Specifies the number of times Amazon Data Lifecycle Manager should retry scripts that fail. Must be an integer between `0` and `3`. The default is `0`.
	MaximumRetryCount pulumi.IntPtrInput `pulumi:"maximumRetryCount"`
	// List to indicate which scripts Amazon Data Lifecycle Manager should run on target instances. Pre scripts run before Amazon Data Lifecycle Manager initiates snapshot creation. Post scripts run after Amazon Data Lifecycle Manager initiates snapshot creation. Valid values: `PRE` and `POST`. The default is `PRE` and `POST`
	Stages pulumi.StringArrayInput `pulumi:"stages"`
}

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsArgs) ElementType added in v7.7.0 

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsArgs) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput added in v7.7.0 

func (i LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsArgs) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput() LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsArgs) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutputWithContext added in v7.7.0 

func (i LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsArgs) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsArgs) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput added in v7.7.0 

func (i LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsArgs) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput() LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsArgs) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutputWithContext added in v7.7.0 

func (i LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsArgs) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput

type LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsInput added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput() LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput
	ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput
}

LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsArgs and LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsInput` via: 

LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsArgs{...}

type LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput) ElementType added in v7.7.0 

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput) ExecuteOperationOnScriptFailure added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput) ExecuteOperationOnScriptFailure() pulumi.BoolPtrOutput

Indicates whether Amazon Data Lifecycle Manager should default to crash-consistent snapshots if the pre script fails. The default is `true`.

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput) ExecutionHandler added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput) ExecutionHandler() pulumi.StringOutput

The SSM document that includes the pre and/or post scripts to run. In case automating VSS backups, specify `AWS_VSS_BACKUP`. In case automating application-consistent snapshots for SAP HANA workloads, specify `AWSSystemsManagerSAP-CreateDLMSnapshotForSAPHANA`. If you are using a custom SSM document that you own, specify either the name or ARN of the SSM document.

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput) ExecutionHandlerService added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput) ExecutionHandlerService() pulumi.StringPtrOutput

Indicates the service used to execute the pre and/or post scripts. If using custom SSM documents or automating application-consistent snapshots of SAP HANA workloads, specify `AWS_SYSTEMS_MANAGER`. In case automating VSS Backups, omit this parameter. The default is `AWS_SYSTEMS_MANAGER`.

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput) ExecutionTimeout added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput) ExecutionTimeout() pulumi.IntPtrOutput

Specifies a timeout period, in seconds, after which Amazon Data Lifecycle Manager fails the script run attempt if it has not completed. In case automating VSS Backups, omit this parameter. The default is `10`.

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput) MaximumRetryCount added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput) MaximumRetryCount() pulumi.IntPtrOutput

Specifies the number of times Amazon Data Lifecycle Manager should retry scripts that fail. Must be an integer between `0` and `3`. The default is `0`.

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput) Stages added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput) Stages() pulumi.StringArrayOutput

List to indicate which scripts Amazon Data Lifecycle Manager should run on target instances. Pre scripts run before Amazon Data Lifecycle Manager initiates snapshot creation. Post scripts run after Amazon Data Lifecycle Manager initiates snapshot creation. Valid values: `PRE` and `POST`. The default is `PRE` and `POST`

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput() LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutputWithContext added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput() LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutputWithContext added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput

type LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrInput added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput() LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput
	ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput
}

LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsArgs, LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtr and LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrInput` via: 

        LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsArgs{...}

or:

        nil

func LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtr added in v7.7.0 

func LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtr(v *LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsArgs) LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrInput

type LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput added in v7.7.0 

type LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput) Elem added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput) Elem() LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsOutput

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput) ElementType added in v7.7.0 

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput) ExecuteOperationOnScriptFailure added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput) ExecuteOperationOnScriptFailure() pulumi.BoolPtrOutput

Indicates whether Amazon Data Lifecycle Manager should default to crash-consistent snapshots if the pre script fails. The default is `true`.

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput) ExecutionHandler added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput) ExecutionHandler() pulumi.StringPtrOutput

The SSM document that includes the pre and/or post scripts to run. In case automating VSS backups, specify `AWS_VSS_BACKUP`. In case automating application-consistent snapshots for SAP HANA workloads, specify `AWSSystemsManagerSAP-CreateDLMSnapshotForSAPHANA`. If you are using a custom SSM document that you own, specify either the name or ARN of the SSM document.

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput) ExecutionHandlerService added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput) ExecutionHandlerService() pulumi.StringPtrOutput

Indicates the service used to execute the pre and/or post scripts. If using custom SSM documents or automating application-consistent snapshots of SAP HANA workloads, specify `AWS_SYSTEMS_MANAGER`. In case automating VSS Backups, omit this parameter. The default is `AWS_SYSTEMS_MANAGER`.

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput) ExecutionTimeout added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput) ExecutionTimeout() pulumi.IntPtrOutput

Specifies a timeout period, in seconds, after which Amazon Data Lifecycle Manager fails the script run attempt if it has not completed. In case automating VSS Backups, omit this parameter. The default is `10`.

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput) MaximumRetryCount added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput) MaximumRetryCount() pulumi.IntPtrOutput

Specifies the number of times Amazon Data Lifecycle Manager should retry scripts that fail. Must be an integer between `0` and `3`. The default is `0`.

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput) Stages added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput) Stages() pulumi.StringArrayOutput

List to indicate which scripts Amazon Data Lifecycle Manager should run on target instances. Pre scripts run before Amazon Data Lifecycle Manager initiates snapshot creation. Post scripts run after Amazon Data Lifecycle Manager initiates snapshot creation. Valid values: `PRE` and `POST`. The default is `PRE` and `POST`

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput() LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutputWithContext added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsPtrOutput

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRule 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRule struct {
	CmkArn        *string                                                               `pulumi:"cmkArn"`
	CopyTags      *bool                                                                 `pulumi:"copyTags"`
	DeprecateRule *LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRule `pulumi:"deprecateRule"`
	Encrypted     bool                                                                  `pulumi:"encrypted"`
	RetainRule    *LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRule    `pulumi:"retainRule"`
	Target        *string                                                               `pulumi:"target"`
	// Use only for DLM policies of `policy_type=IMAGE_MANAGEMENT`. The target Region or the Amazon Resource Name (ARN) of the target Outpost for the snapshot copies.
	TargetRegion *string `pulumi:"targetRegion"`
}

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArgs 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArgs struct {
	CmkArn        pulumi.StringPtrInput                                                        `pulumi:"cmkArn"`
	CopyTags      pulumi.BoolPtrInput                                                          `pulumi:"copyTags"`
	DeprecateRule LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrInput `pulumi:"deprecateRule"`
	Encrypted     pulumi.BoolInput                                                             `pulumi:"encrypted"`
	RetainRule    LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrInput    `pulumi:"retainRule"`
	Target        pulumi.StringPtrInput                                                        `pulumi:"target"`
	// Use only for DLM policies of `policy_type=IMAGE_MANAGEMENT`. The target Region or the Amazon Resource Name (ARN) of the target Outpost for the snapshot copies.
	TargetRegion pulumi.StringPtrInput `pulumi:"targetRegion"`
}

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 {
	Interval     int    `pulumi:"interval"`
	IntervalUnit string `pulumi:"intervalUnit"`
}

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleArgs 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleArgs struct {
	Interval     pulumi.IntInput    `pulumi:"interval"`
	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

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRuleOutput) IntervalUnit() pulumi.StringOutput

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

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput) IntervalUnit() pulumi.StringPtrOutput

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

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) CopyTags 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) CopyTags() pulumi.BoolPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) DeprecateRule 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) DeprecateRule() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) Encrypted 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) Encrypted() pulumi.BoolOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) RetainRule 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) RetainRule() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) Target 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) Target() pulumi.StringPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) TargetRegion added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput) TargetRegion() pulumi.StringPtrOutput

Use only for DLM policies of `policy_type=IMAGE_MANAGEMENT`. 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 {
	Interval     int    `pulumi:"interval"`
	IntervalUnit string `pulumi:"intervalUnit"`
}

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleArgs 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleArgs struct {
	Interval     pulumi.IntInput    `pulumi:"interval"`
	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

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRuleOutput) IntervalUnit() pulumi.StringOutput

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

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput) IntervalUnit() pulumi.StringPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleRetainRulePtrOutputWithContext 

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

type LifecyclePolicyPolicyDetailsScheduleDeprecateRule 

type LifecyclePolicyPolicyDetailsScheduleDeprecateRule struct {
	Count        *int    `pulumi:"count"`
	Interval     *int    `pulumi:"interval"`
	IntervalUnit *string `pulumi:"intervalUnit"`
}

type LifecyclePolicyPolicyDetailsScheduleDeprecateRuleArgs 

type LifecyclePolicyPolicyDetailsScheduleDeprecateRuleArgs struct {
	Count        pulumi.IntPtrInput    `pulumi:"count"`
	Interval     pulumi.IntPtrInput    `pulumi:"interval"`
	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

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput) Interval 

func (o LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput) Interval() pulumi.IntPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleDeprecateRuleOutput) IntervalUnit() pulumi.StringPtrOutput

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

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

func (LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput) IntervalUnit() pulumi.StringPtrOutput

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"`
	Count             *int     `pulumi:"count"`
	Interval          *int     `pulumi:"interval"`
	IntervalUnit      *string  `pulumi:"intervalUnit"`
}

type LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleArgs 

type LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleArgs struct {
	// The Availability Zones in which to enable fast snapshot restore.
	AvailabilityZones pulumi.StringArrayInput `pulumi:"availabilityZones"`
	Count             pulumi.IntPtrInput      `pulumi:"count"`
	Interval          pulumi.IntPtrInput      `pulumi:"interval"`
	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

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) Interval 

func (o LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) Interval() pulumi.IntPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleOutput) IntervalUnit() pulumi.StringPtrOutput

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

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

func (LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput) IntervalUnit() pulumi.StringPtrOutput

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) ArchiveRule added in v7.7.0 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) ArchiveRule() LifecyclePolicyPolicyDetailsScheduleArchiveRulePtrOutput

Specifies a snapshot archiving rule for a schedule. See `archiveRule` block.

func (LifecyclePolicyPolicyDetailsScheduleOutput) CopyTags 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) CopyTags() pulumi.BoolPtrOutput

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

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

func (LifecyclePolicyPolicyDetailsScheduleOutput) RetainRule 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) RetainRule() LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput

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 {
	Count        *int    `pulumi:"count"`
	Interval     *int    `pulumi:"interval"`
	IntervalUnit *string `pulumi:"intervalUnit"`
}

type LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs 

type LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs struct {
	Count        pulumi.IntPtrInput    `pulumi:"count"`
	Interval     pulumi.IntPtrInput    `pulumi:"interval"`
	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

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) Interval 

func (o LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) Interval() pulumi.IntPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) IntervalUnit() pulumi.StringPtrOutput

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"`
	// The period after which snapshots that are shared with other AWS accounts are automatically unshared.
	UnshareInterval *int `pulumi:"unshareInterval"`
	// The unit of time for the automatic unsharing interval. Valid values are `DAYS`, `WEEKS`, `MONTHS`, `YEARS`.
	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"`
	// The period after which snapshots that are shared with other AWS accounts are automatically unshared.
	UnshareInterval pulumi.IntPtrInput `pulumi:"unshareInterval"`
	// The unit of time for the automatic unsharing interval. Valid values are `DAYS`, `WEEKS`, `MONTHS`, `YEARS`.
	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

The period after which snapshots that are shared with other AWS accounts are automatically unshared.

func (LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) UnshareIntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) UnshareIntervalUnit() pulumi.StringPtrOutput

The unit of time for the automatic unsharing interval. Valid values are `DAYS`, `WEEKS`, `MONTHS`, `YEARS`.

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

The period after which snapshots that are shared with other AWS accounts are automatically unshared.

func (LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) UnshareIntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) UnshareIntervalUnit() pulumi.StringPtrOutput

The unit of time for the automatic unsharing interval. Valid values are `DAYS`, `WEEKS`, `MONTHS`, `YEARS`.

type LifecyclePolicyState 

type LifecyclePolicyState struct {
	// Amazon Resource Name (ARN) of the DLM Lifecycle Policy.
	Arn pulumi.StringPtrInput
	// Specify the type of default policy to create. valid values are `VOLUME` or `INSTANCE`.
	DefaultPolicy 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
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput
	// 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.
	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.