ControlTowerClient.h

 
#pragma once
#include <aws/controltower/ControlTowerServiceClientModel.h>
#include <aws/controltower/ControlTower_EXPORTS.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
 
namespace Aws {
namespace ControlTower {
class AWS_CONTROLTOWER_API ControlTowerClient : public Aws::Client::AWSJsonClient,
                                                public Aws::Client::ClientWithAsyncTemplateMethods<ControlTowerClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef ControlTowerClientConfiguration ClientConfigurationType;
  typedef ControlTowerEndpointProvider EndpointProviderType;
 
  ControlTowerClient(
      const Aws::ControlTower::ControlTowerClientConfiguration& clientConfiguration = Aws::ControlTower::ControlTowerClientConfiguration(),
      std::shared_ptr<ControlTowerEndpointProviderBase> endpointProvider = nullptr);
 
  ControlTowerClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<ControlTowerEndpointProviderBase> endpointProvider = nullptr,
      const Aws::ControlTower::ControlTowerClientConfiguration& clientConfiguration = Aws::ControlTower::ControlTowerClientConfiguration());
 
  ControlTowerClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<ControlTowerEndpointProviderBase> endpointProvider = nullptr,
      const Aws::ControlTower::ControlTowerClientConfiguration& clientConfiguration = Aws::ControlTower::ControlTowerClientConfiguration());
 
  /* Legacy constructors due deprecation */
  ControlTowerClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ControlTowerClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ControlTowerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~ControlTowerClient();
 
  virtual Model::CreateLandingZoneOutcome CreateLandingZone(const Model::CreateLandingZoneRequest& request) const;
 
  template <typename CreateLandingZoneRequestT = Model::CreateLandingZoneRequest>
  Model::CreateLandingZoneOutcomeCallable CreateLandingZoneCallable(const CreateLandingZoneRequestT& request) const {
    return SubmitCallable(&ControlTowerClient::CreateLandingZone, request);
  }
 
  template <typename CreateLandingZoneRequestT = Model::CreateLandingZoneRequest>
  void CreateLandingZoneAsync(const CreateLandingZoneRequestT& request, const CreateLandingZoneResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ControlTowerClient::CreateLandingZone, request, handler, context);
  }
 
  virtual Model::DeleteLandingZoneOutcome DeleteLandingZone(const Model::DeleteLandingZoneRequest& request) const;
 
  template <typename DeleteLandingZoneRequestT = Model::DeleteLandingZoneRequest>
  Model::DeleteLandingZoneOutcomeCallable DeleteLandingZoneCallable(const DeleteLandingZoneRequestT& request) const {
    return SubmitCallable(&ControlTowerClient::DeleteLandingZone, request);
  }
 
  template <typename DeleteLandingZoneRequestT = Model::DeleteLandingZoneRequest>
  void DeleteLandingZoneAsync(const DeleteLandingZoneRequestT& request, const DeleteLandingZoneResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ControlTowerClient::DeleteLandingZone, request, handler, context);
  }
 
  virtual Model::DisableBaselineOutcome DisableBaseline(const Model::DisableBaselineRequest& request) const;
 
  template <typename DisableBaselineRequestT = Model::DisableBaselineRequest>
  Model::DisableBaselineOutcomeCallable DisableBaselineCallable(const DisableBaselineRequestT& request) const {
    return SubmitCallable(&ControlTowerClient::DisableBaseline, request);
  }
 
  template <typename DisableBaselineRequestT = Model::DisableBaselineRequest>
  void DisableBaselineAsync(const DisableBaselineRequestT& request, const DisableBaselineResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ControlTowerClient::DisableBaseline, request, handler, context);
  }
 
  virtual Model::DisableControlOutcome DisableControl(const Model::DisableControlRequest& request = {}) const;
 
  template <typename DisableControlRequestT = Model::DisableControlRequest>
  Model::DisableControlOutcomeCallable DisableControlCallable(const DisableControlRequestT& request = {}) const {
    return SubmitCallable(&ControlTowerClient::DisableControl, request);
  }
 
  template <typename DisableControlRequestT = Model::DisableControlRequest>
  void DisableControlAsync(const DisableControlResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const DisableControlRequestT& request = {}) const {
    return SubmitAsync(&ControlTowerClient::DisableControl, request, handler, context);
  }
 
  virtual Model::EnableBaselineOutcome EnableBaseline(const Model::EnableBaselineRequest& request) const;
 
  template <typename EnableBaselineRequestT = Model::EnableBaselineRequest>
  Model::EnableBaselineOutcomeCallable EnableBaselineCallable(const EnableBaselineRequestT& request) const {
    return SubmitCallable(&ControlTowerClient::EnableBaseline, request);
  }
 
  template <typename EnableBaselineRequestT = Model::EnableBaselineRequest>
  void EnableBaselineAsync(const EnableBaselineRequestT& request, const EnableBaselineResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ControlTowerClient::EnableBaseline, request, handler, context);
  }
 
  virtual Model::EnableControlOutcome EnableControl(const Model::EnableControlRequest& request) const;
 
  template <typename EnableControlRequestT = Model::EnableControlRequest>
  Model::EnableControlOutcomeCallable EnableControlCallable(const EnableControlRequestT& request) const {
    return SubmitCallable(&ControlTowerClient::EnableControl, request);
  }
 
  template <typename EnableControlRequestT = Model::EnableControlRequest>
  void EnableControlAsync(const EnableControlRequestT& request, const EnableControlResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ControlTowerClient::EnableControl, request, handler, context);
  }
 
  virtual Model::GetBaselineOutcome GetBaseline(const Model::GetBaselineRequest& request) const;
 
  template <typename GetBaselineRequestT = Model::GetBaselineRequest>
  Model::GetBaselineOutcomeCallable GetBaselineCallable(const GetBaselineRequestT& request) const {
    return SubmitCallable(&ControlTowerClient::GetBaseline, request);
  }
 
  template <typename GetBaselineRequestT = Model::GetBaselineRequest>
  void GetBaselineAsync(const GetBaselineRequestT& request, const GetBaselineResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ControlTowerClient::GetBaseline, request, handler, context);
  }
 
  virtual Model::GetBaselineOperationOutcome GetBaselineOperation(const Model::GetBaselineOperationRequest& request) const;
 
  template <typename GetBaselineOperationRequestT = Model::GetBaselineOperationRequest>
  Model::GetBaselineOperationOutcomeCallable GetBaselineOperationCallable(const GetBaselineOperationRequestT& request) const {
    return SubmitCallable(&ControlTowerClient::GetBaselineOperation, request);
  }
 
  template <typename GetBaselineOperationRequestT = Model::GetBaselineOperationRequest>
  void GetBaselineOperationAsync(const GetBaselineOperationRequestT& request, const GetBaselineOperationResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ControlTowerClient::GetBaselineOperation, request, handler, context);
  }
 
  virtual Model::GetControlOperationOutcome GetControlOperation(const Model::GetControlOperationRequest& request) const;
 
  template <typename GetControlOperationRequestT = Model::GetControlOperationRequest>
  Model::GetControlOperationOutcomeCallable GetControlOperationCallable(const GetControlOperationRequestT& request) const {
    return SubmitCallable(&ControlTowerClient::GetControlOperation, request);
  }
 
  template <typename GetControlOperationRequestT = Model::GetControlOperationRequest>
  void GetControlOperationAsync(const GetControlOperationRequestT& request, const GetControlOperationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ControlTowerClient::GetControlOperation, request, handler, context);
  }
 
  virtual Model::GetEnabledBaselineOutcome GetEnabledBaseline(const Model::GetEnabledBaselineRequest& request) const;
 
  template <typename GetEnabledBaselineRequestT = Model::GetEnabledBaselineRequest>
  Model::GetEnabledBaselineOutcomeCallable GetEnabledBaselineCallable(const GetEnabledBaselineRequestT& request) const {
    return SubmitCallable(&ControlTowerClient::GetEnabledBaseline, request);
  }
 
  template <typename GetEnabledBaselineRequestT = Model::GetEnabledBaselineRequest>
  void GetEnabledBaselineAsync(const GetEnabledBaselineRequestT& request, const GetEnabledBaselineResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ControlTowerClient::GetEnabledBaseline, request, handler, context);
  }
 
  virtual Model::GetEnabledControlOutcome GetEnabledControl(const Model::GetEnabledControlRequest& request) const;
 
  template <typename GetEnabledControlRequestT = Model::GetEnabledControlRequest>
  Model::GetEnabledControlOutcomeCallable GetEnabledControlCallable(const GetEnabledControlRequestT& request) const {
    return SubmitCallable(&ControlTowerClient::GetEnabledControl, request);
  }
 
  template <typename GetEnabledControlRequestT = Model::GetEnabledControlRequest>
  void GetEnabledControlAsync(const GetEnabledControlRequestT& request, const GetEnabledControlResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ControlTowerClient::GetEnabledControl, request, handler, context);
  }
 
  virtual Model::GetLandingZoneOutcome GetLandingZone(const Model::GetLandingZoneRequest& request) const;
 
  template <typename GetLandingZoneRequestT = Model::GetLandingZoneRequest>
  Model::GetLandingZoneOutcomeCallable GetLandingZoneCallable(const GetLandingZoneRequestT& request) const {
    return SubmitCallable(&ControlTowerClient::GetLandingZone, request);
  }
 
  template <typename GetLandingZoneRequestT = Model::GetLandingZoneRequest>
  void GetLandingZoneAsync(const GetLandingZoneRequestT& request, const GetLandingZoneResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ControlTowerClient::GetLandingZone, request, handler, context);
  }
 
  virtual Model::GetLandingZoneOperationOutcome GetLandingZoneOperation(const Model::GetLandingZoneOperationRequest& request) const;
 
  template <typename GetLandingZoneOperationRequestT = Model::GetLandingZoneOperationRequest>
  Model::GetLandingZoneOperationOutcomeCallable GetLandingZoneOperationCallable(const GetLandingZoneOperationRequestT& request) const {
    return SubmitCallable(&ControlTowerClient::GetLandingZoneOperation, request);
  }
 
  template <typename GetLandingZoneOperationRequestT = Model::GetLandingZoneOperationRequest>
  void GetLandingZoneOperationAsync(const GetLandingZoneOperationRequestT& request,
                                    const GetLandingZoneOperationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ControlTowerClient::GetLandingZoneOperation, request, handler, context);
  }
 
  virtual Model::ListBaselinesOutcome ListBaselines(const Model::ListBaselinesRequest& request = {}) const;
 
  template <typename ListBaselinesRequestT = Model::ListBaselinesRequest>
  Model::ListBaselinesOutcomeCallable ListBaselinesCallable(const ListBaselinesRequestT& request = {}) const {
    return SubmitCallable(&ControlTowerClient::ListBaselines, request);
  }
 
  template <typename ListBaselinesRequestT = Model::ListBaselinesRequest>
  void ListBaselinesAsync(const ListBaselinesResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const ListBaselinesRequestT& request = {}) const {
    return SubmitAsync(&ControlTowerClient::ListBaselines, request, handler, context);
  }
 
  virtual Model::ListControlOperationsOutcome ListControlOperations(const Model::ListControlOperationsRequest& request = {}) const;
 
  template <typename ListControlOperationsRequestT = Model::ListControlOperationsRequest>
  Model::ListControlOperationsOutcomeCallable ListControlOperationsCallable(const ListControlOperationsRequestT& request = {}) const {
    return SubmitCallable(&ControlTowerClient::ListControlOperations, request);
  }
 
  template <typename ListControlOperationsRequestT = Model::ListControlOperationsRequest>
  void ListControlOperationsAsync(const ListControlOperationsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const ListControlOperationsRequestT& request = {}) const {
    return SubmitAsync(&ControlTowerClient::ListControlOperations, request, handler, context);
  }
 
  virtual Model::ListEnabledBaselinesOutcome ListEnabledBaselines(const Model::ListEnabledBaselinesRequest& request = {}) const;
 
  template <typename ListEnabledBaselinesRequestT = Model::ListEnabledBaselinesRequest>
  Model::ListEnabledBaselinesOutcomeCallable ListEnabledBaselinesCallable(const ListEnabledBaselinesRequestT& request = {}) const {
    return SubmitCallable(&ControlTowerClient::ListEnabledBaselines, request);
  }
 
  template <typename ListEnabledBaselinesRequestT = Model::ListEnabledBaselinesRequest>
  void ListEnabledBaselinesAsync(const ListEnabledBaselinesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListEnabledBaselinesRequestT& request = {}) const {
    return SubmitAsync(&ControlTowerClient::ListEnabledBaselines, request, handler, context);
  }
 
  virtual Model::ListEnabledControlsOutcome ListEnabledControls(const Model::ListEnabledControlsRequest& request = {}) const;
 
  template <typename ListEnabledControlsRequestT = Model::ListEnabledControlsRequest>
  Model::ListEnabledControlsOutcomeCallable ListEnabledControlsCallable(const ListEnabledControlsRequestT& request = {}) const {
    return SubmitCallable(&ControlTowerClient::ListEnabledControls, request);
  }
 
  template <typename ListEnabledControlsRequestT = Model::ListEnabledControlsRequest>
  void ListEnabledControlsAsync(const ListEnabledControlsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListEnabledControlsRequestT& request = {}) const {
    return SubmitAsync(&ControlTowerClient::ListEnabledControls, request, handler, context);
  }
 
  virtual Model::ListLandingZoneOperationsOutcome ListLandingZoneOperations(
      const Model::ListLandingZoneOperationsRequest& request = {}) const;
 
  template <typename ListLandingZoneOperationsRequestT = Model::ListLandingZoneOperationsRequest>
  Model::ListLandingZoneOperationsOutcomeCallable ListLandingZoneOperationsCallable(
      const ListLandingZoneOperationsRequestT& request = {}) const {
    return SubmitCallable(&ControlTowerClient::ListLandingZoneOperations, request);
  }
 
  template <typename ListLandingZoneOperationsRequestT = Model::ListLandingZoneOperationsRequest>
  void ListLandingZoneOperationsAsync(const ListLandingZoneOperationsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListLandingZoneOperationsRequestT& request = {}) const {
    return SubmitAsync(&ControlTowerClient::ListLandingZoneOperations, request, handler, context);
  }
 
  virtual Model::ListLandingZonesOutcome ListLandingZones(const Model::ListLandingZonesRequest& request = {}) const;
 
  template <typename ListLandingZonesRequestT = Model::ListLandingZonesRequest>
  Model::ListLandingZonesOutcomeCallable ListLandingZonesCallable(const ListLandingZonesRequestT& request = {}) const {
    return SubmitCallable(&ControlTowerClient::ListLandingZones, request);
  }
 
  template <typename ListLandingZonesRequestT = Model::ListLandingZonesRequest>
  void ListLandingZonesAsync(const ListLandingZonesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListLandingZonesRequestT& request = {}) const {
    return SubmitAsync(&ControlTowerClient::ListLandingZones, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&ControlTowerClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ControlTowerClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ResetEnabledBaselineOutcome ResetEnabledBaseline(const Model::ResetEnabledBaselineRequest& request) const;
 
  template <typename ResetEnabledBaselineRequestT = Model::ResetEnabledBaselineRequest>
  Model::ResetEnabledBaselineOutcomeCallable ResetEnabledBaselineCallable(const ResetEnabledBaselineRequestT& request) const {
    return SubmitCallable(&ControlTowerClient::ResetEnabledBaseline, request);
  }
 
  template <typename ResetEnabledBaselineRequestT = Model::ResetEnabledBaselineRequest>
  void ResetEnabledBaselineAsync(const ResetEnabledBaselineRequestT& request, const ResetEnabledBaselineResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ControlTowerClient::ResetEnabledBaseline, request, handler, context);
  }
 
  virtual Model::ResetEnabledControlOutcome ResetEnabledControl(const Model::ResetEnabledControlRequest& request) const;
 
  template <typename ResetEnabledControlRequestT = Model::ResetEnabledControlRequest>
  Model::ResetEnabledControlOutcomeCallable ResetEnabledControlCallable(const ResetEnabledControlRequestT& request) const {
    return SubmitCallable(&ControlTowerClient::ResetEnabledControl, request);
  }
 
  template <typename ResetEnabledControlRequestT = Model::ResetEnabledControlRequest>
  void ResetEnabledControlAsync(const ResetEnabledControlRequestT& request, const ResetEnabledControlResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ControlTowerClient::ResetEnabledControl, request, handler, context);
  }
 
  virtual Model::ResetLandingZoneOutcome ResetLandingZone(const Model::ResetLandingZoneRequest& request) const;
 
  template <typename ResetLandingZoneRequestT = Model::ResetLandingZoneRequest>
  Model::ResetLandingZoneOutcomeCallable ResetLandingZoneCallable(const ResetLandingZoneRequestT& request) const {
    return SubmitCallable(&ControlTowerClient::ResetLandingZone, request);
  }
 
  template <typename ResetLandingZoneRequestT = Model::ResetLandingZoneRequest>
  void ResetLandingZoneAsync(const ResetLandingZoneRequestT& request, const ResetLandingZoneResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ControlTowerClient::ResetLandingZone, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&ControlTowerClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ControlTowerClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&ControlTowerClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ControlTowerClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateEnabledBaselineOutcome UpdateEnabledBaseline(const Model::UpdateEnabledBaselineRequest& request) const;
 
  template <typename UpdateEnabledBaselineRequestT = Model::UpdateEnabledBaselineRequest>
  Model::UpdateEnabledBaselineOutcomeCallable UpdateEnabledBaselineCallable(const UpdateEnabledBaselineRequestT& request) const {
    return SubmitCallable(&ControlTowerClient::UpdateEnabledBaseline, request);
  }
 
  template <typename UpdateEnabledBaselineRequestT = Model::UpdateEnabledBaselineRequest>
  void UpdateEnabledBaselineAsync(const UpdateEnabledBaselineRequestT& request, const UpdateEnabledBaselineResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ControlTowerClient::UpdateEnabledBaseline, request, handler, context);
  }
 
  virtual Model::UpdateEnabledControlOutcome UpdateEnabledControl(const Model::UpdateEnabledControlRequest& request) const;
 
  template <typename UpdateEnabledControlRequestT = Model::UpdateEnabledControlRequest>
  Model::UpdateEnabledControlOutcomeCallable UpdateEnabledControlCallable(const UpdateEnabledControlRequestT& request) const {
    return SubmitCallable(&ControlTowerClient::UpdateEnabledControl, request);
  }
 
  template <typename UpdateEnabledControlRequestT = Model::UpdateEnabledControlRequest>
  void UpdateEnabledControlAsync(const UpdateEnabledControlRequestT& request, const UpdateEnabledControlResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ControlTowerClient::UpdateEnabledControl, request, handler, context);
  }
 
  virtual Model::UpdateLandingZoneOutcome UpdateLandingZone(const Model::UpdateLandingZoneRequest& request) const;
 
  template <typename UpdateLandingZoneRequestT = Model::UpdateLandingZoneRequest>
  Model::UpdateLandingZoneOutcomeCallable UpdateLandingZoneCallable(const UpdateLandingZoneRequestT& request) const {
    return SubmitCallable(&ControlTowerClient::UpdateLandingZone, request);
  }
 
  template <typename UpdateLandingZoneRequestT = Model::UpdateLandingZoneRequest>
  void UpdateLandingZoneAsync(const UpdateLandingZoneRequestT& request, const UpdateLandingZoneResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ControlTowerClient::UpdateLandingZone, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<ControlTowerEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ControlTowerClient>;
  void init(const ControlTowerClientConfiguration& clientConfiguration);
 
  ControlTowerClientConfiguration m_clientConfiguration;
  std::shared_ptr<ControlTowerEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ControlTower
}  // namespace Aws