dlm

package
v6.34.1 Latest Latest
Warning

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

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

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type LifecyclePolicy 

type LifecyclePolicy struct {
	pulumi.CustomResourceState

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

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

## Example Usage

### Basic

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		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: pulumi.Array{
				iam.GetPolicyDocumentStatement{
					Effect: pulumi.StringRef("Allow"),
					Actions: []string{
						"ec2:CreateSnapshot",
						"ec2:CreateSnapshots",
						"ec2:DeleteSnapshot",
						"ec2:DescribeInstances",
						"ec2:DescribeVolumes",
						"ec2:DescribeSnapshots",
					},
					Resources: []string{
						"*",
					},
				},
				iam.GetPolicyDocumentStatement{
					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("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 Cross-Region Snapshot Copy Usage

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws"
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/dlm"
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/iam"
"github.com/pulumi/pulumi-aws/sdk/v6/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, nil, 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("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/v6/go/aws"
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/dlm"
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		current, err := aws.GetCallerIdentity(ctx, nil, nil)
		if err != nil {
			return err
		}
		_, err = dlm.NewLifecyclePolicy(ctx, "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: nil,
							RetainRule: &dlm.LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRuleArgs{
								Interval:     pulumi.Int(15),
								IntervalUnit: pulumi.String("MONTHS"),
							},
							Target: pulumi.String("us-east-1"),
						},
					},
				},
				EventSource: &dlm.LifecyclePolicyPolicyDetailsEventSourceArgs{
					Type: pulumi.String("MANAGED_CWE"),
					Parameters: &dlm.LifecyclePolicyPolicyDetailsEventSourceParametersArgs{
						DescriptionRegex: pulumi.String("^.*Created for policy: policy-1234567890abcdef0.*$"),
						EventType:        pulumi.String("shareSnapshot"),
						SnapshotOwners: pulumi.StringArray{
							pulumi.String(current.AccountId),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		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
	})
}

```

## Import

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

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

func GetLifecyclePolicy 

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

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

func NewLifecyclePolicy 

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

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

func (*LifecyclePolicy) ElementType 

func (*LifecyclePolicy) ElementType() reflect.Type

func (*LifecyclePolicy) ToLifecyclePolicyOutput 

func (i *LifecyclePolicy) ToLifecyclePolicyOutput() LifecyclePolicyOutput

func (*LifecyclePolicy) ToLifecyclePolicyOutputWithContext 

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

type LifecyclePolicyArgs 

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

The set of arguments for constructing a LifecyclePolicy resource.

func (LifecyclePolicyArgs) ElementType 

func (LifecyclePolicyArgs) ElementType() reflect.Type

type LifecyclePolicyArray 

type LifecyclePolicyArray []LifecyclePolicyInput

func (LifecyclePolicyArray) ElementType 

func (LifecyclePolicyArray) ElementType() reflect.Type

func (LifecyclePolicyArray) ToLifecyclePolicyArrayOutput 

func (i LifecyclePolicyArray) ToLifecyclePolicyArrayOutput() LifecyclePolicyArrayOutput

func (LifecyclePolicyArray) ToLifecyclePolicyArrayOutputWithContext 

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

type LifecyclePolicyArrayInput 

type LifecyclePolicyArrayInput interface {
	pulumi.Input

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

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

LifecyclePolicyArray{ LifecyclePolicyArgs{...} }

type LifecyclePolicyArrayOutput 

type LifecyclePolicyArrayOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyArrayOutput) ElementType 

func (LifecyclePolicyArrayOutput) ElementType() reflect.Type

func (LifecyclePolicyArrayOutput) Index 

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

func (LifecyclePolicyArrayOutput) ToLifecyclePolicyArrayOutput 

func (o LifecyclePolicyArrayOutput) ToLifecyclePolicyArrayOutput() LifecyclePolicyArrayOutput

func (LifecyclePolicyArrayOutput) ToLifecyclePolicyArrayOutputWithContext 

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

type LifecyclePolicyInput 

type LifecyclePolicyInput interface {
	pulumi.Input

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

type LifecyclePolicyMap 

type LifecyclePolicyMap map[string]LifecyclePolicyInput

func (LifecyclePolicyMap) ElementType 

func (LifecyclePolicyMap) ElementType() reflect.Type

func (LifecyclePolicyMap) ToLifecyclePolicyMapOutput 

func (i LifecyclePolicyMap) ToLifecyclePolicyMapOutput() LifecyclePolicyMapOutput

func (LifecyclePolicyMap) ToLifecyclePolicyMapOutputWithContext 

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

type LifecyclePolicyMapInput 

type LifecyclePolicyMapInput interface {
	pulumi.Input

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

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

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

type LifecyclePolicyMapOutput 

type LifecyclePolicyMapOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyMapOutput) ElementType 

func (LifecyclePolicyMapOutput) ElementType() reflect.Type

func (LifecyclePolicyMapOutput) MapIndex 

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

func (LifecyclePolicyMapOutput) ToLifecyclePolicyMapOutput 

func (o LifecyclePolicyMapOutput) ToLifecyclePolicyMapOutput() LifecyclePolicyMapOutput

func (LifecyclePolicyMapOutput) ToLifecyclePolicyMapOutputWithContext 

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

type LifecyclePolicyOutput 

type LifecyclePolicyOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyOutput) Arn 

func (o LifecyclePolicyOutput) Arn() pulumi.StringOutput

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

func (LifecyclePolicyOutput) Description 

func (o LifecyclePolicyOutput) Description() pulumi.StringOutput

A description for the DLM lifecycle policy.

func (LifecyclePolicyOutput) ElementType 

func (LifecyclePolicyOutput) ElementType() reflect.Type

func (LifecyclePolicyOutput) ExecutionRoleArn 

func (o LifecyclePolicyOutput) ExecutionRoleArn() pulumi.StringOutput

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

func (LifecyclePolicyOutput) PolicyDetails 

func (o LifecyclePolicyOutput) PolicyDetails() LifecyclePolicyPolicyDetailsOutput

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

func (LifecyclePolicyOutput) State 

func (o LifecyclePolicyOutput) State() pulumi.StringPtrOutput

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

func (LifecyclePolicyOutput) Tags 

func (o LifecyclePolicyOutput) Tags() pulumi.StringMapOutput

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

func (LifecyclePolicyOutput) TagsAll deprecated 

func (o LifecyclePolicyOutput) TagsAll() pulumi.StringMapOutput

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

Deprecated: Please use `tags` instead.

func (LifecyclePolicyOutput) ToLifecyclePolicyOutput 

func (o LifecyclePolicyOutput) ToLifecyclePolicyOutput() LifecyclePolicyOutput

func (LifecyclePolicyOutput) ToLifecyclePolicyOutputWithContext 

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

type LifecyclePolicyPolicyDetails 

type LifecyclePolicyPolicyDetails struct {
	Action            *LifecyclePolicyPolicyDetailsAction      `pulumi:"action"`
	EventSource       *LifecyclePolicyPolicyDetailsEventSource `pulumi:"eventSource"`
	Parameters        *LifecyclePolicyPolicyDetailsParameters  `pulumi:"parameters"`
	PolicyType        *string                                  `pulumi:"policyType"`
	ResourceLocations *string                                  `pulumi:"resourceLocations"`
	ResourceTypes     []string                                 `pulumi:"resourceTypes"`
	Schedules         []LifecyclePolicyPolicyDetailsSchedule   `pulumi:"schedules"`
	TargetTags        map[string]string                        `pulumi:"targetTags"`
}

type LifecyclePolicyPolicyDetailsAction 

type LifecyclePolicyPolicyDetailsAction struct {
	CrossRegionCopies []LifecyclePolicyPolicyDetailsActionCrossRegionCopy `pulumi:"crossRegionCopies"`
	Name              string                                              `pulumi:"name"`
}

type LifecyclePolicyPolicyDetailsActionArgs 

type LifecyclePolicyPolicyDetailsActionArgs struct {
	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 {
	EncryptionConfiguration LifecyclePolicyPolicyDetailsActionCrossRegionCopyEncryptionConfiguration `pulumi:"encryptionConfiguration"`
	RetainRule              *LifecyclePolicyPolicyDetailsActionCrossRegionCopyRetainRule             `pulumi:"retainRule"`
	Target                  string                                                                   `pulumi:"target"`
}

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyArgs 

type LifecyclePolicyPolicyDetailsActionCrossRegionCopyArgs struct {
	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

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

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

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 {
	Action            LifecyclePolicyPolicyDetailsActionPtrInput      `pulumi:"action"`
	EventSource       LifecyclePolicyPolicyDetailsEventSourcePtrInput `pulumi:"eventSource"`
	Parameters        LifecyclePolicyPolicyDetailsParametersPtrInput  `pulumi:"parameters"`
	PolicyType        pulumi.StringPtrInput                           `pulumi:"policyType"`
	ResourceLocations pulumi.StringPtrInput                           `pulumi:"resourceLocations"`
	ResourceTypes     pulumi.StringArrayInput                         `pulumi:"resourceTypes"`
	Schedules         LifecyclePolicyPolicyDetailsScheduleArrayInput  `pulumi:"schedules"`
	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"`
	Type       string                                            `pulumi:"type"`
}

type LifecyclePolicyPolicyDetailsEventSourceArgs 

type LifecyclePolicyPolicyDetailsEventSourceArgs struct {
	Parameters LifecyclePolicyPolicyDetailsEventSourceParametersInput `pulumi:"parameters"`
	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

type LifecyclePolicyPolicyDetailsEventSourceParameters 

type LifecyclePolicyPolicyDetailsEventSourceParameters struct {
	DescriptionRegex string   `pulumi:"descriptionRegex"`
	EventType        string   `pulumi:"eventType"`
	SnapshotOwners   []string `pulumi:"snapshotOwners"`
}

type LifecyclePolicyPolicyDetailsEventSourceParametersArgs 

type LifecyclePolicyPolicyDetailsEventSourceParametersArgs struct {
	DescriptionRegex pulumi.StringInput      `pulumi:"descriptionRegex"`
	EventType        pulumi.StringInput      `pulumi:"eventType"`
	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

func (LifecyclePolicyPolicyDetailsEventSourceParametersOutput) ElementType 

func (LifecyclePolicyPolicyDetailsEventSourceParametersOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsEventSourceParametersOutput) EventType 

func (o LifecyclePolicyPolicyDetailsEventSourceParametersOutput) EventType() pulumi.StringOutput

func (LifecyclePolicyPolicyDetailsEventSourceParametersOutput) SnapshotOwners 

func (o LifecyclePolicyPolicyDetailsEventSourceParametersOutput) SnapshotOwners() pulumi.StringArrayOutput

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

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

func (LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput) SnapshotOwners 

func (o LifecyclePolicyPolicyDetailsEventSourceParametersPtrOutput) SnapshotOwners() pulumi.StringArrayOutput

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

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

func (LifecyclePolicyPolicyDetailsOutput) ElementType 

func (LifecyclePolicyPolicyDetailsOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsOutput) EventSource 

func (o LifecyclePolicyPolicyDetailsOutput) EventSource() LifecyclePolicyPolicyDetailsEventSourcePtrOutput

func (LifecyclePolicyPolicyDetailsOutput) Parameters 

func (o LifecyclePolicyPolicyDetailsOutput) Parameters() LifecyclePolicyPolicyDetailsParametersPtrOutput

func (LifecyclePolicyPolicyDetailsOutput) PolicyType 

func (o LifecyclePolicyPolicyDetailsOutput) PolicyType() pulumi.StringPtrOutput

func (LifecyclePolicyPolicyDetailsOutput) ResourceLocations 

func (o LifecyclePolicyPolicyDetailsOutput) ResourceLocations() pulumi.StringPtrOutput

func (LifecyclePolicyPolicyDetailsOutput) ResourceTypes 

func (o LifecyclePolicyPolicyDetailsOutput) ResourceTypes() pulumi.StringArrayOutput

func (LifecyclePolicyPolicyDetailsOutput) Schedules 

func (o LifecyclePolicyPolicyDetailsOutput) Schedules() LifecyclePolicyPolicyDetailsScheduleArrayOutput

func (LifecyclePolicyPolicyDetailsOutput) TargetTags 

func (o LifecyclePolicyPolicyDetailsOutput) TargetTags() pulumi.StringMapOutput

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 {
	ExcludeBootVolume *bool `pulumi:"excludeBootVolume"`
	NoReboot          *bool `pulumi:"noReboot"`
}

type LifecyclePolicyPolicyDetailsParametersArgs 

type LifecyclePolicyPolicyDetailsParametersArgs struct {
	ExcludeBootVolume pulumi.BoolPtrInput `pulumi:"excludeBootVolume"`
	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

func (LifecyclePolicyPolicyDetailsParametersOutput) NoReboot 

func (o LifecyclePolicyPolicyDetailsParametersOutput) NoReboot() pulumi.BoolPtrOutput

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

func (LifecyclePolicyPolicyDetailsParametersPtrOutput) NoReboot 

func (o LifecyclePolicyPolicyDetailsParametersPtrOutput) NoReboot() pulumi.BoolPtrOutput

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

func (LifecyclePolicyPolicyDetailsPtrOutput) Elem 

func (o LifecyclePolicyPolicyDetailsPtrOutput) Elem() LifecyclePolicyPolicyDetailsOutput

func (LifecyclePolicyPolicyDetailsPtrOutput) ElementType 

func (LifecyclePolicyPolicyDetailsPtrOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsPtrOutput) EventSource 

func (o LifecyclePolicyPolicyDetailsPtrOutput) EventSource() LifecyclePolicyPolicyDetailsEventSourcePtrOutput

func (LifecyclePolicyPolicyDetailsPtrOutput) Parameters 

func (o LifecyclePolicyPolicyDetailsPtrOutput) Parameters() LifecyclePolicyPolicyDetailsParametersPtrOutput

func (LifecyclePolicyPolicyDetailsPtrOutput) PolicyType 

func (o LifecyclePolicyPolicyDetailsPtrOutput) PolicyType() pulumi.StringPtrOutput

func (LifecyclePolicyPolicyDetailsPtrOutput) ResourceLocations 

func (o LifecyclePolicyPolicyDetailsPtrOutput) ResourceLocations() pulumi.StringPtrOutput

func (LifecyclePolicyPolicyDetailsPtrOutput) ResourceTypes 

func (o LifecyclePolicyPolicyDetailsPtrOutput) ResourceTypes() pulumi.StringArrayOutput

func (LifecyclePolicyPolicyDetailsPtrOutput) Schedules 

func (o LifecyclePolicyPolicyDetailsPtrOutput) Schedules() LifecyclePolicyPolicyDetailsScheduleArrayOutput

func (LifecyclePolicyPolicyDetailsPtrOutput) TargetTags 

func (o LifecyclePolicyPolicyDetailsPtrOutput) TargetTags() pulumi.StringMapOutput

func (LifecyclePolicyPolicyDetailsPtrOutput) ToLifecyclePolicyPolicyDetailsPtrOutput 

func (o LifecyclePolicyPolicyDetailsPtrOutput) ToLifecyclePolicyPolicyDetailsPtrOutput() LifecyclePolicyPolicyDetailsPtrOutput

func (LifecyclePolicyPolicyDetailsPtrOutput) ToLifecyclePolicyPolicyDetailsPtrOutputWithContext 

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

type LifecyclePolicyPolicyDetailsSchedule 

type LifecyclePolicyPolicyDetailsSchedule struct {
	CopyTags             *bool                                                     `pulumi:"copyTags"`
	CreateRule           LifecyclePolicyPolicyDetailsScheduleCreateRule            `pulumi:"createRule"`
	CrossRegionCopyRules []LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRule `pulumi:"crossRegionCopyRules"`
	DeprecateRule        *LifecyclePolicyPolicyDetailsScheduleDeprecateRule        `pulumi:"deprecateRule"`
	FastRestoreRule      *LifecyclePolicyPolicyDetailsScheduleFastRestoreRule      `pulumi:"fastRestoreRule"`
	Name                 string                                                    `pulumi:"name"`
	RetainRule           LifecyclePolicyPolicyDetailsScheduleRetainRule            `pulumi:"retainRule"`
	ShareRule            *LifecyclePolicyPolicyDetailsScheduleShareRule            `pulumi:"shareRule"`
	TagsToAdd            map[string]string                                         `pulumi:"tagsToAdd"`
	VariableTags         map[string]string                                         `pulumi:"variableTags"`
}

type LifecyclePolicyPolicyDetailsScheduleArgs 

type LifecyclePolicyPolicyDetailsScheduleArgs struct {
	CopyTags             pulumi.BoolPtrInput                                               `pulumi:"copyTags"`
	CreateRule           LifecyclePolicyPolicyDetailsScheduleCreateRuleInput               `pulumi:"createRule"`
	CrossRegionCopyRules LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayInput `pulumi:"crossRegionCopyRules"`
	DeprecateRule        LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrInput         `pulumi:"deprecateRule"`
	FastRestoreRule      LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrInput       `pulumi:"fastRestoreRule"`
	Name                 pulumi.StringInput                                                `pulumi:"name"`
	RetainRule           LifecyclePolicyPolicyDetailsScheduleRetainRuleInput               `pulumi:"retainRule"`
	ShareRule            LifecyclePolicyPolicyDetailsScheduleShareRulePtrInput             `pulumi:"shareRule"`
	TagsToAdd            pulumi.StringMapInput                                             `pulumi:"tagsToAdd"`
	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 {
	CronExpression *string `pulumi:"cronExpression"`
	Interval       *int    `pulumi:"interval"`
	IntervalUnit   *string `pulumi:"intervalUnit"`
	Location       *string `pulumi:"location"`
	Times          *string `pulumi:"times"`
}

type LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs 

type LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs struct {
	CronExpression pulumi.StringPtrInput `pulumi:"cronExpression"`
	Interval       pulumi.IntPtrInput    `pulumi:"interval"`
	IntervalUnit   pulumi.StringPtrInput `pulumi:"intervalUnit"`
	Location       pulumi.StringPtrInput `pulumi:"location"`
	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

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

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) Times 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) Times() pulumi.StringPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleOutput 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleOutput() LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleOutputWithContext 

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

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"`
}

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.StringInput                                                           `pulumi:"target"`
}

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArgs) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput 

func (i LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleOutputWithContext 

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

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArray 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArray []LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleInput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArray) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArray) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArray) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput 

func (i LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArray) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArray) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutputWithContext 

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

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayInput 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayInput interface {
	pulumi.Input

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

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

LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArray{ LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArgs{...} }

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput) Index 

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

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput 

func (o LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput

func (LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput) ToLifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutputWithContext 

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

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRule 

type LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleDeprecateRule struct {
	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.StringOutput

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

type LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleArgs 

type LifecyclePolicyPolicyDetailsScheduleFastRestoreRuleArgs struct {
	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

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

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

func (o LifecyclePolicyPolicyDetailsScheduleOutput) CopyTags() pulumi.BoolPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleOutput) CreateRule 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) CreateRule() LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleOutput) CrossRegionCopyRules 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) CrossRegionCopyRules() LifecyclePolicyPolicyDetailsScheduleCrossRegionCopyRuleArrayOutput

func (LifecyclePolicyPolicyDetailsScheduleOutput) DeprecateRule 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) DeprecateRule() LifecyclePolicyPolicyDetailsScheduleDeprecateRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleOutput) FastRestoreRule 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) FastRestoreRule() LifecyclePolicyPolicyDetailsScheduleFastRestoreRulePtrOutput

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

func (LifecyclePolicyPolicyDetailsScheduleOutput) TagsToAdd 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) TagsToAdd() pulumi.StringMapOutput

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

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 {
	TargetAccounts      []string `pulumi:"targetAccounts"`
	UnshareInterval     *int     `pulumi:"unshareInterval"`
	UnshareIntervalUnit *string  `pulumi:"unshareIntervalUnit"`
}

type LifecyclePolicyPolicyDetailsScheduleShareRuleArgs 

type LifecyclePolicyPolicyDetailsScheduleShareRuleArgs struct {
	TargetAccounts      pulumi.StringArrayInput `pulumi:"targetAccounts"`
	UnshareInterval     pulumi.IntPtrInput      `pulumi:"unshareInterval"`
	UnshareIntervalUnit pulumi.StringPtrInput   `pulumi:"unshareIntervalUnit"`
}

func (LifecyclePolicyPolicyDetailsScheduleShareRuleArgs) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleShareRuleArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleShareRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleShareRuleOutput 

func (i LifecyclePolicyPolicyDetailsScheduleShareRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleShareRuleOutput() LifecyclePolicyPolicyDetailsScheduleShareRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleShareRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleShareRuleOutputWithContext 

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

func (LifecyclePolicyPolicyDetailsScheduleShareRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput 

func (i LifecyclePolicyPolicyDetailsScheduleShareRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleShareRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleShareRulePtrOutputWithContext 

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

type LifecyclePolicyPolicyDetailsScheduleShareRuleInput 

type LifecyclePolicyPolicyDetailsScheduleShareRuleInput interface {
	pulumi.Input

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

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

LifecyclePolicyPolicyDetailsScheduleShareRuleArgs{...}

type LifecyclePolicyPolicyDetailsScheduleShareRuleOutput 

type LifecyclePolicyPolicyDetailsScheduleShareRuleOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) TargetAccounts 

func (o LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) TargetAccounts() pulumi.StringArrayOutput

func (LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleShareRuleOutput 

func (o LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleShareRuleOutput() LifecyclePolicyPolicyDetailsScheduleShareRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleShareRuleOutputWithContext 

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

func (LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput 

func (o LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleShareRulePtrOutputWithContext 

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

func (LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) UnshareInterval 

func (o LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) UnshareInterval() pulumi.IntPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) UnshareIntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleShareRuleOutput) UnshareIntervalUnit() pulumi.StringPtrOutput

type LifecyclePolicyPolicyDetailsScheduleShareRulePtrInput 

type LifecyclePolicyPolicyDetailsScheduleShareRulePtrInput interface {
	pulumi.Input

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

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

        LifecyclePolicyPolicyDetailsScheduleShareRuleArgs{...}

or:

        nil

func LifecyclePolicyPolicyDetailsScheduleShareRulePtr 

func LifecyclePolicyPolicyDetailsScheduleShareRulePtr(v *LifecyclePolicyPolicyDetailsScheduleShareRuleArgs) LifecyclePolicyPolicyDetailsScheduleShareRulePtrInput

type LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput 

type LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) Elem 

func (o LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) Elem() LifecyclePolicyPolicyDetailsScheduleShareRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) TargetAccounts 

func (o LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) TargetAccounts() pulumi.StringArrayOutput

func (LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput 

func (o LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput() LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput

func (LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) ToLifecyclePolicyPolicyDetailsScheduleShareRulePtrOutputWithContext 

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

func (LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) UnshareInterval 

func (o LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) UnshareInterval() pulumi.IntPtrOutput

func (LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) UnshareIntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleShareRulePtrOutput) UnshareIntervalUnit() pulumi.StringPtrOutput

type LifecyclePolicyState 

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

func (LifecyclePolicyState) ElementType 

func (LifecyclePolicyState) ElementType() reflect.Type

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.