CreateAppRequest.h

 
#pragma once
#include <aws/amplify/AmplifyRequest.h>
#include <aws/amplify/Amplify_EXPORTS.h>
#include <aws/amplify/model/AutoBranchCreationConfig.h>
#include <aws/amplify/model/CacheConfig.h>
#include <aws/amplify/model/CustomRule.h>
#include <aws/amplify/model/JobConfig.h>
#include <aws/amplify/model/Platform.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 <utility>
 
namespace Aws {
namespace Amplify {
namespace Model {
 
class CreateAppRequest : public AmplifyRequest {
 public:
  AWS_AMPLIFY_API CreateAppRequest() = 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 "CreateApp"; }
 
  AWS_AMPLIFY_API Aws::String SerializePayload() const override;
 
 
  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>
  CreateAppRequest& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDescription() const { return m_description; }
  inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
  template <typename DescriptionT = Aws::String>
  void SetDescription(DescriptionT&& value) {
    m_descriptionHasBeenSet = true;
    m_description = std::forward<DescriptionT>(value);
  }
  template <typename DescriptionT = Aws::String>
  CreateAppRequest& WithDescription(DescriptionT&& value) {
    SetDescription(std::forward<DescriptionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRepository() const { return m_repository; }
  inline bool RepositoryHasBeenSet() const { return m_repositoryHasBeenSet; }
  template <typename RepositoryT = Aws::String>
  void SetRepository(RepositoryT&& value) {
    m_repositoryHasBeenSet = true;
    m_repository = std::forward<RepositoryT>(value);
  }
  template <typename RepositoryT = Aws::String>
  CreateAppRequest& WithRepository(RepositoryT&& value) {
    SetRepository(std::forward<RepositoryT>(value));
    return *this;
  }
 
 
  inline Platform GetPlatform() const { return m_platform; }
  inline bool PlatformHasBeenSet() const { return m_platformHasBeenSet; }
  inline void SetPlatform(Platform value) {
    m_platformHasBeenSet = true;
    m_platform = value;
  }
  inline CreateAppRequest& WithPlatform(Platform value) {
    SetPlatform(value);
    return *this;
  }
 
 
  inline const Aws::String& GetComputeRoleArn() const { return m_computeRoleArn; }
  inline bool ComputeRoleArnHasBeenSet() const { return m_computeRoleArnHasBeenSet; }
  template <typename ComputeRoleArnT = Aws::String>
  void SetComputeRoleArn(ComputeRoleArnT&& value) {
    m_computeRoleArnHasBeenSet = true;
    m_computeRoleArn = std::forward<ComputeRoleArnT>(value);
  }
  template <typename ComputeRoleArnT = Aws::String>
  CreateAppRequest& WithComputeRoleArn(ComputeRoleArnT&& value) {
    SetComputeRoleArn(std::forward<ComputeRoleArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetIamServiceRoleArn() const { return m_iamServiceRoleArn; }
  inline bool IamServiceRoleArnHasBeenSet() const { return m_iamServiceRoleArnHasBeenSet; }
  template <typename IamServiceRoleArnT = Aws::String>
  void SetIamServiceRoleArn(IamServiceRoleArnT&& value) {
    m_iamServiceRoleArnHasBeenSet = true;
    m_iamServiceRoleArn = std::forward<IamServiceRoleArnT>(value);
  }
  template <typename IamServiceRoleArnT = Aws::String>
  CreateAppRequest& WithIamServiceRoleArn(IamServiceRoleArnT&& value) {
    SetIamServiceRoleArn(std::forward<IamServiceRoleArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetOauthToken() const { return m_oauthToken; }
  inline bool OauthTokenHasBeenSet() const { return m_oauthTokenHasBeenSet; }
  template <typename OauthTokenT = Aws::String>
  void SetOauthToken(OauthTokenT&& value) {
    m_oauthTokenHasBeenSet = true;
    m_oauthToken = std::forward<OauthTokenT>(value);
  }
  template <typename OauthTokenT = Aws::String>
  CreateAppRequest& WithOauthToken(OauthTokenT&& value) {
    SetOauthToken(std::forward<OauthTokenT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAccessToken() const { return m_accessToken; }
  inline bool AccessTokenHasBeenSet() const { return m_accessTokenHasBeenSet; }
  template <typename AccessTokenT = Aws::String>
  void SetAccessToken(AccessTokenT&& value) {
    m_accessTokenHasBeenSet = true;
    m_accessToken = std::forward<AccessTokenT>(value);
  }
  template <typename AccessTokenT = Aws::String>
  CreateAppRequest& WithAccessToken(AccessTokenT&& value) {
    SetAccessToken(std::forward<AccessTokenT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetEnvironmentVariables() const { return m_environmentVariables; }
  inline bool EnvironmentVariablesHasBeenSet() const { return m_environmentVariablesHasBeenSet; }
  template <typename EnvironmentVariablesT = Aws::Map<Aws::String, Aws::String>>
  void SetEnvironmentVariables(EnvironmentVariablesT&& value) {
    m_environmentVariablesHasBeenSet = true;
    m_environmentVariables = std::forward<EnvironmentVariablesT>(value);
  }
  template <typename EnvironmentVariablesT = Aws::Map<Aws::String, Aws::String>>
  CreateAppRequest& WithEnvironmentVariables(EnvironmentVariablesT&& value) {
    SetEnvironmentVariables(std::forward<EnvironmentVariablesT>(value));
    return *this;
  }
  template <typename EnvironmentVariablesKeyT = Aws::String, typename EnvironmentVariablesValueT = Aws::String>
  CreateAppRequest& AddEnvironmentVariables(EnvironmentVariablesKeyT&& key, EnvironmentVariablesValueT&& value) {
    m_environmentVariablesHasBeenSet = true;
    m_environmentVariables.emplace(std::forward<EnvironmentVariablesKeyT>(key), std::forward<EnvironmentVariablesValueT>(value));
    return *this;
  }
 
 
  inline bool GetEnableBranchAutoBuild() const { return m_enableBranchAutoBuild; }
  inline bool EnableBranchAutoBuildHasBeenSet() const { return m_enableBranchAutoBuildHasBeenSet; }
  inline void SetEnableBranchAutoBuild(bool value) {
    m_enableBranchAutoBuildHasBeenSet = true;
    m_enableBranchAutoBuild = value;
  }
  inline CreateAppRequest& WithEnableBranchAutoBuild(bool value) {
    SetEnableBranchAutoBuild(value);
    return *this;
  }
 
 
  inline bool GetEnableBranchAutoDeletion() const { return m_enableBranchAutoDeletion; }
  inline bool EnableBranchAutoDeletionHasBeenSet() const { return m_enableBranchAutoDeletionHasBeenSet; }
  inline void SetEnableBranchAutoDeletion(bool value) {
    m_enableBranchAutoDeletionHasBeenSet = true;
    m_enableBranchAutoDeletion = value;
  }
  inline CreateAppRequest& WithEnableBranchAutoDeletion(bool value) {
    SetEnableBranchAutoDeletion(value);
    return *this;
  }
 
 
  inline bool GetEnableBasicAuth() const { return m_enableBasicAuth; }
  inline bool EnableBasicAuthHasBeenSet() const { return m_enableBasicAuthHasBeenSet; }
  inline void SetEnableBasicAuth(bool value) {
    m_enableBasicAuthHasBeenSet = true;
    m_enableBasicAuth = value;
  }
  inline CreateAppRequest& WithEnableBasicAuth(bool value) {
    SetEnableBasicAuth(value);
    return *this;
  }
 
 
  inline const Aws::String& GetBasicAuthCredentials() const { return m_basicAuthCredentials; }
  inline bool BasicAuthCredentialsHasBeenSet() const { return m_basicAuthCredentialsHasBeenSet; }
  template <typename BasicAuthCredentialsT = Aws::String>
  void SetBasicAuthCredentials(BasicAuthCredentialsT&& value) {
    m_basicAuthCredentialsHasBeenSet = true;
    m_basicAuthCredentials = std::forward<BasicAuthCredentialsT>(value);
  }
  template <typename BasicAuthCredentialsT = Aws::String>
  CreateAppRequest& WithBasicAuthCredentials(BasicAuthCredentialsT&& value) {
    SetBasicAuthCredentials(std::forward<BasicAuthCredentialsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<CustomRule>& GetCustomRules() const { return m_customRules; }
  inline bool CustomRulesHasBeenSet() const { return m_customRulesHasBeenSet; }
  template <typename CustomRulesT = Aws::Vector<CustomRule>>
  void SetCustomRules(CustomRulesT&& value) {
    m_customRulesHasBeenSet = true;
    m_customRules = std::forward<CustomRulesT>(value);
  }
  template <typename CustomRulesT = Aws::Vector<CustomRule>>
  CreateAppRequest& WithCustomRules(CustomRulesT&& value) {
    SetCustomRules(std::forward<CustomRulesT>(value));
    return *this;
  }
  template <typename CustomRulesT = CustomRule>
  CreateAppRequest& AddCustomRules(CustomRulesT&& value) {
    m_customRulesHasBeenSet = true;
    m_customRules.emplace_back(std::forward<CustomRulesT>(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>>
  CreateAppRequest& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsKeyT = Aws::String, typename TagsValueT = Aws::String>
  CreateAppRequest& AddTags(TagsKeyT&& key, TagsValueT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace(std::forward<TagsKeyT>(key), std::forward<TagsValueT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetBuildSpec() const { return m_buildSpec; }
  inline bool BuildSpecHasBeenSet() const { return m_buildSpecHasBeenSet; }
  template <typename BuildSpecT = Aws::String>
  void SetBuildSpec(BuildSpecT&& value) {
    m_buildSpecHasBeenSet = true;
    m_buildSpec = std::forward<BuildSpecT>(value);
  }
  template <typename BuildSpecT = Aws::String>
  CreateAppRequest& WithBuildSpec(BuildSpecT&& value) {
    SetBuildSpec(std::forward<BuildSpecT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCustomHeaders() const { return m_customHeaders; }
  inline bool CustomHeadersHasBeenSet() const { return m_customHeadersHasBeenSet; }
  template <typename CustomHeadersT = Aws::String>
  void SetCustomHeaders(CustomHeadersT&& value) {
    m_customHeadersHasBeenSet = true;
    m_customHeaders = std::forward<CustomHeadersT>(value);
  }
  template <typename CustomHeadersT = Aws::String>
  CreateAppRequest& WithCustomHeaders(CustomHeadersT&& value) {
    SetCustomHeaders(std::forward<CustomHeadersT>(value));
    return *this;
  }
 
 
  inline bool GetEnableAutoBranchCreation() const { return m_enableAutoBranchCreation; }
  inline bool EnableAutoBranchCreationHasBeenSet() const { return m_enableAutoBranchCreationHasBeenSet; }
  inline void SetEnableAutoBranchCreation(bool value) {
    m_enableAutoBranchCreationHasBeenSet = true;
    m_enableAutoBranchCreation = value;
  }
  inline CreateAppRequest& WithEnableAutoBranchCreation(bool value) {
    SetEnableAutoBranchCreation(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetAutoBranchCreationPatterns() const { return m_autoBranchCreationPatterns; }
  inline bool AutoBranchCreationPatternsHasBeenSet() const { return m_autoBranchCreationPatternsHasBeenSet; }
  template <typename AutoBranchCreationPatternsT = Aws::Vector<Aws::String>>
  void SetAutoBranchCreationPatterns(AutoBranchCreationPatternsT&& value) {
    m_autoBranchCreationPatternsHasBeenSet = true;
    m_autoBranchCreationPatterns = std::forward<AutoBranchCreationPatternsT>(value);
  }
  template <typename AutoBranchCreationPatternsT = Aws::Vector<Aws::String>>
  CreateAppRequest& WithAutoBranchCreationPatterns(AutoBranchCreationPatternsT&& value) {
    SetAutoBranchCreationPatterns(std::forward<AutoBranchCreationPatternsT>(value));
    return *this;
  }
  template <typename AutoBranchCreationPatternsT = Aws::String>
  CreateAppRequest& AddAutoBranchCreationPatterns(AutoBranchCreationPatternsT&& value) {
    m_autoBranchCreationPatternsHasBeenSet = true;
    m_autoBranchCreationPatterns.emplace_back(std::forward<AutoBranchCreationPatternsT>(value));
    return *this;
  }
 
 
  inline const AutoBranchCreationConfig& GetAutoBranchCreationConfig() const { return m_autoBranchCreationConfig; }
  inline bool AutoBranchCreationConfigHasBeenSet() const { return m_autoBranchCreationConfigHasBeenSet; }
  template <typename AutoBranchCreationConfigT = AutoBranchCreationConfig>
  void SetAutoBranchCreationConfig(AutoBranchCreationConfigT&& value) {
    m_autoBranchCreationConfigHasBeenSet = true;
    m_autoBranchCreationConfig = std::forward<AutoBranchCreationConfigT>(value);
  }
  template <typename AutoBranchCreationConfigT = AutoBranchCreationConfig>
  CreateAppRequest& WithAutoBranchCreationConfig(AutoBranchCreationConfigT&& value) {
    SetAutoBranchCreationConfig(std::forward<AutoBranchCreationConfigT>(value));
    return *this;
  }
 
 
  inline const JobConfig& GetJobConfig() const { return m_jobConfig; }
  inline bool JobConfigHasBeenSet() const { return m_jobConfigHasBeenSet; }
  template <typename JobConfigT = JobConfig>
  void SetJobConfig(JobConfigT&& value) {
    m_jobConfigHasBeenSet = true;
    m_jobConfig = std::forward<JobConfigT>(value);
  }
  template <typename JobConfigT = JobConfig>
  CreateAppRequest& WithJobConfig(JobConfigT&& value) {
    SetJobConfig(std::forward<JobConfigT>(value));
    return *this;
  }
 
 
  inline const CacheConfig& GetCacheConfig() const { return m_cacheConfig; }
  inline bool CacheConfigHasBeenSet() const { return m_cacheConfigHasBeenSet; }
  template <typename CacheConfigT = CacheConfig>
  void SetCacheConfig(CacheConfigT&& value) {
    m_cacheConfigHasBeenSet = true;
    m_cacheConfig = std::forward<CacheConfigT>(value);
  }
  template <typename CacheConfigT = CacheConfig>
  CreateAppRequest& WithCacheConfig(CacheConfigT&& value) {
    SetCacheConfig(std::forward<CacheConfigT>(value));
    return *this;
  }
 private:
  Aws::String m_name;
 
  Aws::String m_description;
 
  Aws::String m_repository;
 
  Platform m_platform{Platform::NOT_SET};
 
  Aws::String m_computeRoleArn;
 
  Aws::String m_iamServiceRoleArn;
 
  Aws::String m_oauthToken;
 
  Aws::String m_accessToken;
 
  Aws::Map<Aws::String, Aws::String> m_environmentVariables;
 
  bool m_enableBranchAutoBuild{false};
 
  bool m_enableBranchAutoDeletion{false};
 
  bool m_enableBasicAuth{false};
 
  Aws::String m_basicAuthCredentials;
 
  Aws::Vector<CustomRule> m_customRules;
 
  Aws::Map<Aws::String, Aws::String> m_tags;
 
  Aws::String m_buildSpec;
 
  Aws::String m_customHeaders;
 
  bool m_enableAutoBranchCreation{false};
 
  Aws::Vector<Aws::String> m_autoBranchCreationPatterns;
 
  AutoBranchCreationConfig m_autoBranchCreationConfig;
 
  JobConfig m_jobConfig;
 
  CacheConfig m_cacheConfig;
  bool m_nameHasBeenSet = false;
  bool m_descriptionHasBeenSet = false;
  bool m_repositoryHasBeenSet = false;
  bool m_platformHasBeenSet = false;
  bool m_computeRoleArnHasBeenSet = false;
  bool m_iamServiceRoleArnHasBeenSet = false;
  bool m_oauthTokenHasBeenSet = false;
  bool m_accessTokenHasBeenSet = false;
  bool m_environmentVariablesHasBeenSet = false;
  bool m_enableBranchAutoBuildHasBeenSet = false;
  bool m_enableBranchAutoDeletionHasBeenSet = false;
  bool m_enableBasicAuthHasBeenSet = false;
  bool m_basicAuthCredentialsHasBeenSet = false;
  bool m_customRulesHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_buildSpecHasBeenSet = false;
  bool m_customHeadersHasBeenSet = false;
  bool m_enableAutoBranchCreationHasBeenSet = false;
  bool m_autoBranchCreationPatternsHasBeenSet = false;
  bool m_autoBranchCreationConfigHasBeenSet = false;
  bool m_jobConfigHasBeenSet = false;
  bool m_cacheConfigHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Amplify
}  // namespace Aws