CreateUserRequest.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/awstransfer/model/Tag.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 CreateUserRequest : public TransferRequest {
 public:
  AWS_TRANSFER_API CreateUserRequest() = 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 "CreateUser"; }
 
  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>
  CreateUserRequest& 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 CreateUserRequest& 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>>
  CreateUserRequest& WithHomeDirectoryMappings(HomeDirectoryMappingsT&& value) {
    SetHomeDirectoryMappings(std::forward<HomeDirectoryMappingsT>(value));
    return *this;
  }
  template <typename HomeDirectoryMappingsT = HomeDirectoryMapEntry>
  CreateUserRequest& 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>
  CreateUserRequest& 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>
  CreateUserRequest& 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>
  CreateUserRequest& 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>
  CreateUserRequest& WithServerId(ServerIdT&& value) {
    SetServerId(std::forward<ServerIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSshPublicKeyBody() const { return m_sshPublicKeyBody; }
  inline bool SshPublicKeyBodyHasBeenSet() const { return m_sshPublicKeyBodyHasBeenSet; }
  template <typename SshPublicKeyBodyT = Aws::String>
  void SetSshPublicKeyBody(SshPublicKeyBodyT&& value) {
    m_sshPublicKeyBodyHasBeenSet = true;
    m_sshPublicKeyBody = std::forward<SshPublicKeyBodyT>(value);
  }
  template <typename SshPublicKeyBodyT = Aws::String>
  CreateUserRequest& WithSshPublicKeyBody(SshPublicKeyBodyT&& value) {
    SetSshPublicKeyBody(std::forward<SshPublicKeyBodyT>(value));
    return *this;
  }
 
 
  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>>
  CreateUserRequest& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsT = Tag>
  CreateUserRequest& AddTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace_back(std::forward<TagsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetUserName() const { return m_userName; }
  inline bool UserNameHasBeenSet() const { return m_userNameHasBeenSet; }
  template <typename UserNameT = Aws::String>
  void SetUserName(UserNameT&& value) {
    m_userNameHasBeenSet = true;
    m_userName = std::forward<UserNameT>(value);
  }
  template <typename UserNameT = Aws::String>
  CreateUserRequest& WithUserName(UserNameT&& value) {
    SetUserName(std::forward<UserNameT>(value));
    return *this;
  }
 private:
  Aws::String m_homeDirectory;
 
  HomeDirectoryType m_homeDirectoryType{HomeDirectoryType::NOT_SET};
 
  Aws::Vector<HomeDirectoryMapEntry> m_homeDirectoryMappings;
 
  Aws::String m_policy;
 
  PosixProfile m_posixProfile;
 
  Aws::String m_role;
 
  Aws::String m_serverId;
 
  Aws::String m_sshPublicKeyBody;
 
  Aws::Vector<Tag> m_tags;
 
  Aws::String m_userName;
  bool m_homeDirectoryHasBeenSet = false;
  bool m_homeDirectoryTypeHasBeenSet = false;
  bool m_homeDirectoryMappingsHasBeenSet = false;
  bool m_policyHasBeenSet = false;
  bool m_posixProfileHasBeenSet = false;
  bool m_roleHasBeenSet = false;
  bool m_serverIdHasBeenSet = false;
  bool m_sshPublicKeyBodyHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_userNameHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Transfer
}  // namespace Aws