CreateAccountSubscriptionRequest.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/quicksight/QuickSightRequest.h>
#include <aws/quicksight/QuickSight_EXPORTS.h>
#include <aws/quicksight/model/AuthenticationMethodOption.h>
#include <aws/quicksight/model/Edition.h>
 
#include <utility>
 
namespace Aws {
namespace QuickSight {
namespace Model {
 
class CreateAccountSubscriptionRequest : public QuickSightRequest {
 public:
  AWS_QUICKSIGHT_API CreateAccountSubscriptionRequest() = 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 "CreateAccountSubscription"; }
 
  AWS_QUICKSIGHT_API Aws::String SerializePayload() const override;
 
 
  inline Edition GetEdition() const { return m_edition; }
  inline bool EditionHasBeenSet() const { return m_editionHasBeenSet; }
  inline void SetEdition(Edition value) {
    m_editionHasBeenSet = true;
    m_edition = value;
  }
  inline CreateAccountSubscriptionRequest& WithEdition(Edition value) {
    SetEdition(value);
    return *this;
  }
 
 
  inline AuthenticationMethodOption GetAuthenticationMethod() const { return m_authenticationMethod; }
  inline bool AuthenticationMethodHasBeenSet() const { return m_authenticationMethodHasBeenSet; }
  inline void SetAuthenticationMethod(AuthenticationMethodOption value) {
    m_authenticationMethodHasBeenSet = true;
    m_authenticationMethod = value;
  }
  inline CreateAccountSubscriptionRequest& WithAuthenticationMethod(AuthenticationMethodOption value) {
    SetAuthenticationMethod(value);
    return *this;
  }
 
 
  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>
  CreateAccountSubscriptionRequest& WithAwsAccountId(AwsAccountIdT&& value) {
    SetAwsAccountId(std::forward<AwsAccountIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAccountName() const { return m_accountName; }
  inline bool AccountNameHasBeenSet() const { return m_accountNameHasBeenSet; }
  template <typename AccountNameT = Aws::String>
  void SetAccountName(AccountNameT&& value) {
    m_accountNameHasBeenSet = true;
    m_accountName = std::forward<AccountNameT>(value);
  }
  template <typename AccountNameT = Aws::String>
  CreateAccountSubscriptionRequest& WithAccountName(AccountNameT&& value) {
    SetAccountName(std::forward<AccountNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetNotificationEmail() const { return m_notificationEmail; }
  inline bool NotificationEmailHasBeenSet() const { return m_notificationEmailHasBeenSet; }
  template <typename NotificationEmailT = Aws::String>
  void SetNotificationEmail(NotificationEmailT&& value) {
    m_notificationEmailHasBeenSet = true;
    m_notificationEmail = std::forward<NotificationEmailT>(value);
  }
  template <typename NotificationEmailT = Aws::String>
  CreateAccountSubscriptionRequest& WithNotificationEmail(NotificationEmailT&& value) {
    SetNotificationEmail(std::forward<NotificationEmailT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetActiveDirectoryName() const { return m_activeDirectoryName; }
  inline bool ActiveDirectoryNameHasBeenSet() const { return m_activeDirectoryNameHasBeenSet; }
  template <typename ActiveDirectoryNameT = Aws::String>
  void SetActiveDirectoryName(ActiveDirectoryNameT&& value) {
    m_activeDirectoryNameHasBeenSet = true;
    m_activeDirectoryName = std::forward<ActiveDirectoryNameT>(value);
  }
  template <typename ActiveDirectoryNameT = Aws::String>
  CreateAccountSubscriptionRequest& WithActiveDirectoryName(ActiveDirectoryNameT&& value) {
    SetActiveDirectoryName(std::forward<ActiveDirectoryNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRealm() const { return m_realm; }
  inline bool RealmHasBeenSet() const { return m_realmHasBeenSet; }
  template <typename RealmT = Aws::String>
  void SetRealm(RealmT&& value) {
    m_realmHasBeenSet = true;
    m_realm = std::forward<RealmT>(value);
  }
  template <typename RealmT = Aws::String>
  CreateAccountSubscriptionRequest& WithRealm(RealmT&& value) {
    SetRealm(std::forward<RealmT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDirectoryId() const { return m_directoryId; }
  inline bool DirectoryIdHasBeenSet() const { return m_directoryIdHasBeenSet; }
  template <typename DirectoryIdT = Aws::String>
  void SetDirectoryId(DirectoryIdT&& value) {
    m_directoryIdHasBeenSet = true;
    m_directoryId = std::forward<DirectoryIdT>(value);
  }
  template <typename DirectoryIdT = Aws::String>
  CreateAccountSubscriptionRequest& WithDirectoryId(DirectoryIdT&& value) {
    SetDirectoryId(std::forward<DirectoryIdT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetAdminGroup() const { return m_adminGroup; }
  inline bool AdminGroupHasBeenSet() const { return m_adminGroupHasBeenSet; }
  template <typename AdminGroupT = Aws::Vector<Aws::String>>
  void SetAdminGroup(AdminGroupT&& value) {
    m_adminGroupHasBeenSet = true;
    m_adminGroup = std::forward<AdminGroupT>(value);
  }
  template <typename AdminGroupT = Aws::Vector<Aws::String>>
  CreateAccountSubscriptionRequest& WithAdminGroup(AdminGroupT&& value) {
    SetAdminGroup(std::forward<AdminGroupT>(value));
    return *this;
  }
  template <typename AdminGroupT = Aws::String>
  CreateAccountSubscriptionRequest& AddAdminGroup(AdminGroupT&& value) {
    m_adminGroupHasBeenSet = true;
    m_adminGroup.emplace_back(std::forward<AdminGroupT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetAuthorGroup() const { return m_authorGroup; }
  inline bool AuthorGroupHasBeenSet() const { return m_authorGroupHasBeenSet; }
  template <typename AuthorGroupT = Aws::Vector<Aws::String>>
  void SetAuthorGroup(AuthorGroupT&& value) {
    m_authorGroupHasBeenSet = true;
    m_authorGroup = std::forward<AuthorGroupT>(value);
  }
  template <typename AuthorGroupT = Aws::Vector<Aws::String>>
  CreateAccountSubscriptionRequest& WithAuthorGroup(AuthorGroupT&& value) {
    SetAuthorGroup(std::forward<AuthorGroupT>(value));
    return *this;
  }
  template <typename AuthorGroupT = Aws::String>
  CreateAccountSubscriptionRequest& AddAuthorGroup(AuthorGroupT&& value) {
    m_authorGroupHasBeenSet = true;
    m_authorGroup.emplace_back(std::forward<AuthorGroupT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetReaderGroup() const { return m_readerGroup; }
  inline bool ReaderGroupHasBeenSet() const { return m_readerGroupHasBeenSet; }
  template <typename ReaderGroupT = Aws::Vector<Aws::String>>
  void SetReaderGroup(ReaderGroupT&& value) {
    m_readerGroupHasBeenSet = true;
    m_readerGroup = std::forward<ReaderGroupT>(value);
  }
  template <typename ReaderGroupT = Aws::Vector<Aws::String>>
  CreateAccountSubscriptionRequest& WithReaderGroup(ReaderGroupT&& value) {
    SetReaderGroup(std::forward<ReaderGroupT>(value));
    return *this;
  }
  template <typename ReaderGroupT = Aws::String>
  CreateAccountSubscriptionRequest& AddReaderGroup(ReaderGroupT&& value) {
    m_readerGroupHasBeenSet = true;
    m_readerGroup.emplace_back(std::forward<ReaderGroupT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetAdminProGroup() const { return m_adminProGroup; }
  inline bool AdminProGroupHasBeenSet() const { return m_adminProGroupHasBeenSet; }
  template <typename AdminProGroupT = Aws::Vector<Aws::String>>
  void SetAdminProGroup(AdminProGroupT&& value) {
    m_adminProGroupHasBeenSet = true;
    m_adminProGroup = std::forward<AdminProGroupT>(value);
  }
  template <typename AdminProGroupT = Aws::Vector<Aws::String>>
  CreateAccountSubscriptionRequest& WithAdminProGroup(AdminProGroupT&& value) {
    SetAdminProGroup(std::forward<AdminProGroupT>(value));
    return *this;
  }
  template <typename AdminProGroupT = Aws::String>
  CreateAccountSubscriptionRequest& AddAdminProGroup(AdminProGroupT&& value) {
    m_adminProGroupHasBeenSet = true;
    m_adminProGroup.emplace_back(std::forward<AdminProGroupT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetAuthorProGroup() const { return m_authorProGroup; }
  inline bool AuthorProGroupHasBeenSet() const { return m_authorProGroupHasBeenSet; }
  template <typename AuthorProGroupT = Aws::Vector<Aws::String>>
  void SetAuthorProGroup(AuthorProGroupT&& value) {
    m_authorProGroupHasBeenSet = true;
    m_authorProGroup = std::forward<AuthorProGroupT>(value);
  }
  template <typename AuthorProGroupT = Aws::Vector<Aws::String>>
  CreateAccountSubscriptionRequest& WithAuthorProGroup(AuthorProGroupT&& value) {
    SetAuthorProGroup(std::forward<AuthorProGroupT>(value));
    return *this;
  }
  template <typename AuthorProGroupT = Aws::String>
  CreateAccountSubscriptionRequest& AddAuthorProGroup(AuthorProGroupT&& value) {
    m_authorProGroupHasBeenSet = true;
    m_authorProGroup.emplace_back(std::forward<AuthorProGroupT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetReaderProGroup() const { return m_readerProGroup; }
  inline bool ReaderProGroupHasBeenSet() const { return m_readerProGroupHasBeenSet; }
  template <typename ReaderProGroupT = Aws::Vector<Aws::String>>
  void SetReaderProGroup(ReaderProGroupT&& value) {
    m_readerProGroupHasBeenSet = true;
    m_readerProGroup = std::forward<ReaderProGroupT>(value);
  }
  template <typename ReaderProGroupT = Aws::Vector<Aws::String>>
  CreateAccountSubscriptionRequest& WithReaderProGroup(ReaderProGroupT&& value) {
    SetReaderProGroup(std::forward<ReaderProGroupT>(value));
    return *this;
  }
  template <typename ReaderProGroupT = Aws::String>
  CreateAccountSubscriptionRequest& AddReaderProGroup(ReaderProGroupT&& value) {
    m_readerProGroupHasBeenSet = true;
    m_readerProGroup.emplace_back(std::forward<ReaderProGroupT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetFirstName() const { return m_firstName; }
  inline bool FirstNameHasBeenSet() const { return m_firstNameHasBeenSet; }
  template <typename FirstNameT = Aws::String>
  void SetFirstName(FirstNameT&& value) {
    m_firstNameHasBeenSet = true;
    m_firstName = std::forward<FirstNameT>(value);
  }
  template <typename FirstNameT = Aws::String>
  CreateAccountSubscriptionRequest& WithFirstName(FirstNameT&& value) {
    SetFirstName(std::forward<FirstNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLastName() const { return m_lastName; }
  inline bool LastNameHasBeenSet() const { return m_lastNameHasBeenSet; }
  template <typename LastNameT = Aws::String>
  void SetLastName(LastNameT&& value) {
    m_lastNameHasBeenSet = true;
    m_lastName = std::forward<LastNameT>(value);
  }
  template <typename LastNameT = Aws::String>
  CreateAccountSubscriptionRequest& WithLastName(LastNameT&& value) {
    SetLastName(std::forward<LastNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEmailAddress() const { return m_emailAddress; }
  inline bool EmailAddressHasBeenSet() const { return m_emailAddressHasBeenSet; }
  template <typename EmailAddressT = Aws::String>
  void SetEmailAddress(EmailAddressT&& value) {
    m_emailAddressHasBeenSet = true;
    m_emailAddress = std::forward<EmailAddressT>(value);
  }
  template <typename EmailAddressT = Aws::String>
  CreateAccountSubscriptionRequest& WithEmailAddress(EmailAddressT&& value) {
    SetEmailAddress(std::forward<EmailAddressT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetContactNumber() const { return m_contactNumber; }
  inline bool ContactNumberHasBeenSet() const { return m_contactNumberHasBeenSet; }
  template <typename ContactNumberT = Aws::String>
  void SetContactNumber(ContactNumberT&& value) {
    m_contactNumberHasBeenSet = true;
    m_contactNumber = std::forward<ContactNumberT>(value);
  }
  template <typename ContactNumberT = Aws::String>
  CreateAccountSubscriptionRequest& WithContactNumber(ContactNumberT&& value) {
    SetContactNumber(std::forward<ContactNumberT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetIAMIdentityCenterInstanceArn() const { return m_iAMIdentityCenterInstanceArn; }
  inline bool IAMIdentityCenterInstanceArnHasBeenSet() const { return m_iAMIdentityCenterInstanceArnHasBeenSet; }
  template <typename IAMIdentityCenterInstanceArnT = Aws::String>
  void SetIAMIdentityCenterInstanceArn(IAMIdentityCenterInstanceArnT&& value) {
    m_iAMIdentityCenterInstanceArnHasBeenSet = true;
    m_iAMIdentityCenterInstanceArn = std::forward<IAMIdentityCenterInstanceArnT>(value);
  }
  template <typename IAMIdentityCenterInstanceArnT = Aws::String>
  CreateAccountSubscriptionRequest& WithIAMIdentityCenterInstanceArn(IAMIdentityCenterInstanceArnT&& value) {
    SetIAMIdentityCenterInstanceArn(std::forward<IAMIdentityCenterInstanceArnT>(value));
    return *this;
  }
 private:
  Edition m_edition{Edition::NOT_SET};
 
  AuthenticationMethodOption m_authenticationMethod{AuthenticationMethodOption::NOT_SET};
 
  Aws::String m_awsAccountId;
 
  Aws::String m_accountName;
 
  Aws::String m_notificationEmail;
 
  Aws::String m_activeDirectoryName;
 
  Aws::String m_realm;
 
  Aws::String m_directoryId;
 
  Aws::Vector<Aws::String> m_adminGroup;
 
  Aws::Vector<Aws::String> m_authorGroup;
 
  Aws::Vector<Aws::String> m_readerGroup;
 
  Aws::Vector<Aws::String> m_adminProGroup;
 
  Aws::Vector<Aws::String> m_authorProGroup;
 
  Aws::Vector<Aws::String> m_readerProGroup;
 
  Aws::String m_firstName;
 
  Aws::String m_lastName;
 
  Aws::String m_emailAddress;
 
  Aws::String m_contactNumber;
 
  Aws::String m_iAMIdentityCenterInstanceArn;
  bool m_editionHasBeenSet = false;
  bool m_authenticationMethodHasBeenSet = false;
  bool m_awsAccountIdHasBeenSet = false;
  bool m_accountNameHasBeenSet = false;
  bool m_notificationEmailHasBeenSet = false;
  bool m_activeDirectoryNameHasBeenSet = false;
  bool m_realmHasBeenSet = false;
  bool m_directoryIdHasBeenSet = false;
  bool m_adminGroupHasBeenSet = false;
  bool m_authorGroupHasBeenSet = false;
  bool m_readerGroupHasBeenSet = false;
  bool m_adminProGroupHasBeenSet = false;
  bool m_authorProGroupHasBeenSet = false;
  bool m_readerProGroupHasBeenSet = false;
  bool m_firstNameHasBeenSet = false;
  bool m_lastNameHasBeenSet = false;
  bool m_emailAddressHasBeenSet = false;
  bool m_contactNumberHasBeenSet = false;
  bool m_iAMIdentityCenterInstanceArnHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace QuickSight
}  // namespace Aws