Project.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/partnercentral-selling/PartnerCentralSelling_EXPORTS.h>
#include <aws/partnercentral-selling/model/AwsPartition.h>
#include <aws/partnercentral-selling/model/CompetitorName.h>
#include <aws/partnercentral-selling/model/DeliveryModel.h>
#include <aws/partnercentral-selling/model/ExpectedContractDuration.h>
#include <aws/partnercentral-selling/model/ExpectedCustomerSpend.h>
#include <aws/partnercentral-selling/model/SalesActivity.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace PartnerCentralSelling {
namespace Model {
 
class Project {
 public:
  AWS_PARTNERCENTRALSELLING_API Project() = default;
  AWS_PARTNERCENTRALSELLING_API Project(Aws::Utils::Json::JsonView jsonValue);
  AWS_PARTNERCENTRALSELLING_API Project& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_PARTNERCENTRALSELLING_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::Vector<DeliveryModel>& GetDeliveryModels() const { return m_deliveryModels; }
  inline bool DeliveryModelsHasBeenSet() const { return m_deliveryModelsHasBeenSet; }
  template <typename DeliveryModelsT = Aws::Vector<DeliveryModel>>
  void SetDeliveryModels(DeliveryModelsT&& value) {
    m_deliveryModelsHasBeenSet = true;
    m_deliveryModels = std::forward<DeliveryModelsT>(value);
  }
  template <typename DeliveryModelsT = Aws::Vector<DeliveryModel>>
  Project& WithDeliveryModels(DeliveryModelsT&& value) {
    SetDeliveryModels(std::forward<DeliveryModelsT>(value));
    return *this;
  }
  inline Project& AddDeliveryModels(DeliveryModel value) {
    m_deliveryModelsHasBeenSet = true;
    m_deliveryModels.push_back(value);
    return *this;
  }
 
 
  inline const Aws::Vector<ExpectedCustomerSpend>& GetExpectedCustomerSpend() const { return m_expectedCustomerSpend; }
  inline bool ExpectedCustomerSpendHasBeenSet() const { return m_expectedCustomerSpendHasBeenSet; }
  template <typename ExpectedCustomerSpendT = Aws::Vector<ExpectedCustomerSpend>>
  void SetExpectedCustomerSpend(ExpectedCustomerSpendT&& value) {
    m_expectedCustomerSpendHasBeenSet = true;
    m_expectedCustomerSpend = std::forward<ExpectedCustomerSpendT>(value);
  }
  template <typename ExpectedCustomerSpendT = Aws::Vector<ExpectedCustomerSpend>>
  Project& WithExpectedCustomerSpend(ExpectedCustomerSpendT&& value) {
    SetExpectedCustomerSpend(std::forward<ExpectedCustomerSpendT>(value));
    return *this;
  }
  template <typename ExpectedCustomerSpendT = ExpectedCustomerSpend>
  Project& AddExpectedCustomerSpend(ExpectedCustomerSpendT&& value) {
    m_expectedCustomerSpendHasBeenSet = true;
    m_expectedCustomerSpend.emplace_back(std::forward<ExpectedCustomerSpendT>(value));
    return *this;
  }
 
 
  inline const ExpectedContractDuration& GetExpectedContractDuration() const { return m_expectedContractDuration; }
  inline bool ExpectedContractDurationHasBeenSet() const { return m_expectedContractDurationHasBeenSet; }
  template <typename ExpectedContractDurationT = ExpectedContractDuration>
  void SetExpectedContractDuration(ExpectedContractDurationT&& value) {
    m_expectedContractDurationHasBeenSet = true;
    m_expectedContractDuration = std::forward<ExpectedContractDurationT>(value);
  }
  template <typename ExpectedContractDurationT = ExpectedContractDuration>
  Project& WithExpectedContractDuration(ExpectedContractDurationT&& value) {
    SetExpectedContractDuration(std::forward<ExpectedContractDurationT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTitle() const { return m_title; }
  inline bool TitleHasBeenSet() const { return m_titleHasBeenSet; }
  template <typename TitleT = Aws::String>
  void SetTitle(TitleT&& value) {
    m_titleHasBeenSet = true;
    m_title = std::forward<TitleT>(value);
  }
  template <typename TitleT = Aws::String>
  Project& WithTitle(TitleT&& value) {
    SetTitle(std::forward<TitleT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetApnPrograms() const { return m_apnPrograms; }
  inline bool ApnProgramsHasBeenSet() const { return m_apnProgramsHasBeenSet; }
  template <typename ApnProgramsT = Aws::Vector<Aws::String>>
  void SetApnPrograms(ApnProgramsT&& value) {
    m_apnProgramsHasBeenSet = true;
    m_apnPrograms = std::forward<ApnProgramsT>(value);
  }
  template <typename ApnProgramsT = Aws::Vector<Aws::String>>
  Project& WithApnPrograms(ApnProgramsT&& value) {
    SetApnPrograms(std::forward<ApnProgramsT>(value));
    return *this;
  }
  template <typename ApnProgramsT = Aws::String>
  Project& AddApnPrograms(ApnProgramsT&& value) {
    m_apnProgramsHasBeenSet = true;
    m_apnPrograms.emplace_back(std::forward<ApnProgramsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCustomerBusinessProblem() const { return m_customerBusinessProblem; }
  inline bool CustomerBusinessProblemHasBeenSet() const { return m_customerBusinessProblemHasBeenSet; }
  template <typename CustomerBusinessProblemT = Aws::String>
  void SetCustomerBusinessProblem(CustomerBusinessProblemT&& value) {
    m_customerBusinessProblemHasBeenSet = true;
    m_customerBusinessProblem = std::forward<CustomerBusinessProblemT>(value);
  }
  template <typename CustomerBusinessProblemT = Aws::String>
  Project& WithCustomerBusinessProblem(CustomerBusinessProblemT&& value) {
    SetCustomerBusinessProblem(std::forward<CustomerBusinessProblemT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCustomerUseCase() const { return m_customerUseCase; }
  inline bool CustomerUseCaseHasBeenSet() const { return m_customerUseCaseHasBeenSet; }
  template <typename CustomerUseCaseT = Aws::String>
  void SetCustomerUseCase(CustomerUseCaseT&& value) {
    m_customerUseCaseHasBeenSet = true;
    m_customerUseCase = std::forward<CustomerUseCaseT>(value);
  }
  template <typename CustomerUseCaseT = Aws::String>
  Project& WithCustomerUseCase(CustomerUseCaseT&& value) {
    SetCustomerUseCase(std::forward<CustomerUseCaseT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRelatedOpportunityIdentifier() const { return m_relatedOpportunityIdentifier; }
  inline bool RelatedOpportunityIdentifierHasBeenSet() const { return m_relatedOpportunityIdentifierHasBeenSet; }
  template <typename RelatedOpportunityIdentifierT = Aws::String>
  void SetRelatedOpportunityIdentifier(RelatedOpportunityIdentifierT&& value) {
    m_relatedOpportunityIdentifierHasBeenSet = true;
    m_relatedOpportunityIdentifier = std::forward<RelatedOpportunityIdentifierT>(value);
  }
  template <typename RelatedOpportunityIdentifierT = Aws::String>
  Project& WithRelatedOpportunityIdentifier(RelatedOpportunityIdentifierT&& value) {
    SetRelatedOpportunityIdentifier(std::forward<RelatedOpportunityIdentifierT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<SalesActivity>& GetSalesActivities() const { return m_salesActivities; }
  inline bool SalesActivitiesHasBeenSet() const { return m_salesActivitiesHasBeenSet; }
  template <typename SalesActivitiesT = Aws::Vector<SalesActivity>>
  void SetSalesActivities(SalesActivitiesT&& value) {
    m_salesActivitiesHasBeenSet = true;
    m_salesActivities = std::forward<SalesActivitiesT>(value);
  }
  template <typename SalesActivitiesT = Aws::Vector<SalesActivity>>
  Project& WithSalesActivities(SalesActivitiesT&& value) {
    SetSalesActivities(std::forward<SalesActivitiesT>(value));
    return *this;
  }
  inline Project& AddSalesActivities(SalesActivity value) {
    m_salesActivitiesHasBeenSet = true;
    m_salesActivities.push_back(value);
    return *this;
  }
 
 
  inline CompetitorName GetCompetitorName() const { return m_competitorName; }
  inline bool CompetitorNameHasBeenSet() const { return m_competitorNameHasBeenSet; }
  inline void SetCompetitorName(CompetitorName value) {
    m_competitorNameHasBeenSet = true;
    m_competitorName = value;
  }
  inline Project& WithCompetitorName(CompetitorName value) {
    SetCompetitorName(value);
    return *this;
  }
 
 
  inline const Aws::String& GetOtherCompetitorNames() const { return m_otherCompetitorNames; }
  inline bool OtherCompetitorNamesHasBeenSet() const { return m_otherCompetitorNamesHasBeenSet; }
  template <typename OtherCompetitorNamesT = Aws::String>
  void SetOtherCompetitorNames(OtherCompetitorNamesT&& value) {
    m_otherCompetitorNamesHasBeenSet = true;
    m_otherCompetitorNames = std::forward<OtherCompetitorNamesT>(value);
  }
  template <typename OtherCompetitorNamesT = Aws::String>
  Project& WithOtherCompetitorNames(OtherCompetitorNamesT&& value) {
    SetOtherCompetitorNames(std::forward<OtherCompetitorNamesT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetOtherSolutionDescription() const { return m_otherSolutionDescription; }
  inline bool OtherSolutionDescriptionHasBeenSet() const { return m_otherSolutionDescriptionHasBeenSet; }
  template <typename OtherSolutionDescriptionT = Aws::String>
  void SetOtherSolutionDescription(OtherSolutionDescriptionT&& value) {
    m_otherSolutionDescriptionHasBeenSet = true;
    m_otherSolutionDescription = std::forward<OtherSolutionDescriptionT>(value);
  }
  template <typename OtherSolutionDescriptionT = Aws::String>
  Project& WithOtherSolutionDescription(OtherSolutionDescriptionT&& value) {
    SetOtherSolutionDescription(std::forward<OtherSolutionDescriptionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAdditionalComments() const { return m_additionalComments; }
  inline bool AdditionalCommentsHasBeenSet() const { return m_additionalCommentsHasBeenSet; }
  template <typename AdditionalCommentsT = Aws::String>
  void SetAdditionalComments(AdditionalCommentsT&& value) {
    m_additionalCommentsHasBeenSet = true;
    m_additionalComments = std::forward<AdditionalCommentsT>(value);
  }
  template <typename AdditionalCommentsT = Aws::String>
  Project& WithAdditionalComments(AdditionalCommentsT&& value) {
    SetAdditionalComments(std::forward<AdditionalCommentsT>(value));
    return *this;
  }
 
 
  inline AwsPartition GetAwsPartition() const { return m_awsPartition; }
  inline bool AwsPartitionHasBeenSet() const { return m_awsPartitionHasBeenSet; }
  inline void SetAwsPartition(AwsPartition value) {
    m_awsPartitionHasBeenSet = true;
    m_awsPartition = value;
  }
  inline Project& WithAwsPartition(AwsPartition value) {
    SetAwsPartition(value);
    return *this;
  }
 private:
  Aws::Vector<DeliveryModel> m_deliveryModels;
 
  Aws::Vector<ExpectedCustomerSpend> m_expectedCustomerSpend;
 
  ExpectedContractDuration m_expectedContractDuration;
 
  Aws::String m_title;
 
  Aws::Vector<Aws::String> m_apnPrograms;
 
  Aws::String m_customerBusinessProblem;
 
  Aws::String m_customerUseCase;
 
  Aws::String m_relatedOpportunityIdentifier;
 
  Aws::Vector<SalesActivity> m_salesActivities;
 
  CompetitorName m_competitorName{CompetitorName::NOT_SET};
 
  Aws::String m_otherCompetitorNames;
 
  Aws::String m_otherSolutionDescription;
 
  Aws::String m_additionalComments;
 
  AwsPartition m_awsPartition{AwsPartition::NOT_SET};
  bool m_deliveryModelsHasBeenSet = false;
  bool m_expectedCustomerSpendHasBeenSet = false;
  bool m_expectedContractDurationHasBeenSet = false;
  bool m_titleHasBeenSet = false;
  bool m_apnProgramsHasBeenSet = false;
  bool m_customerBusinessProblemHasBeenSet = false;
  bool m_customerUseCaseHasBeenSet = false;
  bool m_relatedOpportunityIdentifierHasBeenSet = false;
  bool m_salesActivitiesHasBeenSet = false;
  bool m_competitorNameHasBeenSet = false;
  bool m_otherCompetitorNamesHasBeenSet = false;
  bool m_otherSolutionDescriptionHasBeenSet = false;
  bool m_additionalCommentsHasBeenSet = false;
  bool m_awsPartitionHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace PartnerCentralSelling
}  // namespace Aws