AdditionalInfoResponse.h

 
#pragma once
#include <aws/taxsettings/TaxSettings_EXPORTS.h>
#include <aws/taxsettings/model/BrazilAdditionalInfo.h>
#include <aws/taxsettings/model/CanadaAdditionalInfo.h>
#include <aws/taxsettings/model/EgyptAdditionalInfo.h>
#include <aws/taxsettings/model/EstoniaAdditionalInfo.h>
#include <aws/taxsettings/model/GeorgiaAdditionalInfo.h>
#include <aws/taxsettings/model/GreeceAdditionalInfo.h>
#include <aws/taxsettings/model/IndiaAdditionalInfo.h>
#include <aws/taxsettings/model/IndonesiaAdditionalInfo.h>
#include <aws/taxsettings/model/IsraelAdditionalInfo.h>
#include <aws/taxsettings/model/ItalyAdditionalInfo.h>
#include <aws/taxsettings/model/KenyaAdditionalInfo.h>
#include <aws/taxsettings/model/MalaysiaAdditionalInfo.h>
#include <aws/taxsettings/model/PolandAdditionalInfo.h>
#include <aws/taxsettings/model/RomaniaAdditionalInfo.h>
#include <aws/taxsettings/model/SaudiArabiaAdditionalInfo.h>
#include <aws/taxsettings/model/SouthKoreaAdditionalInfo.h>
#include <aws/taxsettings/model/SpainAdditionalInfo.h>
#include <aws/taxsettings/model/TurkeyAdditionalInfo.h>
#include <aws/taxsettings/model/UkraineAdditionalInfo.h>
#include <aws/taxsettings/model/UzbekistanAdditionalInfo.h>
#include <aws/taxsettings/model/VietnamAdditionalInfo.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace TaxSettings
{
namespace Model
{
 
  class AdditionalInfoResponse
  {
  public:
    AWS_TAXSETTINGS_API AdditionalInfoResponse() = default;
    AWS_TAXSETTINGS_API AdditionalInfoResponse(Aws::Utils::Json::JsonView jsonValue);
    AWS_TAXSETTINGS_API AdditionalInfoResponse& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_TAXSETTINGS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    inline const BrazilAdditionalInfo& GetBrazilAdditionalInfo() const { return m_brazilAdditionalInfo; }
    inline bool BrazilAdditionalInfoHasBeenSet() const { return m_brazilAdditionalInfoHasBeenSet; }
    template<typename BrazilAdditionalInfoT = BrazilAdditionalInfo>
    void SetBrazilAdditionalInfo(BrazilAdditionalInfoT&& value) { m_brazilAdditionalInfoHasBeenSet = true; m_brazilAdditionalInfo = std::forward<BrazilAdditionalInfoT>(value); }
    template<typename BrazilAdditionalInfoT = BrazilAdditionalInfo>
    AdditionalInfoResponse& WithBrazilAdditionalInfo(BrazilAdditionalInfoT&& value) { SetBrazilAdditionalInfo(std::forward<BrazilAdditionalInfoT>(value)); return *this;}
 
 
    inline const CanadaAdditionalInfo& GetCanadaAdditionalInfo() const { return m_canadaAdditionalInfo; }
    inline bool CanadaAdditionalInfoHasBeenSet() const { return m_canadaAdditionalInfoHasBeenSet; }
    template<typename CanadaAdditionalInfoT = CanadaAdditionalInfo>
    void SetCanadaAdditionalInfo(CanadaAdditionalInfoT&& value) { m_canadaAdditionalInfoHasBeenSet = true; m_canadaAdditionalInfo = std::forward<CanadaAdditionalInfoT>(value); }
    template<typename CanadaAdditionalInfoT = CanadaAdditionalInfo>
    AdditionalInfoResponse& WithCanadaAdditionalInfo(CanadaAdditionalInfoT&& value) { SetCanadaAdditionalInfo(std::forward<CanadaAdditionalInfoT>(value)); return *this;}
 
 
    inline const EgyptAdditionalInfo& GetEgyptAdditionalInfo() const { return m_egyptAdditionalInfo; }
    inline bool EgyptAdditionalInfoHasBeenSet() const { return m_egyptAdditionalInfoHasBeenSet; }
    template<typename EgyptAdditionalInfoT = EgyptAdditionalInfo>
    void SetEgyptAdditionalInfo(EgyptAdditionalInfoT&& value) { m_egyptAdditionalInfoHasBeenSet = true; m_egyptAdditionalInfo = std::forward<EgyptAdditionalInfoT>(value); }
    template<typename EgyptAdditionalInfoT = EgyptAdditionalInfo>
    AdditionalInfoResponse& WithEgyptAdditionalInfo(EgyptAdditionalInfoT&& value) { SetEgyptAdditionalInfo(std::forward<EgyptAdditionalInfoT>(value)); return *this;}
 
 
    inline const EstoniaAdditionalInfo& GetEstoniaAdditionalInfo() const { return m_estoniaAdditionalInfo; }
    inline bool EstoniaAdditionalInfoHasBeenSet() const { return m_estoniaAdditionalInfoHasBeenSet; }
    template<typename EstoniaAdditionalInfoT = EstoniaAdditionalInfo>
    void SetEstoniaAdditionalInfo(EstoniaAdditionalInfoT&& value) { m_estoniaAdditionalInfoHasBeenSet = true; m_estoniaAdditionalInfo = std::forward<EstoniaAdditionalInfoT>(value); }
    template<typename EstoniaAdditionalInfoT = EstoniaAdditionalInfo>
    AdditionalInfoResponse& WithEstoniaAdditionalInfo(EstoniaAdditionalInfoT&& value) { SetEstoniaAdditionalInfo(std::forward<EstoniaAdditionalInfoT>(value)); return *this;}
 
 
    inline const GeorgiaAdditionalInfo& GetGeorgiaAdditionalInfo() const { return m_georgiaAdditionalInfo; }
    inline bool GeorgiaAdditionalInfoHasBeenSet() const { return m_georgiaAdditionalInfoHasBeenSet; }
    template<typename GeorgiaAdditionalInfoT = GeorgiaAdditionalInfo>
    void SetGeorgiaAdditionalInfo(GeorgiaAdditionalInfoT&& value) { m_georgiaAdditionalInfoHasBeenSet = true; m_georgiaAdditionalInfo = std::forward<GeorgiaAdditionalInfoT>(value); }
    template<typename GeorgiaAdditionalInfoT = GeorgiaAdditionalInfo>
    AdditionalInfoResponse& WithGeorgiaAdditionalInfo(GeorgiaAdditionalInfoT&& value) { SetGeorgiaAdditionalInfo(std::forward<GeorgiaAdditionalInfoT>(value)); return *this;}
 
 
    inline const GreeceAdditionalInfo& GetGreeceAdditionalInfo() const { return m_greeceAdditionalInfo; }
    inline bool GreeceAdditionalInfoHasBeenSet() const { return m_greeceAdditionalInfoHasBeenSet; }
    template<typename GreeceAdditionalInfoT = GreeceAdditionalInfo>
    void SetGreeceAdditionalInfo(GreeceAdditionalInfoT&& value) { m_greeceAdditionalInfoHasBeenSet = true; m_greeceAdditionalInfo = std::forward<GreeceAdditionalInfoT>(value); }
    template<typename GreeceAdditionalInfoT = GreeceAdditionalInfo>
    AdditionalInfoResponse& WithGreeceAdditionalInfo(GreeceAdditionalInfoT&& value) { SetGreeceAdditionalInfo(std::forward<GreeceAdditionalInfoT>(value)); return *this;}
 
 
    inline const IndiaAdditionalInfo& GetIndiaAdditionalInfo() const { return m_indiaAdditionalInfo; }
    inline bool IndiaAdditionalInfoHasBeenSet() const { return m_indiaAdditionalInfoHasBeenSet; }
    template<typename IndiaAdditionalInfoT = IndiaAdditionalInfo>
    void SetIndiaAdditionalInfo(IndiaAdditionalInfoT&& value) { m_indiaAdditionalInfoHasBeenSet = true; m_indiaAdditionalInfo = std::forward<IndiaAdditionalInfoT>(value); }
    template<typename IndiaAdditionalInfoT = IndiaAdditionalInfo>
    AdditionalInfoResponse& WithIndiaAdditionalInfo(IndiaAdditionalInfoT&& value) { SetIndiaAdditionalInfo(std::forward<IndiaAdditionalInfoT>(value)); return *this;}
 
 
    inline const IndonesiaAdditionalInfo& GetIndonesiaAdditionalInfo() const { return m_indonesiaAdditionalInfo; }
    inline bool IndonesiaAdditionalInfoHasBeenSet() const { return m_indonesiaAdditionalInfoHasBeenSet; }
    template<typename IndonesiaAdditionalInfoT = IndonesiaAdditionalInfo>
    void SetIndonesiaAdditionalInfo(IndonesiaAdditionalInfoT&& value) { m_indonesiaAdditionalInfoHasBeenSet = true; m_indonesiaAdditionalInfo = std::forward<IndonesiaAdditionalInfoT>(value); }
    template<typename IndonesiaAdditionalInfoT = IndonesiaAdditionalInfo>
    AdditionalInfoResponse& WithIndonesiaAdditionalInfo(IndonesiaAdditionalInfoT&& value) { SetIndonesiaAdditionalInfo(std::forward<IndonesiaAdditionalInfoT>(value)); return *this;}
 
 
    inline const IsraelAdditionalInfo& GetIsraelAdditionalInfo() const { return m_israelAdditionalInfo; }
    inline bool IsraelAdditionalInfoHasBeenSet() const { return m_israelAdditionalInfoHasBeenSet; }
    template<typename IsraelAdditionalInfoT = IsraelAdditionalInfo>
    void SetIsraelAdditionalInfo(IsraelAdditionalInfoT&& value) { m_israelAdditionalInfoHasBeenSet = true; m_israelAdditionalInfo = std::forward<IsraelAdditionalInfoT>(value); }
    template<typename IsraelAdditionalInfoT = IsraelAdditionalInfo>
    AdditionalInfoResponse& WithIsraelAdditionalInfo(IsraelAdditionalInfoT&& value) { SetIsraelAdditionalInfo(std::forward<IsraelAdditionalInfoT>(value)); return *this;}
 
 
    inline const ItalyAdditionalInfo& GetItalyAdditionalInfo() const { return m_italyAdditionalInfo; }
    inline bool ItalyAdditionalInfoHasBeenSet() const { return m_italyAdditionalInfoHasBeenSet; }
    template<typename ItalyAdditionalInfoT = ItalyAdditionalInfo>
    void SetItalyAdditionalInfo(ItalyAdditionalInfoT&& value) { m_italyAdditionalInfoHasBeenSet = true; m_italyAdditionalInfo = std::forward<ItalyAdditionalInfoT>(value); }
    template<typename ItalyAdditionalInfoT = ItalyAdditionalInfo>
    AdditionalInfoResponse& WithItalyAdditionalInfo(ItalyAdditionalInfoT&& value) { SetItalyAdditionalInfo(std::forward<ItalyAdditionalInfoT>(value)); return *this;}
 
 
    inline const KenyaAdditionalInfo& GetKenyaAdditionalInfo() const { return m_kenyaAdditionalInfo; }
    inline bool KenyaAdditionalInfoHasBeenSet() const { return m_kenyaAdditionalInfoHasBeenSet; }
    template<typename KenyaAdditionalInfoT = KenyaAdditionalInfo>
    void SetKenyaAdditionalInfo(KenyaAdditionalInfoT&& value) { m_kenyaAdditionalInfoHasBeenSet = true; m_kenyaAdditionalInfo = std::forward<KenyaAdditionalInfoT>(value); }
    template<typename KenyaAdditionalInfoT = KenyaAdditionalInfo>
    AdditionalInfoResponse& WithKenyaAdditionalInfo(KenyaAdditionalInfoT&& value) { SetKenyaAdditionalInfo(std::forward<KenyaAdditionalInfoT>(value)); return *this;}
 
 
    inline const MalaysiaAdditionalInfo& GetMalaysiaAdditionalInfo() const { return m_malaysiaAdditionalInfo; }
    inline bool MalaysiaAdditionalInfoHasBeenSet() const { return m_malaysiaAdditionalInfoHasBeenSet; }
    template<typename MalaysiaAdditionalInfoT = MalaysiaAdditionalInfo>
    void SetMalaysiaAdditionalInfo(MalaysiaAdditionalInfoT&& value) { m_malaysiaAdditionalInfoHasBeenSet = true; m_malaysiaAdditionalInfo = std::forward<MalaysiaAdditionalInfoT>(value); }
    template<typename MalaysiaAdditionalInfoT = MalaysiaAdditionalInfo>
    AdditionalInfoResponse& WithMalaysiaAdditionalInfo(MalaysiaAdditionalInfoT&& value) { SetMalaysiaAdditionalInfo(std::forward<MalaysiaAdditionalInfoT>(value)); return *this;}
 
 
    inline const PolandAdditionalInfo& GetPolandAdditionalInfo() const { return m_polandAdditionalInfo; }
    inline bool PolandAdditionalInfoHasBeenSet() const { return m_polandAdditionalInfoHasBeenSet; }
    template<typename PolandAdditionalInfoT = PolandAdditionalInfo>
    void SetPolandAdditionalInfo(PolandAdditionalInfoT&& value) { m_polandAdditionalInfoHasBeenSet = true; m_polandAdditionalInfo = std::forward<PolandAdditionalInfoT>(value); }
    template<typename PolandAdditionalInfoT = PolandAdditionalInfo>
    AdditionalInfoResponse& WithPolandAdditionalInfo(PolandAdditionalInfoT&& value) { SetPolandAdditionalInfo(std::forward<PolandAdditionalInfoT>(value)); return *this;}
 
 
    inline const RomaniaAdditionalInfo& GetRomaniaAdditionalInfo() const { return m_romaniaAdditionalInfo; }
    inline bool RomaniaAdditionalInfoHasBeenSet() const { return m_romaniaAdditionalInfoHasBeenSet; }
    template<typename RomaniaAdditionalInfoT = RomaniaAdditionalInfo>
    void SetRomaniaAdditionalInfo(RomaniaAdditionalInfoT&& value) { m_romaniaAdditionalInfoHasBeenSet = true; m_romaniaAdditionalInfo = std::forward<RomaniaAdditionalInfoT>(value); }
    template<typename RomaniaAdditionalInfoT = RomaniaAdditionalInfo>
    AdditionalInfoResponse& WithRomaniaAdditionalInfo(RomaniaAdditionalInfoT&& value) { SetRomaniaAdditionalInfo(std::forward<RomaniaAdditionalInfoT>(value)); return *this;}
 
 
    inline const SaudiArabiaAdditionalInfo& GetSaudiArabiaAdditionalInfo() const { return m_saudiArabiaAdditionalInfo; }
    inline bool SaudiArabiaAdditionalInfoHasBeenSet() const { return m_saudiArabiaAdditionalInfoHasBeenSet; }
    template<typename SaudiArabiaAdditionalInfoT = SaudiArabiaAdditionalInfo>
    void SetSaudiArabiaAdditionalInfo(SaudiArabiaAdditionalInfoT&& value) { m_saudiArabiaAdditionalInfoHasBeenSet = true; m_saudiArabiaAdditionalInfo = std::forward<SaudiArabiaAdditionalInfoT>(value); }
    template<typename SaudiArabiaAdditionalInfoT = SaudiArabiaAdditionalInfo>
    AdditionalInfoResponse& WithSaudiArabiaAdditionalInfo(SaudiArabiaAdditionalInfoT&& value) { SetSaudiArabiaAdditionalInfo(std::forward<SaudiArabiaAdditionalInfoT>(value)); return *this;}
 
 
    inline const SouthKoreaAdditionalInfo& GetSouthKoreaAdditionalInfo() const { return m_southKoreaAdditionalInfo; }
    inline bool SouthKoreaAdditionalInfoHasBeenSet() const { return m_southKoreaAdditionalInfoHasBeenSet; }
    template<typename SouthKoreaAdditionalInfoT = SouthKoreaAdditionalInfo>
    void SetSouthKoreaAdditionalInfo(SouthKoreaAdditionalInfoT&& value) { m_southKoreaAdditionalInfoHasBeenSet = true; m_southKoreaAdditionalInfo = std::forward<SouthKoreaAdditionalInfoT>(value); }
    template<typename SouthKoreaAdditionalInfoT = SouthKoreaAdditionalInfo>
    AdditionalInfoResponse& WithSouthKoreaAdditionalInfo(SouthKoreaAdditionalInfoT&& value) { SetSouthKoreaAdditionalInfo(std::forward<SouthKoreaAdditionalInfoT>(value)); return *this;}
 
 
    inline const SpainAdditionalInfo& GetSpainAdditionalInfo() const { return m_spainAdditionalInfo; }
    inline bool SpainAdditionalInfoHasBeenSet() const { return m_spainAdditionalInfoHasBeenSet; }
    template<typename SpainAdditionalInfoT = SpainAdditionalInfo>
    void SetSpainAdditionalInfo(SpainAdditionalInfoT&& value) { m_spainAdditionalInfoHasBeenSet = true; m_spainAdditionalInfo = std::forward<SpainAdditionalInfoT>(value); }
    template<typename SpainAdditionalInfoT = SpainAdditionalInfo>
    AdditionalInfoResponse& WithSpainAdditionalInfo(SpainAdditionalInfoT&& value) { SetSpainAdditionalInfo(std::forward<SpainAdditionalInfoT>(value)); return *this;}
 
 
    inline const TurkeyAdditionalInfo& GetTurkeyAdditionalInfo() const { return m_turkeyAdditionalInfo; }
    inline bool TurkeyAdditionalInfoHasBeenSet() const { return m_turkeyAdditionalInfoHasBeenSet; }
    template<typename TurkeyAdditionalInfoT = TurkeyAdditionalInfo>
    void SetTurkeyAdditionalInfo(TurkeyAdditionalInfoT&& value) { m_turkeyAdditionalInfoHasBeenSet = true; m_turkeyAdditionalInfo = std::forward<TurkeyAdditionalInfoT>(value); }
    template<typename TurkeyAdditionalInfoT = TurkeyAdditionalInfo>
    AdditionalInfoResponse& WithTurkeyAdditionalInfo(TurkeyAdditionalInfoT&& value) { SetTurkeyAdditionalInfo(std::forward<TurkeyAdditionalInfoT>(value)); return *this;}
 
 
    inline const UkraineAdditionalInfo& GetUkraineAdditionalInfo() const { return m_ukraineAdditionalInfo; }
    inline bool UkraineAdditionalInfoHasBeenSet() const { return m_ukraineAdditionalInfoHasBeenSet; }
    template<typename UkraineAdditionalInfoT = UkraineAdditionalInfo>
    void SetUkraineAdditionalInfo(UkraineAdditionalInfoT&& value) { m_ukraineAdditionalInfoHasBeenSet = true; m_ukraineAdditionalInfo = std::forward<UkraineAdditionalInfoT>(value); }
    template<typename UkraineAdditionalInfoT = UkraineAdditionalInfo>
    AdditionalInfoResponse& WithUkraineAdditionalInfo(UkraineAdditionalInfoT&& value) { SetUkraineAdditionalInfo(std::forward<UkraineAdditionalInfoT>(value)); return *this;}
 
 
    inline const UzbekistanAdditionalInfo& GetUzbekistanAdditionalInfo() const { return m_uzbekistanAdditionalInfo; }
    inline bool UzbekistanAdditionalInfoHasBeenSet() const { return m_uzbekistanAdditionalInfoHasBeenSet; }
    template<typename UzbekistanAdditionalInfoT = UzbekistanAdditionalInfo>
    void SetUzbekistanAdditionalInfo(UzbekistanAdditionalInfoT&& value) { m_uzbekistanAdditionalInfoHasBeenSet = true; m_uzbekistanAdditionalInfo = std::forward<UzbekistanAdditionalInfoT>(value); }
    template<typename UzbekistanAdditionalInfoT = UzbekistanAdditionalInfo>
    AdditionalInfoResponse& WithUzbekistanAdditionalInfo(UzbekistanAdditionalInfoT&& value) { SetUzbekistanAdditionalInfo(std::forward<UzbekistanAdditionalInfoT>(value)); return *this;}
 
 
    inline const VietnamAdditionalInfo& GetVietnamAdditionalInfo() const { return m_vietnamAdditionalInfo; }
    inline bool VietnamAdditionalInfoHasBeenSet() const { return m_vietnamAdditionalInfoHasBeenSet; }
    template<typename VietnamAdditionalInfoT = VietnamAdditionalInfo>
    void SetVietnamAdditionalInfo(VietnamAdditionalInfoT&& value) { m_vietnamAdditionalInfoHasBeenSet = true; m_vietnamAdditionalInfo = std::forward<VietnamAdditionalInfoT>(value); }
    template<typename VietnamAdditionalInfoT = VietnamAdditionalInfo>
    AdditionalInfoResponse& WithVietnamAdditionalInfo(VietnamAdditionalInfoT&& value) { SetVietnamAdditionalInfo(std::forward<VietnamAdditionalInfoT>(value)); return *this;}
  private:
 
    BrazilAdditionalInfo m_brazilAdditionalInfo;
    bool m_brazilAdditionalInfoHasBeenSet = false;
 
    CanadaAdditionalInfo m_canadaAdditionalInfo;
    bool m_canadaAdditionalInfoHasBeenSet = false;
 
    EgyptAdditionalInfo m_egyptAdditionalInfo;
    bool m_egyptAdditionalInfoHasBeenSet = false;
 
    EstoniaAdditionalInfo m_estoniaAdditionalInfo;
    bool m_estoniaAdditionalInfoHasBeenSet = false;
 
    GeorgiaAdditionalInfo m_georgiaAdditionalInfo;
    bool m_georgiaAdditionalInfoHasBeenSet = false;
 
    GreeceAdditionalInfo m_greeceAdditionalInfo;
    bool m_greeceAdditionalInfoHasBeenSet = false;
 
    IndiaAdditionalInfo m_indiaAdditionalInfo;
    bool m_indiaAdditionalInfoHasBeenSet = false;
 
    IndonesiaAdditionalInfo m_indonesiaAdditionalInfo;
    bool m_indonesiaAdditionalInfoHasBeenSet = false;
 
    IsraelAdditionalInfo m_israelAdditionalInfo;
    bool m_israelAdditionalInfoHasBeenSet = false;
 
    ItalyAdditionalInfo m_italyAdditionalInfo;
    bool m_italyAdditionalInfoHasBeenSet = false;
 
    KenyaAdditionalInfo m_kenyaAdditionalInfo;
    bool m_kenyaAdditionalInfoHasBeenSet = false;
 
    MalaysiaAdditionalInfo m_malaysiaAdditionalInfo;
    bool m_malaysiaAdditionalInfoHasBeenSet = false;
 
    PolandAdditionalInfo m_polandAdditionalInfo;
    bool m_polandAdditionalInfoHasBeenSet = false;
 
    RomaniaAdditionalInfo m_romaniaAdditionalInfo;
    bool m_romaniaAdditionalInfoHasBeenSet = false;
 
    SaudiArabiaAdditionalInfo m_saudiArabiaAdditionalInfo;
    bool m_saudiArabiaAdditionalInfoHasBeenSet = false;
 
    SouthKoreaAdditionalInfo m_southKoreaAdditionalInfo;
    bool m_southKoreaAdditionalInfoHasBeenSet = false;
 
    SpainAdditionalInfo m_spainAdditionalInfo;
    bool m_spainAdditionalInfoHasBeenSet = false;
 
    TurkeyAdditionalInfo m_turkeyAdditionalInfo;
    bool m_turkeyAdditionalInfoHasBeenSet = false;
 
    UkraineAdditionalInfo m_ukraineAdditionalInfo;
    bool m_ukraineAdditionalInfoHasBeenSet = false;
 
    UzbekistanAdditionalInfo m_uzbekistanAdditionalInfo;
    bool m_uzbekistanAdditionalInfoHasBeenSet = false;
 
    VietnamAdditionalInfo m_vietnamAdditionalInfo;
    bool m_vietnamAdditionalInfoHasBeenSet = false;
  };
 
} // namespace Model
} // namespace TaxSettings
} // namespace Aws