type CreateRule struct {
	// The time, in UTC, to start the operation. The supported format is hh:mm. The
	// operation occurs within a one-hour window following the specified time. If you
	// do not specify a time, Amazon DLM selects a time within the next 24 hours.
	Times []*string
	// The schedule, as a Cron expression. The schedule interval must be between 1 hour
	// and 1 year. For more information, see Cron expressions
	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html#CronExpressions)
	// in the Amazon CloudWatch User Guide.
	CronExpression *string
	// The interval unit.
	IntervalUnit IntervalUnitValues
	// The interval between snapshots. The supported values are 1, 2, 3, 4, 6, 8, 12,
	// and 24.
	Interval *int32
}

type CrossRegionCopyRetainRule struct {
	// The unit of time for time-based retention.
	IntervalUnit RetentionIntervalUnitValues
	// The amount of time to retain each snapshot. The maximum is 100 years. This is
	// equivalent to 1200 months, 5200 weeks, or 36500 days.
	Interval *int32
}

type CrossRegionCopyRule struct {
	// To encrypt a copy of an unencrypted snapshot if encryption by default is not
	// enabled, enable encryption using this parameter. Copies of encrypted snapshots
	// are encrypted, even if this parameter is false or if encryption by default is
	// not enabled.
	Encrypted *bool
	// The retention rule.
	RetainRule *CrossRegionCopyRetainRule
	// The target Region.
	TargetRegion *string
	// Copy all user-defined tags from the source snapshot to the copied snapshot.
	CopyTags *bool
	// The Amazon Resource Name (ARN) of the AWS KMS customer master key (CMK) to use
	// for EBS encryption. If this parameter is not specified, your AWS managed CMK for
	// EBS is used.
	CmkArn *string
}

type FastRestoreRule struct {
	// The number of snapshots to be enabled with fast snapshot restore.
	Count *int32
	// The unit of time for enabling fast snapshot restore.
	IntervalUnit RetentionIntervalUnitValues
	// The amount of time to enable fast snapshot restore. The maximum is 100 years.
	// This is equivalent to 1200 months, 5200 weeks, or 36500 days.
	Interval *int32
	// The Availability Zones in which to enable fast snapshot restore.
	AvailabilityZones []*string
}

type GettablePolicyStateValues string

const (
	GettablePolicyStateValuesEnabled  GettablePolicyStateValues = "ENABLED"
	GettablePolicyStateValuesDisabled GettablePolicyStateValues = "DISABLED"
	GettablePolicyStateValuesError    GettablePolicyStateValues = "ERROR"
)

type InternalServerException struct {
	Message *string

	Code *string
}

type IntervalUnitValues string

const (
	IntervalUnitValuesHours IntervalUnitValues = "HOURS"
)

type InvalidRequestException struct {
	Message *string

	MutuallyExclusiveParameters []*string
	Code                        *string
	RequiredParameters          []*string
}

type LifecyclePolicy struct {
	// The Amazon Resource Name (ARN) of the policy.
	PolicyArn *string
	// The identifier of the lifecycle policy.
	PolicyId *string
	// The local date and time when the lifecycle policy was last modified.
	DateModified *time.Time
	// The description of the status.
	StatusMessage *string
	// The tags.
	Tags map[string]*string
	// The Amazon Resource Name (ARN) of the IAM role used to run the operations
	// specified by the lifecycle policy.
	ExecutionRoleArn *string
	// The activation state of the lifecycle policy.
	State GettablePolicyStateValues
	// The local date and time when the lifecycle policy was created.
	DateCreated *time.Time
	// The configuration of the lifecycle policy
	PolicyDetails *PolicyDetails
	// The description of the lifecycle policy.
	Description *string
}

type LifecyclePolicySummary struct {
	// The description of the lifecycle policy.
	Description *string
	// The tags.
	Tags map[string]*string
	// The identifier of the lifecycle policy.
	PolicyId *string
	// The activation state of the lifecycle policy.
	State GettablePolicyStateValues
}

type LimitExceededException struct {
	Message *string

	Code         *string
	ResourceType *string
}

type Parameters struct {
	// [EBS Snapshot Management – Instance policies only] Indicates whether to exclude
	// the root volume from snapshots created using CreateSnapshots
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateSnapshots.html).
	// The default is false.
	ExcludeBootVolume *bool
}

type PolicyDetails struct {
	// A set of optional parameters for the policy.
	Parameters *Parameters
	// The resource type. Use VOLUME to create snapshots of individual volumes or use
	// INSTANCE to create multi-volume snapshots from the volumes for an instance.
	ResourceTypes []ResourceTypeValues
	// The valid target resource types and actions a policy can manage. The default is
	// EBS_SNAPSHOT_MANAGEMENT.
	PolicyType PolicyTypeValues
	// The schedule of policy-defined actions.
	Schedules []*Schedule
	// The single tag that identifies targeted resources for this policy.
	TargetTags []*Tag
}

type PolicyTypeValues string

const (
	PolicyTypeValuesEbs_snapshot_management PolicyTypeValues = "EBS_SNAPSHOT_MANAGEMENT"
)

type ResourceNotFoundException struct {
	Message *string

	Code         *string
	ResourceIds  []*string
	ResourceType *string
}

type ResourceTypeValues string

const (
	ResourceTypeValuesVolume   ResourceTypeValues = "VOLUME"
	ResourceTypeValuesInstance ResourceTypeValues = "INSTANCE"
)

type RetainRule struct {
	// The unit of time for time-based retention.
	IntervalUnit RetentionIntervalUnitValues
	// The number of snapshots to retain for each volume, up to a maximum of 1000.
	Count *int32
	// The amount of time to retain each snapshot. The maximum is 100 years. This is
	// equivalent to 1200 months, 5200 weeks, or 36500 days.
	Interval *int32
}

type RetentionIntervalUnitValues string

const (
	RetentionIntervalUnitValuesDays   RetentionIntervalUnitValues = "DAYS"
	RetentionIntervalUnitValuesWeeks  RetentionIntervalUnitValues = "WEEKS"
	RetentionIntervalUnitValuesMonths RetentionIntervalUnitValues = "MONTHS"
	RetentionIntervalUnitValuesYears  RetentionIntervalUnitValues = "YEARS"
)

type Schedule struct {
	// The rule for cross-Region snapshot copies.
	CrossRegionCopyRules []*CrossRegionCopyRule
	// Copy all user-defined tags on a source volume to snapshots of the volume created
	// by this policy.
	CopyTags *bool
	// The name of the schedule.
	Name *string
	// The rule for enabling fast snapshot restore.
	FastRestoreRule *FastRestoreRule
	// The retention rule.
	RetainRule *RetainRule
	// The tags to apply to policy-created resources. These user-defined tags are in
	// addition to the AWS-added lifecycle tags.
	TagsToAdd []*Tag
	// A collection of key/value pairs with values determined dynamically when the
	// policy is executed. Keys may be any valid Amazon EC2 tag key. Values must be in
	// one of the two following formats: $(instance-id) or $(timestamp). Variable tags
	// are only valid for EBS Snapshot Management – Instance policies.
	VariableTags []*Tag
	// The creation rule.
	CreateRule *CreateRule
}

type SettablePolicyStateValues string

const (
	SettablePolicyStateValuesEnabled  SettablePolicyStateValues = "ENABLED"
	SettablePolicyStateValuesDisabled SettablePolicyStateValues = "DISABLED"
)

type Tag struct {
	// The tag key.
	Key *string
	// The tag value.
	Value *string
}