CreateWorkspaceRequest.h

 
#pragma once
#include <aws/core/utils/UUID.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/grafana/ManagedGrafanaRequest.h>
#include <aws/grafana/ManagedGrafana_EXPORTS.h>
#include <aws/grafana/model/AccountAccessType.h>
#include <aws/grafana/model/AuthenticationProviderTypes.h>
#include <aws/grafana/model/DataSourceType.h>
#include <aws/grafana/model/NetworkAccessConfiguration.h>
#include <aws/grafana/model/NotificationDestinationType.h>
#include <aws/grafana/model/PermissionType.h>
#include <aws/grafana/model/VpcConfiguration.h>
 
#include <utility>
 
namespace Aws {
namespace ManagedGrafana {
namespace Model {
 
class CreateWorkspaceRequest : public ManagedGrafanaRequest {
 public:
  AWS_MANAGEDGRAFANA_API CreateWorkspaceRequest() = 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 "CreateWorkspace"; }
 
  AWS_MANAGEDGRAFANA_API Aws::String SerializePayload() const override;
 
 
  inline AccountAccessType GetAccountAccessType() const { return m_accountAccessType; }
  inline bool AccountAccessTypeHasBeenSet() const { return m_accountAccessTypeHasBeenSet; }
  inline void SetAccountAccessType(AccountAccessType value) {
    m_accountAccessTypeHasBeenSet = true;
    m_accountAccessType = value;
  }
  inline CreateWorkspaceRequest& WithAccountAccessType(AccountAccessType value) {
    SetAccountAccessType(value);
    return *this;
  }
 
 
  inline const Aws::Vector<AuthenticationProviderTypes>& GetAuthenticationProviders() const { return m_authenticationProviders; }
  inline bool AuthenticationProvidersHasBeenSet() const { return m_authenticationProvidersHasBeenSet; }
  template <typename AuthenticationProvidersT = Aws::Vector<AuthenticationProviderTypes>>
  void SetAuthenticationProviders(AuthenticationProvidersT&& value) {
    m_authenticationProvidersHasBeenSet = true;
    m_authenticationProviders = std::forward<AuthenticationProvidersT>(value);
  }
  template <typename AuthenticationProvidersT = Aws::Vector<AuthenticationProviderTypes>>
  CreateWorkspaceRequest& WithAuthenticationProviders(AuthenticationProvidersT&& value) {
    SetAuthenticationProviders(std::forward<AuthenticationProvidersT>(value));
    return *this;
  }
  inline CreateWorkspaceRequest& AddAuthenticationProviders(AuthenticationProviderTypes value) {
    m_authenticationProvidersHasBeenSet = true;
    m_authenticationProviders.push_back(value);
    return *this;
  }
 
 
  inline const Aws::String& GetClientToken() const { return m_clientToken; }
  inline bool ClientTokenHasBeenSet() const { return m_clientTokenHasBeenSet; }
  template <typename ClientTokenT = Aws::String>
  void SetClientToken(ClientTokenT&& value) {
    m_clientTokenHasBeenSet = true;
    m_clientToken = std::forward<ClientTokenT>(value);
  }
  template <typename ClientTokenT = Aws::String>
  CreateWorkspaceRequest& WithClientToken(ClientTokenT&& value) {
    SetClientToken(std::forward<ClientTokenT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetConfiguration() const { return m_configuration; }
  inline bool ConfigurationHasBeenSet() const { return m_configurationHasBeenSet; }
  template <typename ConfigurationT = Aws::String>
  void SetConfiguration(ConfigurationT&& value) {
    m_configurationHasBeenSet = true;
    m_configuration = std::forward<ConfigurationT>(value);
  }
  template <typename ConfigurationT = Aws::String>
  CreateWorkspaceRequest& WithConfiguration(ConfigurationT&& value) {
    SetConfiguration(std::forward<ConfigurationT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetGrafanaVersion() const { return m_grafanaVersion; }
  inline bool GrafanaVersionHasBeenSet() const { return m_grafanaVersionHasBeenSet; }
  template <typename GrafanaVersionT = Aws::String>
  void SetGrafanaVersion(GrafanaVersionT&& value) {
    m_grafanaVersionHasBeenSet = true;
    m_grafanaVersion = std::forward<GrafanaVersionT>(value);
  }
  template <typename GrafanaVersionT = Aws::String>
  CreateWorkspaceRequest& WithGrafanaVersion(GrafanaVersionT&& value) {
    SetGrafanaVersion(std::forward<GrafanaVersionT>(value));
    return *this;
  }
 
 
  inline const NetworkAccessConfiguration& GetNetworkAccessControl() const { return m_networkAccessControl; }
  inline bool NetworkAccessControlHasBeenSet() const { return m_networkAccessControlHasBeenSet; }
  template <typename NetworkAccessControlT = NetworkAccessConfiguration>
  void SetNetworkAccessControl(NetworkAccessControlT&& value) {
    m_networkAccessControlHasBeenSet = true;
    m_networkAccessControl = std::forward<NetworkAccessControlT>(value);
  }
  template <typename NetworkAccessControlT = NetworkAccessConfiguration>
  CreateWorkspaceRequest& WithNetworkAccessControl(NetworkAccessControlT&& value) {
    SetNetworkAccessControl(std::forward<NetworkAccessControlT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetOrganizationRoleName() const { return m_organizationRoleName; }
  inline bool OrganizationRoleNameHasBeenSet() const { return m_organizationRoleNameHasBeenSet; }
  template <typename OrganizationRoleNameT = Aws::String>
  void SetOrganizationRoleName(OrganizationRoleNameT&& value) {
    m_organizationRoleNameHasBeenSet = true;
    m_organizationRoleName = std::forward<OrganizationRoleNameT>(value);
  }
  template <typename OrganizationRoleNameT = Aws::String>
  CreateWorkspaceRequest& WithOrganizationRoleName(OrganizationRoleNameT&& value) {
    SetOrganizationRoleName(std::forward<OrganizationRoleNameT>(value));
    return *this;
  }
 
 
  inline PermissionType GetPermissionType() const { return m_permissionType; }
  inline bool PermissionTypeHasBeenSet() const { return m_permissionTypeHasBeenSet; }
  inline void SetPermissionType(PermissionType value) {
    m_permissionTypeHasBeenSet = true;
    m_permissionType = value;
  }
  inline CreateWorkspaceRequest& WithPermissionType(PermissionType value) {
    SetPermissionType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetStackSetName() const { return m_stackSetName; }
  inline bool StackSetNameHasBeenSet() const { return m_stackSetNameHasBeenSet; }
  template <typename StackSetNameT = Aws::String>
  void SetStackSetName(StackSetNameT&& value) {
    m_stackSetNameHasBeenSet = true;
    m_stackSetName = std::forward<StackSetNameT>(value);
  }
  template <typename StackSetNameT = Aws::String>
  CreateWorkspaceRequest& WithStackSetName(StackSetNameT&& value) {
    SetStackSetName(std::forward<StackSetNameT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetTags() const { return m_tags; }
  inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
  template <typename TagsT = Aws::Map<Aws::String, Aws::String>>
  void SetTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags = std::forward<TagsT>(value);
  }
  template <typename TagsT = Aws::Map<Aws::String, Aws::String>>
  CreateWorkspaceRequest& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsKeyT = Aws::String, typename TagsValueT = Aws::String>
  CreateWorkspaceRequest& AddTags(TagsKeyT&& key, TagsValueT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace(std::forward<TagsKeyT>(key), std::forward<TagsValueT>(value));
    return *this;
  }
 
 
  inline const VpcConfiguration& GetVpcConfiguration() const { return m_vpcConfiguration; }
  inline bool VpcConfigurationHasBeenSet() const { return m_vpcConfigurationHasBeenSet; }
  template <typename VpcConfigurationT = VpcConfiguration>
  void SetVpcConfiguration(VpcConfigurationT&& value) {
    m_vpcConfigurationHasBeenSet = true;
    m_vpcConfiguration = std::forward<VpcConfigurationT>(value);
  }
  template <typename VpcConfigurationT = VpcConfiguration>
  CreateWorkspaceRequest& WithVpcConfiguration(VpcConfigurationT&& value) {
    SetVpcConfiguration(std::forward<VpcConfigurationT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<DataSourceType>& GetWorkspaceDataSources() const { return m_workspaceDataSources; }
  inline bool WorkspaceDataSourcesHasBeenSet() const { return m_workspaceDataSourcesHasBeenSet; }
  template <typename WorkspaceDataSourcesT = Aws::Vector<DataSourceType>>
  void SetWorkspaceDataSources(WorkspaceDataSourcesT&& value) {
    m_workspaceDataSourcesHasBeenSet = true;
    m_workspaceDataSources = std::forward<WorkspaceDataSourcesT>(value);
  }
  template <typename WorkspaceDataSourcesT = Aws::Vector<DataSourceType>>
  CreateWorkspaceRequest& WithWorkspaceDataSources(WorkspaceDataSourcesT&& value) {
    SetWorkspaceDataSources(std::forward<WorkspaceDataSourcesT>(value));
    return *this;
  }
  inline CreateWorkspaceRequest& AddWorkspaceDataSources(DataSourceType value) {
    m_workspaceDataSourcesHasBeenSet = true;
    m_workspaceDataSources.push_back(value);
    return *this;
  }
 
 
  inline const Aws::String& GetWorkspaceDescription() const { return m_workspaceDescription; }
  inline bool WorkspaceDescriptionHasBeenSet() const { return m_workspaceDescriptionHasBeenSet; }
  template <typename WorkspaceDescriptionT = Aws::String>
  void SetWorkspaceDescription(WorkspaceDescriptionT&& value) {
    m_workspaceDescriptionHasBeenSet = true;
    m_workspaceDescription = std::forward<WorkspaceDescriptionT>(value);
  }
  template <typename WorkspaceDescriptionT = Aws::String>
  CreateWorkspaceRequest& WithWorkspaceDescription(WorkspaceDescriptionT&& value) {
    SetWorkspaceDescription(std::forward<WorkspaceDescriptionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetWorkspaceName() const { return m_workspaceName; }
  inline bool WorkspaceNameHasBeenSet() const { return m_workspaceNameHasBeenSet; }
  template <typename WorkspaceNameT = Aws::String>
  void SetWorkspaceName(WorkspaceNameT&& value) {
    m_workspaceNameHasBeenSet = true;
    m_workspaceName = std::forward<WorkspaceNameT>(value);
  }
  template <typename WorkspaceNameT = Aws::String>
  CreateWorkspaceRequest& WithWorkspaceName(WorkspaceNameT&& value) {
    SetWorkspaceName(std::forward<WorkspaceNameT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<NotificationDestinationType>& GetWorkspaceNotificationDestinations() const {
    return m_workspaceNotificationDestinations;
  }
  inline bool WorkspaceNotificationDestinationsHasBeenSet() const { return m_workspaceNotificationDestinationsHasBeenSet; }
  template <typename WorkspaceNotificationDestinationsT = Aws::Vector<NotificationDestinationType>>
  void SetWorkspaceNotificationDestinations(WorkspaceNotificationDestinationsT&& value) {
    m_workspaceNotificationDestinationsHasBeenSet = true;
    m_workspaceNotificationDestinations = std::forward<WorkspaceNotificationDestinationsT>(value);
  }
  template <typename WorkspaceNotificationDestinationsT = Aws::Vector<NotificationDestinationType>>
  CreateWorkspaceRequest& WithWorkspaceNotificationDestinations(WorkspaceNotificationDestinationsT&& value) {
    SetWorkspaceNotificationDestinations(std::forward<WorkspaceNotificationDestinationsT>(value));
    return *this;
  }
  inline CreateWorkspaceRequest& AddWorkspaceNotificationDestinations(NotificationDestinationType value) {
    m_workspaceNotificationDestinationsHasBeenSet = true;
    m_workspaceNotificationDestinations.push_back(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetWorkspaceOrganizationalUnits() const { return m_workspaceOrganizationalUnits; }
  inline bool WorkspaceOrganizationalUnitsHasBeenSet() const { return m_workspaceOrganizationalUnitsHasBeenSet; }
  template <typename WorkspaceOrganizationalUnitsT = Aws::Vector<Aws::String>>
  void SetWorkspaceOrganizationalUnits(WorkspaceOrganizationalUnitsT&& value) {
    m_workspaceOrganizationalUnitsHasBeenSet = true;
    m_workspaceOrganizationalUnits = std::forward<WorkspaceOrganizationalUnitsT>(value);
  }
  template <typename WorkspaceOrganizationalUnitsT = Aws::Vector<Aws::String>>
  CreateWorkspaceRequest& WithWorkspaceOrganizationalUnits(WorkspaceOrganizationalUnitsT&& value) {
    SetWorkspaceOrganizationalUnits(std::forward<WorkspaceOrganizationalUnitsT>(value));
    return *this;
  }
  template <typename WorkspaceOrganizationalUnitsT = Aws::String>
  CreateWorkspaceRequest& AddWorkspaceOrganizationalUnits(WorkspaceOrganizationalUnitsT&& value) {
    m_workspaceOrganizationalUnitsHasBeenSet = true;
    m_workspaceOrganizationalUnits.emplace_back(std::forward<WorkspaceOrganizationalUnitsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetWorkspaceRoleArn() const { return m_workspaceRoleArn; }
  inline bool WorkspaceRoleArnHasBeenSet() const { return m_workspaceRoleArnHasBeenSet; }
  template <typename WorkspaceRoleArnT = Aws::String>
  void SetWorkspaceRoleArn(WorkspaceRoleArnT&& value) {
    m_workspaceRoleArnHasBeenSet = true;
    m_workspaceRoleArn = std::forward<WorkspaceRoleArnT>(value);
  }
  template <typename WorkspaceRoleArnT = Aws::String>
  CreateWorkspaceRequest& WithWorkspaceRoleArn(WorkspaceRoleArnT&& value) {
    SetWorkspaceRoleArn(std::forward<WorkspaceRoleArnT>(value));
    return *this;
  }
 private:
  AccountAccessType m_accountAccessType{AccountAccessType::NOT_SET};
  bool m_accountAccessTypeHasBeenSet = false;
 
  Aws::Vector<AuthenticationProviderTypes> m_authenticationProviders;
  bool m_authenticationProvidersHasBeenSet = false;
 
  Aws::String m_clientToken{Aws::Utils::UUID::PseudoRandomUUID()};
  bool m_clientTokenHasBeenSet = true;
 
  Aws::String m_configuration;
  bool m_configurationHasBeenSet = false;
 
  Aws::String m_grafanaVersion;
  bool m_grafanaVersionHasBeenSet = false;
 
  NetworkAccessConfiguration m_networkAccessControl;
  bool m_networkAccessControlHasBeenSet = false;
 
  Aws::String m_organizationRoleName;
  bool m_organizationRoleNameHasBeenSet = false;
 
  PermissionType m_permissionType{PermissionType::NOT_SET};
  bool m_permissionTypeHasBeenSet = false;
 
  Aws::String m_stackSetName;
  bool m_stackSetNameHasBeenSet = false;
 
  Aws::Map<Aws::String, Aws::String> m_tags;
  bool m_tagsHasBeenSet = false;
 
  VpcConfiguration m_vpcConfiguration;
  bool m_vpcConfigurationHasBeenSet = false;
 
  Aws::Vector<DataSourceType> m_workspaceDataSources;
  bool m_workspaceDataSourcesHasBeenSet = false;
 
  Aws::String m_workspaceDescription;
  bool m_workspaceDescriptionHasBeenSet = false;
 
  Aws::String m_workspaceName;
  bool m_workspaceNameHasBeenSet = false;
 
  Aws::Vector<NotificationDestinationType> m_workspaceNotificationDestinations;
  bool m_workspaceNotificationDestinationsHasBeenSet = false;
 
  Aws::Vector<Aws::String> m_workspaceOrganizationalUnits;
  bool m_workspaceOrganizationalUnitsHasBeenSet = false;
 
  Aws::String m_workspaceRoleArn;
  bool m_workspaceRoleArnHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ManagedGrafana
}  // namespace Aws