AdminGetUserResult.h

 
#pragma once
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
#include <aws/cognito-idp/model/AttributeType.h>
#include <aws/cognito-idp/model/MFAOptionType.h>
#include <aws/cognito-idp/model/UserStatusType.h>
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
 
#include <utility>
 
namespace Aws {
template <typename RESULT_TYPE>
class AmazonWebServiceResult;
 
namespace Utils {
namespace Json {
class JsonValue;
}  // namespace Json
}  // namespace Utils
namespace CognitoIdentityProvider {
namespace Model {
class AdminGetUserResult {
 public:
  AWS_COGNITOIDENTITYPROVIDER_API AdminGetUserResult() = default;
  AWS_COGNITOIDENTITYPROVIDER_API AdminGetUserResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
  AWS_COGNITOIDENTITYPROVIDER_API AdminGetUserResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
 
 
  inline const Aws::String& GetUsername() const { return m_username; }
  template <typename UsernameT = Aws::String>
  void SetUsername(UsernameT&& value) {
    m_usernameHasBeenSet = true;
    m_username = std::forward<UsernameT>(value);
  }
  template <typename UsernameT = Aws::String>
  AdminGetUserResult& WithUsername(UsernameT&& value) {
    SetUsername(std::forward<UsernameT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<AttributeType>& GetUserAttributes() const { return m_userAttributes; }
  template <typename UserAttributesT = Aws::Vector<AttributeType>>
  void SetUserAttributes(UserAttributesT&& value) {
    m_userAttributesHasBeenSet = true;
    m_userAttributes = std::forward<UserAttributesT>(value);
  }
  template <typename UserAttributesT = Aws::Vector<AttributeType>>
  AdminGetUserResult& WithUserAttributes(UserAttributesT&& value) {
    SetUserAttributes(std::forward<UserAttributesT>(value));
    return *this;
  }
  template <typename UserAttributesT = AttributeType>
  AdminGetUserResult& AddUserAttributes(UserAttributesT&& value) {
    m_userAttributesHasBeenSet = true;
    m_userAttributes.emplace_back(std::forward<UserAttributesT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetUserCreateDate() const { return m_userCreateDate; }
  template <typename UserCreateDateT = Aws::Utils::DateTime>
  void SetUserCreateDate(UserCreateDateT&& value) {
    m_userCreateDateHasBeenSet = true;
    m_userCreateDate = std::forward<UserCreateDateT>(value);
  }
  template <typename UserCreateDateT = Aws::Utils::DateTime>
  AdminGetUserResult& WithUserCreateDate(UserCreateDateT&& value) {
    SetUserCreateDate(std::forward<UserCreateDateT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetUserLastModifiedDate() const { return m_userLastModifiedDate; }
  template <typename UserLastModifiedDateT = Aws::Utils::DateTime>
  void SetUserLastModifiedDate(UserLastModifiedDateT&& value) {
    m_userLastModifiedDateHasBeenSet = true;
    m_userLastModifiedDate = std::forward<UserLastModifiedDateT>(value);
  }
  template <typename UserLastModifiedDateT = Aws::Utils::DateTime>
  AdminGetUserResult& WithUserLastModifiedDate(UserLastModifiedDateT&& value) {
    SetUserLastModifiedDate(std::forward<UserLastModifiedDateT>(value));
    return *this;
  }
 
 
  inline bool GetEnabled() const { return m_enabled; }
  inline void SetEnabled(bool value) {
    m_enabledHasBeenSet = true;
    m_enabled = value;
  }
  inline AdminGetUserResult& WithEnabled(bool value) {
    SetEnabled(value);
    return *this;
  }
 
 
  inline UserStatusType GetUserStatus() const { return m_userStatus; }
  inline void SetUserStatus(UserStatusType value) {
    m_userStatusHasBeenSet = true;
    m_userStatus = value;
  }
  inline AdminGetUserResult& WithUserStatus(UserStatusType value) {
    SetUserStatus(value);
    return *this;
  }
 
 
  inline const Aws::Vector<MFAOptionType>& GetMFAOptions() const { return m_mFAOptions; }
  template <typename MFAOptionsT = Aws::Vector<MFAOptionType>>
  void SetMFAOptions(MFAOptionsT&& value) {
    m_mFAOptionsHasBeenSet = true;
    m_mFAOptions = std::forward<MFAOptionsT>(value);
  }
  template <typename MFAOptionsT = Aws::Vector<MFAOptionType>>
  AdminGetUserResult& WithMFAOptions(MFAOptionsT&& value) {
    SetMFAOptions(std::forward<MFAOptionsT>(value));
    return *this;
  }
  template <typename MFAOptionsT = MFAOptionType>
  AdminGetUserResult& AddMFAOptions(MFAOptionsT&& value) {
    m_mFAOptionsHasBeenSet = true;
    m_mFAOptions.emplace_back(std::forward<MFAOptionsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPreferredMfaSetting() const { return m_preferredMfaSetting; }
  template <typename PreferredMfaSettingT = Aws::String>
  void SetPreferredMfaSetting(PreferredMfaSettingT&& value) {
    m_preferredMfaSettingHasBeenSet = true;
    m_preferredMfaSetting = std::forward<PreferredMfaSettingT>(value);
  }
  template <typename PreferredMfaSettingT = Aws::String>
  AdminGetUserResult& WithPreferredMfaSetting(PreferredMfaSettingT&& value) {
    SetPreferredMfaSetting(std::forward<PreferredMfaSettingT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetUserMFASettingList() const { return m_userMFASettingList; }
  template <typename UserMFASettingListT = Aws::Vector<Aws::String>>
  void SetUserMFASettingList(UserMFASettingListT&& value) {
    m_userMFASettingListHasBeenSet = true;
    m_userMFASettingList = std::forward<UserMFASettingListT>(value);
  }
  template <typename UserMFASettingListT = Aws::Vector<Aws::String>>
  AdminGetUserResult& WithUserMFASettingList(UserMFASettingListT&& value) {
    SetUserMFASettingList(std::forward<UserMFASettingListT>(value));
    return *this;
  }
  template <typename UserMFASettingListT = Aws::String>
  AdminGetUserResult& AddUserMFASettingList(UserMFASettingListT&& value) {
    m_userMFASettingListHasBeenSet = true;
    m_userMFASettingList.emplace_back(std::forward<UserMFASettingListT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRequestId() const { return m_requestId; }
  template <typename RequestIdT = Aws::String>
  void SetRequestId(RequestIdT&& value) {
    m_requestIdHasBeenSet = true;
    m_requestId = std::forward<RequestIdT>(value);
  }
  template <typename RequestIdT = Aws::String>
  AdminGetUserResult& WithRequestId(RequestIdT&& value) {
    SetRequestId(std::forward<RequestIdT>(value));
    return *this;
  }
 private:
  Aws::String m_username;
 
  Aws::Vector<AttributeType> m_userAttributes;
 
  Aws::Utils::DateTime m_userCreateDate{};
 
  Aws::Utils::DateTime m_userLastModifiedDate{};
 
  bool m_enabled{false};
 
  UserStatusType m_userStatus{UserStatusType::NOT_SET};
 
  Aws::Vector<MFAOptionType> m_mFAOptions;
 
  Aws::String m_preferredMfaSetting;
 
  Aws::Vector<Aws::String> m_userMFASettingList;
 
  Aws::String m_requestId;
  bool m_usernameHasBeenSet = false;
  bool m_userAttributesHasBeenSet = false;
  bool m_userCreateDateHasBeenSet = false;
  bool m_userLastModifiedDateHasBeenSet = false;
  bool m_enabledHasBeenSet = false;
  bool m_userStatusHasBeenSet = false;
  bool m_mFAOptionsHasBeenSet = false;
  bool m_preferredMfaSettingHasBeenSet = false;
  bool m_userMFASettingListHasBeenSet = false;
  bool m_requestIdHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace CognitoIdentityProvider
}  // namespace Aws