Account.h

 
#pragma once
#include <aws/chime/Chime_EXPORTS.h>
#include <aws/chime/model/AccountStatus.h>
#include <aws/chime/model/AccountType.h>
#include <aws/chime/model/License.h>
#include <aws/chime/model/SigninDelegateGroup.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 {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Chime {
namespace Model {
 
class Account {
 public:
  AWS_CHIME_API Account() = default;
  AWS_CHIME_API Account(Aws::Utils::Json::JsonView jsonValue);
  AWS_CHIME_API Account& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_CHIME_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetAwsAccountId() const { return m_awsAccountId; }
  inline bool AwsAccountIdHasBeenSet() const { return m_awsAccountIdHasBeenSet; }
  template <typename AwsAccountIdT = Aws::String>
  void SetAwsAccountId(AwsAccountIdT&& value) {
    m_awsAccountIdHasBeenSet = true;
    m_awsAccountId = std::forward<AwsAccountIdT>(value);
  }
  template <typename AwsAccountIdT = Aws::String>
  Account& WithAwsAccountId(AwsAccountIdT&& value) {
    SetAwsAccountId(std::forward<AwsAccountIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAccountId() const { return m_accountId; }
  inline bool AccountIdHasBeenSet() const { return m_accountIdHasBeenSet; }
  template <typename AccountIdT = Aws::String>
  void SetAccountId(AccountIdT&& value) {
    m_accountIdHasBeenSet = true;
    m_accountId = std::forward<AccountIdT>(value);
  }
  template <typename AccountIdT = Aws::String>
  Account& WithAccountId(AccountIdT&& value) {
    SetAccountId(std::forward<AccountIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetName() const { return m_name; }
  inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
  template <typename NameT = Aws::String>
  void SetName(NameT&& value) {
    m_nameHasBeenSet = true;
    m_name = std::forward<NameT>(value);
  }
  template <typename NameT = Aws::String>
  Account& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline AccountType GetAccountType() const { return m_accountType; }
  inline bool AccountTypeHasBeenSet() const { return m_accountTypeHasBeenSet; }
  inline void SetAccountType(AccountType value) {
    m_accountTypeHasBeenSet = true;
    m_accountType = value;
  }
  inline Account& WithAccountType(AccountType value) {
    SetAccountType(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreatedTimestamp() const { return m_createdTimestamp; }
  inline bool CreatedTimestampHasBeenSet() const { return m_createdTimestampHasBeenSet; }
  template <typename CreatedTimestampT = Aws::Utils::DateTime>
  void SetCreatedTimestamp(CreatedTimestampT&& value) {
    m_createdTimestampHasBeenSet = true;
    m_createdTimestamp = std::forward<CreatedTimestampT>(value);
  }
  template <typename CreatedTimestampT = Aws::Utils::DateTime>
  Account& WithCreatedTimestamp(CreatedTimestampT&& value) {
    SetCreatedTimestamp(std::forward<CreatedTimestampT>(value));
    return *this;
  }
 
 
  inline License GetDefaultLicense() const { return m_defaultLicense; }
  inline bool DefaultLicenseHasBeenSet() const { return m_defaultLicenseHasBeenSet; }
  inline void SetDefaultLicense(License value) {
    m_defaultLicenseHasBeenSet = true;
    m_defaultLicense = value;
  }
  inline Account& WithDefaultLicense(License value) {
    SetDefaultLicense(value);
    return *this;
  }
 
 
  inline const Aws::Vector<License>& GetSupportedLicenses() const { return m_supportedLicenses; }
  inline bool SupportedLicensesHasBeenSet() const { return m_supportedLicensesHasBeenSet; }
  template <typename SupportedLicensesT = Aws::Vector<License>>
  void SetSupportedLicenses(SupportedLicensesT&& value) {
    m_supportedLicensesHasBeenSet = true;
    m_supportedLicenses = std::forward<SupportedLicensesT>(value);
  }
  template <typename SupportedLicensesT = Aws::Vector<License>>
  Account& WithSupportedLicenses(SupportedLicensesT&& value) {
    SetSupportedLicenses(std::forward<SupportedLicensesT>(value));
    return *this;
  }
  inline Account& AddSupportedLicenses(License value) {
    m_supportedLicensesHasBeenSet = true;
    m_supportedLicenses.push_back(value);
    return *this;
  }
 
 
  inline AccountStatus GetAccountStatus() const { return m_accountStatus; }
  inline bool AccountStatusHasBeenSet() const { return m_accountStatusHasBeenSet; }
  inline void SetAccountStatus(AccountStatus value) {
    m_accountStatusHasBeenSet = true;
    m_accountStatus = value;
  }
  inline Account& WithAccountStatus(AccountStatus value) {
    SetAccountStatus(value);
    return *this;
  }
 
 
  inline const Aws::Vector<SigninDelegateGroup>& GetSigninDelegateGroups() const { return m_signinDelegateGroups; }
  inline bool SigninDelegateGroupsHasBeenSet() const { return m_signinDelegateGroupsHasBeenSet; }
  template <typename SigninDelegateGroupsT = Aws::Vector<SigninDelegateGroup>>
  void SetSigninDelegateGroups(SigninDelegateGroupsT&& value) {
    m_signinDelegateGroupsHasBeenSet = true;
    m_signinDelegateGroups = std::forward<SigninDelegateGroupsT>(value);
  }
  template <typename SigninDelegateGroupsT = Aws::Vector<SigninDelegateGroup>>
  Account& WithSigninDelegateGroups(SigninDelegateGroupsT&& value) {
    SetSigninDelegateGroups(std::forward<SigninDelegateGroupsT>(value));
    return *this;
  }
  template <typename SigninDelegateGroupsT = SigninDelegateGroup>
  Account& AddSigninDelegateGroups(SigninDelegateGroupsT&& value) {
    m_signinDelegateGroupsHasBeenSet = true;
    m_signinDelegateGroups.emplace_back(std::forward<SigninDelegateGroupsT>(value));
    return *this;
  }
 private:
  Aws::String m_awsAccountId;
 
  Aws::String m_accountId;
 
  Aws::String m_name;
 
  AccountType m_accountType{AccountType::NOT_SET};
 
  Aws::Utils::DateTime m_createdTimestamp{};
 
  License m_defaultLicense{License::NOT_SET};
 
  Aws::Vector<License> m_supportedLicenses;
 
  AccountStatus m_accountStatus{AccountStatus::NOT_SET};
 
  Aws::Vector<SigninDelegateGroup> m_signinDelegateGroups;
  bool m_awsAccountIdHasBeenSet = false;
  bool m_accountIdHasBeenSet = false;
  bool m_nameHasBeenSet = false;
  bool m_accountTypeHasBeenSet = false;
  bool m_createdTimestampHasBeenSet = false;
  bool m_defaultLicenseHasBeenSet = false;
  bool m_supportedLicensesHasBeenSet = false;
  bool m_accountStatusHasBeenSet = false;
  bool m_signinDelegateGroupsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Chime
}  // namespace Aws