CreateWorkspaceRequest.h

 
#pragma once
#include <aws/grafana/ManagedGrafana_EXPORTS.h>
#include <aws/grafana/ManagedGrafanaRequest.h>
#include <aws/grafana/model/AccountAccessType.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/grafana/model/NetworkAccessConfiguration.h>
#include <aws/grafana/model/PermissionType.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/grafana/model/VpcConfiguration.h>
#include <aws/grafana/model/AuthenticationProviderTypes.h>
#include <aws/grafana/model/DataSourceType.h>
#include <aws/grafana/model/NotificationDestinationType.h>
#include <utility>
#include <aws/core/utils/UUID.h>
 
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