ControlTowerClient.h

 
#pragma once
#include <aws/controltower/ControlTower_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/controltower/ControlTowerServiceClientModel.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 DisableControlRequestT& request, const DisableControlResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) 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::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