CreateAccessRequest.h

 
#pragma once
#include <aws/awstransfer/TransferRequest.h>
#include <aws/awstransfer/Transfer_EXPORTS.h>
#include <aws/awstransfer/model/HomeDirectoryMapEntry.h>
#include <aws/awstransfer/model/HomeDirectoryType.h>
#include <aws/awstransfer/model/PosixProfile.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
 
#include <utility>
 
namespace Aws {
namespace Transfer {
namespace Model {
 
class CreateAccessRequest : public TransferRequest {
 public:
  AWS_TRANSFER_API CreateAccessRequest() = 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 "CreateAccess"; }
 
  AWS_TRANSFER_API Aws::String SerializePayload() const override;
 
  AWS_TRANSFER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
 
 
  inline const Aws::String& GetHomeDirectory() const { return m_homeDirectory; }
  inline bool HomeDirectoryHasBeenSet() const { return m_homeDirectoryHasBeenSet; }
  template <typename HomeDirectoryT = Aws::String>
  void SetHomeDirectory(HomeDirectoryT&& value) {
    m_homeDirectoryHasBeenSet = true;
    m_homeDirectory = std::forward<HomeDirectoryT>(value);
  }
  template <typename HomeDirectoryT = Aws::String>
  CreateAccessRequest& WithHomeDirectory(HomeDirectoryT&& value) {
    SetHomeDirectory(std::forward<HomeDirectoryT>(value));
    return *this;
  }
 
 
  inline HomeDirectoryType GetHomeDirectoryType() const { return m_homeDirectoryType; }
  inline bool HomeDirectoryTypeHasBeenSet() const { return m_homeDirectoryTypeHasBeenSet; }
  inline void SetHomeDirectoryType(HomeDirectoryType value) {
    m_homeDirectoryTypeHasBeenSet = true;
    m_homeDirectoryType = value;
  }
  inline CreateAccessRequest& WithHomeDirectoryType(HomeDirectoryType value) {
    SetHomeDirectoryType(value);
    return *this;
  }
 
 
  inline const Aws::Vector<HomeDirectoryMapEntry>& GetHomeDirectoryMappings() const { return m_homeDirectoryMappings; }
  inline bool HomeDirectoryMappingsHasBeenSet() const { return m_homeDirectoryMappingsHasBeenSet; }
  template <typename HomeDirectoryMappingsT = Aws::Vector<HomeDirectoryMapEntry>>
  void SetHomeDirectoryMappings(HomeDirectoryMappingsT&& value) {
    m_homeDirectoryMappingsHasBeenSet = true;
    m_homeDirectoryMappings = std::forward<HomeDirectoryMappingsT>(value);
  }
  template <typename HomeDirectoryMappingsT = Aws::Vector<HomeDirectoryMapEntry>>
  CreateAccessRequest& WithHomeDirectoryMappings(HomeDirectoryMappingsT&& value) {
    SetHomeDirectoryMappings(std::forward<HomeDirectoryMappingsT>(value));
    return *this;
  }
  template <typename HomeDirectoryMappingsT = HomeDirectoryMapEntry>
  CreateAccessRequest& AddHomeDirectoryMappings(HomeDirectoryMappingsT&& value) {
    m_homeDirectoryMappingsHasBeenSet = true;
    m_homeDirectoryMappings.emplace_back(std::forward<HomeDirectoryMappingsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPolicy() const { return m_policy; }
  inline bool PolicyHasBeenSet() const { return m_policyHasBeenSet; }
  template <typename PolicyT = Aws::String>
  void SetPolicy(PolicyT&& value) {
    m_policyHasBeenSet = true;
    m_policy = std::forward<PolicyT>(value);
  }
  template <typename PolicyT = Aws::String>
  CreateAccessRequest& WithPolicy(PolicyT&& value) {
    SetPolicy(std::forward<PolicyT>(value));
    return *this;
  }
 
 
  inline const PosixProfile& GetPosixProfile() const { return m_posixProfile; }
  inline bool PosixProfileHasBeenSet() const { return m_posixProfileHasBeenSet; }
  template <typename PosixProfileT = PosixProfile>
  void SetPosixProfile(PosixProfileT&& value) {
    m_posixProfileHasBeenSet = true;
    m_posixProfile = std::forward<PosixProfileT>(value);
  }
  template <typename PosixProfileT = PosixProfile>
  CreateAccessRequest& WithPosixProfile(PosixProfileT&& value) {
    SetPosixProfile(std::forward<PosixProfileT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRole() const { return m_role; }
  inline bool RoleHasBeenSet() const { return m_roleHasBeenSet; }
  template <typename RoleT = Aws::String>
  void SetRole(RoleT&& value) {
    m_roleHasBeenSet = true;
    m_role = std::forward<RoleT>(value);
  }
  template <typename RoleT = Aws::String>
  CreateAccessRequest& WithRole(RoleT&& value) {
    SetRole(std::forward<RoleT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetServerId() const { return m_serverId; }
  inline bool ServerIdHasBeenSet() const { return m_serverIdHasBeenSet; }
  template <typename ServerIdT = Aws::String>
  void SetServerId(ServerIdT&& value) {
    m_serverIdHasBeenSet = true;
    m_serverId = std::forward<ServerIdT>(value);
  }
  template <typename ServerIdT = Aws::String>
  CreateAccessRequest& WithServerId(ServerIdT&& value) {
    SetServerId(std::forward<ServerIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExternalId() const { return m_externalId; }
  inline bool ExternalIdHasBeenSet() const { return m_externalIdHasBeenSet; }
  template <typename ExternalIdT = Aws::String>
  void SetExternalId(ExternalIdT&& value) {
    m_externalIdHasBeenSet = true;
    m_externalId = std::forward<ExternalIdT>(value);
  }
  template <typename ExternalIdT = Aws::String>
  CreateAccessRequest& WithExternalId(ExternalIdT&& value) {
    SetExternalId(std::forward<ExternalIdT>(value));
    return *this;
  }
 private:
  Aws::String m_homeDirectory;
  bool m_homeDirectoryHasBeenSet = false;
 
  HomeDirectoryType m_homeDirectoryType{HomeDirectoryType::NOT_SET};
  bool m_homeDirectoryTypeHasBeenSet = false;
 
  Aws::Vector<HomeDirectoryMapEntry> m_homeDirectoryMappings;
  bool m_homeDirectoryMappingsHasBeenSet = false;
 
  Aws::String m_policy;
  bool m_policyHasBeenSet = false;
 
  PosixProfile m_posixProfile;
  bool m_posixProfileHasBeenSet = false;
 
  Aws::String m_role;
  bool m_roleHasBeenSet = false;
 
  Aws::String m_serverId;
  bool m_serverIdHasBeenSet = false;
 
  Aws::String m_externalId;
  bool m_externalIdHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Transfer
}  // namespace Aws