// Code generated by smithy-go-codegen DO NOT EDIT.

package redshift

import (
	"context"
	"fmt"
	awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
	"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
	"github.com/aws/aws-sdk-go-v2/service/redshift/types"
	"github.com/aws/smithy-go/middleware"
	smithyhttp "github.com/aws/smithy-go/transport/http"
)

// Creates a new cluster from a snapshot. By default, Amazon Redshift creates the
// resulting cluster with the same configuration as the original cluster from which
// the snapshot was created, except that the new cluster is created with the
// default cluster security and parameter groups. After Amazon Redshift creates the
// cluster, you can use the ModifyCluster API to associate a different security
// group and different parameter group with the restored cluster. If you are using
// a DS node type, you can also choose to change to another DS node type of the
// same size during restore. If you restore a cluster into a VPC, you must provide
// a cluster subnet group where you want the cluster restored. For more information
// about working with snapshots, go to Amazon Redshift Snapshots (https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-snapshots.html)
// in the Amazon Redshift Cluster Management Guide.
func (c *Client) RestoreFromClusterSnapshot(ctx context.Context, params *RestoreFromClusterSnapshotInput, optFns ...func(*Options)) (*RestoreFromClusterSnapshotOutput, error) {
	if params == nil {
		params = &RestoreFromClusterSnapshotInput{}
	}

	result, metadata, err := c.invokeOperation(ctx, "RestoreFromClusterSnapshot", params, optFns, c.addOperationRestoreFromClusterSnapshotMiddlewares)
	if err != nil {
		return nil, err
	}

	out := result.(*RestoreFromClusterSnapshotOutput)
	out.ResultMetadata = metadata
	return out, nil
}

type RestoreFromClusterSnapshotInput struct {

	// The identifier of the cluster that will be created from restoring the snapshot.
	// Constraints:
	//   - Must contain from 1 to 63 alphanumeric characters or hyphens.
	//   - Alphabetic characters must be lowercase.
	//   - First character must be a letter.
	//   - Cannot end with a hyphen or contain two consecutive hyphens.
	//   - Must be unique for all clusters within an Amazon Web Services account.
	//
	// This member is required.
	ClusterIdentifier *string

	// Reserved.
	AdditionalInfo *string

	// If true , major version upgrades can be applied during the maintenance window to
	// the Amazon Redshift engine that is running on the cluster. Default: true
	AllowVersionUpgrade *bool

	// This parameter is retired. It does not set the AQUA configuration status.
	// Amazon Redshift automatically determines whether to use AQUA (Advanced Query
	// Accelerator).
	AquaConfigurationStatus types.AquaConfigurationStatus

	// The number of days that automated snapshots are retained. If the value is 0,
	// automated snapshots are disabled. Even if automated snapshots are disabled, you
	// can still create manual snapshots when you want with CreateClusterSnapshot . You
	// can't disable automated snapshots for RA3 node types. Set the automated
	// retention period from 1-35 days. Default: The value selected for the cluster
	// from which the snapshot was taken. Constraints: Must be a value from 0 to 35.
	AutomatedSnapshotRetentionPeriod *int32

	// The Amazon EC2 Availability Zone in which to restore the cluster. Default: A
	// random, system-chosen Availability Zone. Example: us-east-2a
	AvailabilityZone *string

	// The option to enable relocation for an Amazon Redshift cluster between
	// Availability Zones after the cluster is restored.
	AvailabilityZoneRelocation *bool

	// The name of the parameter group to be associated with this cluster. Default:
	// The default Amazon Redshift cluster parameter group. For information about the
	// default parameter group, go to Working with Amazon Redshift Parameter Groups (https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-parameter-groups.html)
	// . Constraints:
	//   - Must be 1 to 255 alphanumeric characters or hyphens.
	//   - First character must be a letter.
	//   - Cannot end with a hyphen or contain two consecutive hyphens.
	ClusterParameterGroupName *string

	// A list of security groups to be associated with this cluster. Default: The
	// default cluster security group for Amazon Redshift. Cluster security groups only
	// apply to clusters outside of VPCs.
	ClusterSecurityGroups []string

	// The name of the subnet group where you want to cluster restored. A snapshot of
	// cluster in VPC can be restored only in VPC. Therefore, you must provide subnet
	// group name where you want the cluster restored.
	ClusterSubnetGroupName *string

	// The Amazon Resource Name (ARN) for the IAM role that was set as default for the
	// cluster when the cluster was last modified while it was restored from a
	// snapshot.
	DefaultIamRoleArn *string

	// The Elastic IP (EIP) address for the cluster. Don't specify the Elastic IP
	// address for a publicly accessible cluster with availability zone relocation
	// turned on.
	ElasticIp *string

	// Enables support for restoring an unencrypted snapshot to a cluster encrypted
	// with Key Management Service (KMS) and a customer managed key.
	Encrypted *bool

	// An option that specifies whether to create the cluster with enhanced VPC
	// routing enabled. To create a cluster that uses enhanced VPC routing, the cluster
	// must be in a VPC. For more information, see Enhanced VPC Routing (https://docs.aws.amazon.com/redshift/latest/mgmt/enhanced-vpc-routing.html)
	// in the Amazon Redshift Cluster Management Guide. If this option is true ,
	// enhanced VPC routing is enabled. Default: false
	EnhancedVpcRouting *bool

	// Specifies the name of the HSM client certificate the Amazon Redshift cluster
	// uses to retrieve the data encryption keys stored in an HSM.
	HsmClientCertificateIdentifier *string

	// Specifies the name of the HSM configuration that contains the information the
	// Amazon Redshift cluster can use to retrieve and store keys in an HSM.
	HsmConfigurationIdentifier *string

	// A list of Identity and Access Management (IAM) roles that can be used by the
	// cluster to access other Amazon Web Services services. You must supply the IAM
	// roles in their Amazon Resource Name (ARN) format. The maximum number of IAM
	// roles that you can associate is subject to a quota. For more information, go to
	// Quotas and limits (https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html)
	// in the Amazon Redshift Cluster Management Guide.
	IamRoles []string

	// The IP address type for the cluster. Possible values are ipv4 and dualstack .
	IpAddressType *string

	// The Key Management Service (KMS) key ID of the encryption key that encrypts
	// data in the cluster restored from a shared snapshot. You can also provide the
	// key ID when you restore from an unencrypted snapshot to an encrypted cluster in
	// the same account. Additionally, you can specify a new KMS key ID when you
	// restore from an encrypted snapshot in the same account in order to change it. In
	// that case, the restored cluster is encrypted with the new KMS key ID.
	KmsKeyId *string

	// The name of the maintenance track for the restored cluster. When you take a
	// snapshot, the snapshot inherits the MaintenanceTrack value from the cluster.
	// The snapshot might be on a different track than the cluster that was the source
	// for the snapshot. For example, suppose that you take a snapshot of a cluster
	// that is on the current track and then change the cluster to be on the trailing
	// track. In this case, the snapshot and the source cluster are on different
	// tracks.
	MaintenanceTrackName *string

	// If true , Amazon Redshift uses Secrets Manager to manage the restored cluster's
	// admin credentials. If ManageMasterPassword is false or not set, Amazon Redshift
	// uses the admin credentials the cluster had at the time the snapshot was taken.
	ManageMasterPassword *bool

	// The default number of days to retain a manual snapshot. If the value is -1, the
	// snapshot is retained indefinitely. This setting doesn't change the retention
	// period of existing snapshots. The value must be either -1 or an integer between
	// 1 and 3,653.
	ManualSnapshotRetentionPeriod *int32

	// The ID of the Key Management Service (KMS) key used to encrypt and store the
	// cluster's admin credentials secret. You can only use this parameter if
	// ManageMasterPassword is true.
	MasterPasswordSecretKmsKeyId *string

	// If true, the snapshot will be restored to a cluster deployed in two
	// Availability Zones.
	MultiAZ *bool

	// The node type that the restored cluster will be provisioned with. Default: The
	// node type of the cluster from which the snapshot was taken. You can modify this
	// if you are using any DS node type. In that case, you can choose to restore into
	// another DS node type of the same size. For example, you can restore ds1.8xlarge
	// into ds2.8xlarge, or ds1.xlarge into ds2.xlarge. If you have a DC instance type,
	// you must restore into that same instance type and size. In other words, you can
	// only restore a dc1.large instance type into another dc1.large instance type or
	// dc2.large instance type. You can't restore dc1.8xlarge to dc2.8xlarge. First
	// restore to a dc1.8xlarge cluster, then resize to a dc2.8large cluster. For more
	// information about node types, see About Clusters and Nodes (https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-clusters.html#rs-about-clusters-and-nodes)
	// in the Amazon Redshift Cluster Management Guide.
	NodeType *string

	// The number of nodes specified when provisioning the restored cluster.
	NumberOfNodes *int32

	// The Amazon Web Services account used to create or copy the snapshot. Required
	// if you are restoring a snapshot you do not own, optional if you own the
	// snapshot.
	OwnerAccount *string

	// The port number on which the cluster accepts connections. Default: The same
	// port as the original cluster. Constraints: Must be between 1115 and 65535 .
	Port *int32

	// The weekly time range (in UTC) during which automated cluster maintenance can
	// occur. Format: ddd:hh24:mi-ddd:hh24:mi Default: The value selected for the
	// cluster from which the snapshot was taken. For more information about the time
	// blocks for each region, see Maintenance Windows (https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-clusters.html#rs-maintenance-windows)
	// in Amazon Redshift Cluster Management Guide. Valid Days: Mon | Tue | Wed | Thu |
	// Fri | Sat | Sun Constraints: Minimum 30-minute window.
	PreferredMaintenanceWindow *string

	// If true , the cluster can be accessed from a public network.
	PubliclyAccessible *bool

	// The identifier of the target reserved node offering.
	ReservedNodeId *string

	// The Amazon Resource Name (ARN) of the snapshot associated with the message to
	// restore from a cluster. You must specify this parameter or snapshotIdentifier ,
	// but not both.
	SnapshotArn *string

	// The name of the cluster the source snapshot was created from. This parameter is
	// required if your IAM user has a policy containing a snapshot resource element
	// that specifies anything other than * for the cluster name.
	SnapshotClusterIdentifier *string

	// The name of the snapshot from which to create the new cluster. This parameter
	// isn't case sensitive. You must specify this parameter or snapshotArn , but not
	// both. Example: my-snapshot-id
	SnapshotIdentifier *string

	// A unique identifier for the snapshot schedule.
	SnapshotScheduleIdentifier *string

	// The identifier of the target reserved node offering.
	TargetReservedNodeOfferingId *string

	// A list of Virtual Private Cloud (VPC) security groups to be associated with the
	// cluster. Default: The default VPC security group is associated with the cluster.
	// VPC security groups only apply to clusters in VPCs.
	VpcSecurityGroupIds []string

	noSmithyDocumentSerde
}

type RestoreFromClusterSnapshotOutput struct {

	// Describes a cluster.
	Cluster *types.Cluster

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata

	noSmithyDocumentSerde
}

func (c *Client) addOperationRestoreFromClusterSnapshotMiddlewares(stack *middleware.Stack, options Options) (err error) {
	if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil {
		return err
	}
	err = stack.Serialize.Add(&awsAwsquery_serializeOpRestoreFromClusterSnapshot{}, middleware.After)
	if err != nil {
		return err
	}
	err = stack.Deserialize.Add(&awsAwsquery_deserializeOpRestoreFromClusterSnapshot{}, middleware.After)
	if err != nil {
		return err
	}
	if err := addProtocolFinalizerMiddlewares(stack, options, "RestoreFromClusterSnapshot"); err != nil {
		return fmt.Errorf("add protocol finalizers: %v", err)
	}

	if err = addlegacyEndpointContextSetter(stack, options); err != nil {
		return err
	}
	if err = addSetLoggerMiddleware(stack, options); err != nil {
		return err
	}
	if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
		return err
	}
	if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
		return err
	}
	if err = addResolveEndpointMiddleware(stack, options); err != nil {
		return err
	}
	if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
		return err
	}
	if err = addRetryMiddlewares(stack, options); err != nil {
		return err
	}
	if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
		return err
	}
	if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
		return err
	}
	if err = addClientUserAgent(stack, options); err != nil {
		return err
	}
	if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
		return err
	}
	if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
		return err
	}
	if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil {
		return err
	}
	if err = addOpRestoreFromClusterSnapshotValidationMiddleware(stack); err != nil {
		return err
	}
	if err = stack.Initialize.Add(newServiceMetadataMiddleware_opRestoreFromClusterSnapshot(options.Region), middleware.Before); err != nil {
		return err
	}
	if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
		return err
	}
	if err = addRequestIDRetrieverMiddleware(stack); err != nil {
		return err
	}
	if err = addResponseErrorMiddleware(stack); err != nil {
		return err
	}
	if err = addRequestResponseLogging(stack, options); err != nil {
		return err
	}
	if err = addDisableHTTPSMiddleware(stack, options); err != nil {
		return err
	}
	return nil
}

func newServiceMetadataMiddleware_opRestoreFromClusterSnapshot(region string) *awsmiddleware.RegisterServiceMetadata {
	return &awsmiddleware.RegisterServiceMetadata{
		Region:        region,
		ServiceID:     ServiceID,
		OperationName: "RestoreFromClusterSnapshot",
	}
}