/**
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 * SPDX-License-Identifier: Apache-2.0.
 */

#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/neptune/NeptuneRequest.h>
#include <aws/neptune/Neptune_EXPORTS.h>
#include <aws/neptune/model/Tag.h>

#include <utility>

namespace Aws {
namespace Neptune {
namespace Model {

/**
 */
class CopyDBClusterSnapshotRequest : public NeptuneRequest {
 public:
  AWS_NEPTUNE_API CopyDBClusterSnapshotRequest() = default;

  // Service request name is the Operation name which will send this request out,
  // each operation should has unique request name, so that we can get operation's name from this request.
  // Note: this is not true for response, multiple operations may have the same response name,
  // so we can not get operation's name from response.
  inline virtual const char* GetServiceRequestName() const override { return "CopyDBClusterSnapshot"; }

  AWS_NEPTUNE_API Aws::String SerializePayload() const override;

 protected:
  AWS_NEPTUNE_API void DumpBodyToUrl(Aws::Http::URI& uri) const override;

 public:
  ///@{
  /**
   * <p>The identifier of the DB cluster snapshot to copy. This parameter is not
   * case-sensitive. If the source DB cluster snapshot is in a different region or
   * owned by another account, specify the snapshot ARN.</p> <p>Constraints:</p> <ul>
   * <li> <p>Must specify a valid system snapshot in the "available" state.</p> </li>
   * <li> <p>Specify a valid DB snapshot identifier.</p> </li> </ul> <p>Example:
   * <code>my-cluster-snapshot1</code> </p>
   */
  inline const Aws::String& GetSourceDBClusterSnapshotIdentifier() const { return m_sourceDBClusterSnapshotIdentifier; }
  inline bool SourceDBClusterSnapshotIdentifierHasBeenSet() const { return m_sourceDBClusterSnapshotIdentifierHasBeenSet; }
  template <typename SourceDBClusterSnapshotIdentifierT = Aws::String>
  void SetSourceDBClusterSnapshotIdentifier(SourceDBClusterSnapshotIdentifierT&& value) {
    m_sourceDBClusterSnapshotIdentifierHasBeenSet = true;
    m_sourceDBClusterSnapshotIdentifier = std::forward<SourceDBClusterSnapshotIdentifierT>(value);
  }
  template <typename SourceDBClusterSnapshotIdentifierT = Aws::String>
  CopyDBClusterSnapshotRequest& WithSourceDBClusterSnapshotIdentifier(SourceDBClusterSnapshotIdentifierT&& value) {
    SetSourceDBClusterSnapshotIdentifier(std::forward<SourceDBClusterSnapshotIdentifierT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The identifier of the new DB cluster snapshot to create from the source DB
   * cluster snapshot. This parameter is not case-sensitive.</p> <p>Constraints:</p>
   * <ul> <li> <p>Must contain from 1 to 63 letters, numbers, or hyphens.</p> </li>
   * <li> <p>First character must be a letter.</p> </li> <li> <p>Cannot end with a
   * hyphen or contain two consecutive hyphens.</p> </li> </ul> <p>Example:
   * <code>my-cluster-snapshot2</code> </p>
   */
  inline const Aws::String& GetTargetDBClusterSnapshotIdentifier() const { return m_targetDBClusterSnapshotIdentifier; }
  inline bool TargetDBClusterSnapshotIdentifierHasBeenSet() const { return m_targetDBClusterSnapshotIdentifierHasBeenSet; }
  template <typename TargetDBClusterSnapshotIdentifierT = Aws::String>
  void SetTargetDBClusterSnapshotIdentifier(TargetDBClusterSnapshotIdentifierT&& value) {
    m_targetDBClusterSnapshotIdentifierHasBeenSet = true;
    m_targetDBClusterSnapshotIdentifier = std::forward<TargetDBClusterSnapshotIdentifierT>(value);
  }
  template <typename TargetDBClusterSnapshotIdentifierT = Aws::String>
  CopyDBClusterSnapshotRequest& WithTargetDBClusterSnapshotIdentifier(TargetDBClusterSnapshotIdentifierT&& value) {
    SetTargetDBClusterSnapshotIdentifier(std::forward<TargetDBClusterSnapshotIdentifierT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The Amazon Amazon KMS key ID for an encrypted DB cluster snapshot. The KMS
   * key ID is the Amazon Resource Name (ARN), KMS key identifier, or the KMS key
   * alias for the KMS encryption key.</p> <p>If you copy an encrypted DB cluster
   * snapshot from your Amazon account, you can specify a value for
   * <code>KmsKeyId</code> to encrypt the copy with a new KMS encryption key. If you
   * don't specify a value for <code>KmsKeyId</code>, then the copy of the DB cluster
   * snapshot is encrypted with the same KMS key as the source DB cluster
   * snapshot.</p> <p>If you copy an encrypted DB cluster snapshot that is shared
   * from another Amazon account, then you must specify a value for
   * <code>KmsKeyId</code>.</p> <p> KMS encryption keys are specific to the Amazon
   * Region that they are created in, and you can't use encryption keys from one
   * Amazon Region in another Amazon Region.</p> <p>You cannot encrypt an unencrypted
   * DB cluster snapshot when you copy it. If you try to copy an unencrypted DB
   * cluster snapshot and specify a value for the KmsKeyId parameter, an error is
   * returned.</p>
   */
  inline const Aws::String& GetKmsKeyId() const { return m_kmsKeyId; }
  inline bool KmsKeyIdHasBeenSet() const { return m_kmsKeyIdHasBeenSet; }
  template <typename KmsKeyIdT = Aws::String>
  void SetKmsKeyId(KmsKeyIdT&& value) {
    m_kmsKeyIdHasBeenSet = true;
    m_kmsKeyId = std::forward<KmsKeyIdT>(value);
  }
  template <typename KmsKeyIdT = Aws::String>
  CopyDBClusterSnapshotRequest& WithKmsKeyId(KmsKeyIdT&& value) {
    SetKmsKeyId(std::forward<KmsKeyIdT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>Not currently supported.</p>
   */
  inline const Aws::String& GetPreSignedUrl() const { return m_preSignedUrl; }
  inline bool PreSignedUrlHasBeenSet() const { return m_preSignedUrlHasBeenSet; }
  template <typename PreSignedUrlT = Aws::String>
  void SetPreSignedUrl(PreSignedUrlT&& value) {
    m_preSignedUrlHasBeenSet = true;
    m_preSignedUrl = std::forward<PreSignedUrlT>(value);
  }
  template <typename PreSignedUrlT = Aws::String>
  CopyDBClusterSnapshotRequest& WithPreSignedUrl(PreSignedUrlT&& value) {
    SetPreSignedUrl(std::forward<PreSignedUrlT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>True to copy all tags from the source DB cluster snapshot to the target DB
   * cluster snapshot, and otherwise false. The default is false.</p>
   */
  inline bool GetCopyTags() const { return m_copyTags; }
  inline bool CopyTagsHasBeenSet() const { return m_copyTagsHasBeenSet; }
  inline void SetCopyTags(bool value) {
    m_copyTagsHasBeenSet = true;
    m_copyTags = value;
  }
  inline CopyDBClusterSnapshotRequest& WithCopyTags(bool value) {
    SetCopyTags(value);
    return *this;
  }
  ///@}

  ///@{
  /**
   * <p>The tags to assign to the new DB cluster snapshot copy.</p>
   */
  inline const Aws::Vector<Tag>& GetTags() const { return m_tags; }
  inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
  template <typename TagsT = Aws::Vector<Tag>>
  void SetTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags = std::forward<TagsT>(value);
  }
  template <typename TagsT = Aws::Vector<Tag>>
  CopyDBClusterSnapshotRequest& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsT = Tag>
  CopyDBClusterSnapshotRequest& AddTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace_back(std::forward<TagsT>(value));
    return *this;
  }
  ///@}

  ///@{
  /**
   * If SourceRegion is specified, SDKs will generate pre-signed URLs and populate the pre-signed URL field.
   */
  inline const Aws::String& GetSourceRegion() const { return m_sourceRegion; }
  inline bool SourceRegionHasBeenSet() const { return m_sourceRegionHasBeenSet; }
  template <typename SourceRegionT = Aws::String>
  void SetSourceRegion(SourceRegionT&& value) {
    m_sourceRegionHasBeenSet = true;
    m_sourceRegion = std::forward<SourceRegionT>(value);
  }
  template <typename SourceRegionT = Aws::String>
  CopyDBClusterSnapshotRequest& WithSourceRegion(SourceRegionT&& value) {
    SetSourceRegion(std::forward<SourceRegionT>(value));
    return *this;
  }
  ///@}
 private:
  Aws::String m_sourceDBClusterSnapshotIdentifier;

  Aws::String m_targetDBClusterSnapshotIdentifier;

  Aws::String m_kmsKeyId;

  Aws::String m_preSignedUrl;

  bool m_copyTags{false};

  Aws::Vector<Tag> m_tags;

  Aws::String m_sourceRegion;
  bool m_sourceDBClusterSnapshotIdentifierHasBeenSet = false;
  bool m_targetDBClusterSnapshotIdentifierHasBeenSet = false;
  bool m_kmsKeyIdHasBeenSet = false;
  bool m_preSignedUrlHasBeenSet = false;
  bool m_copyTagsHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_sourceRegionHasBeenSet = false;
};

}  // namespace Model
}  // namespace Neptune
}  // namespace Aws
