IoTEventsClient.h

 
#pragma once
#include <aws/iotevents/IoTEvents_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/iotevents/IoTEventsServiceClientModel.h>
 
namespace Aws
{
namespace IoTEvents
{
  class AWS_IOTEVENTS_API IoTEventsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<IoTEventsClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef IoTEventsClientConfiguration ClientConfigurationType;
      typedef IoTEventsEndpointProvider EndpointProviderType;
 
        IoTEventsClient(const Aws::IoTEvents::IoTEventsClientConfiguration& clientConfiguration = Aws::IoTEvents::IoTEventsClientConfiguration(),
                        std::shared_ptr<IoTEventsEndpointProviderBase> endpointProvider = nullptr);
 
        IoTEventsClient(const Aws::Auth::AWSCredentials& credentials,
                        std::shared_ptr<IoTEventsEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::IoTEvents::IoTEventsClientConfiguration& clientConfiguration = Aws::IoTEvents::IoTEventsClientConfiguration());
 
        IoTEventsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        std::shared_ptr<IoTEventsEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::IoTEvents::IoTEventsClientConfiguration& clientConfiguration = Aws::IoTEvents::IoTEventsClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        IoTEventsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IoTEventsClient(const Aws::Auth::AWSCredentials& credentials,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IoTEventsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~IoTEventsClient();
 
        virtual Model::CreateAlarmModelOutcome CreateAlarmModel(const Model::CreateAlarmModelRequest& request) const;
 
        template<typename CreateAlarmModelRequestT = Model::CreateAlarmModelRequest>
        Model::CreateAlarmModelOutcomeCallable CreateAlarmModelCallable(const CreateAlarmModelRequestT& request) const
        {
            return SubmitCallable(&IoTEventsClient::CreateAlarmModel, request);
        }
 
        template<typename CreateAlarmModelRequestT = Model::CreateAlarmModelRequest>
        void CreateAlarmModelAsync(const CreateAlarmModelRequestT& request, const CreateAlarmModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTEventsClient::CreateAlarmModel, request, handler, context);
        }
 
        virtual Model::CreateDetectorModelOutcome CreateDetectorModel(const Model::CreateDetectorModelRequest& request) const;
 
        template<typename CreateDetectorModelRequestT = Model::CreateDetectorModelRequest>
        Model::CreateDetectorModelOutcomeCallable CreateDetectorModelCallable(const CreateDetectorModelRequestT& request) const
        {
            return SubmitCallable(&IoTEventsClient::CreateDetectorModel, request);
        }
 
        template<typename CreateDetectorModelRequestT = Model::CreateDetectorModelRequest>
        void CreateDetectorModelAsync(const CreateDetectorModelRequestT& request, const CreateDetectorModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTEventsClient::CreateDetectorModel, request, handler, context);
        }
 
        virtual Model::CreateInputOutcome CreateInput(const Model::CreateInputRequest& request) const;
 
        template<typename CreateInputRequestT = Model::CreateInputRequest>
        Model::CreateInputOutcomeCallable CreateInputCallable(const CreateInputRequestT& request) const
        {
            return SubmitCallable(&IoTEventsClient::CreateInput, request);
        }
 
        template<typename CreateInputRequestT = Model::CreateInputRequest>
        void CreateInputAsync(const CreateInputRequestT& request, const CreateInputResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTEventsClient::CreateInput, request, handler, context);
        }
 
        virtual Model::DeleteAlarmModelOutcome DeleteAlarmModel(const Model::DeleteAlarmModelRequest& request) const;
 
        template<typename DeleteAlarmModelRequestT = Model::DeleteAlarmModelRequest>
        Model::DeleteAlarmModelOutcomeCallable DeleteAlarmModelCallable(const DeleteAlarmModelRequestT& request) const
        {
            return SubmitCallable(&IoTEventsClient::DeleteAlarmModel, request);
        }
 
        template<typename DeleteAlarmModelRequestT = Model::DeleteAlarmModelRequest>
        void DeleteAlarmModelAsync(const DeleteAlarmModelRequestT& request, const DeleteAlarmModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTEventsClient::DeleteAlarmModel, request, handler, context);
        }
 
        virtual Model::DeleteDetectorModelOutcome DeleteDetectorModel(const Model::DeleteDetectorModelRequest& request) const;
 
        template<typename DeleteDetectorModelRequestT = Model::DeleteDetectorModelRequest>
        Model::DeleteDetectorModelOutcomeCallable DeleteDetectorModelCallable(const DeleteDetectorModelRequestT& request) const
        {
            return SubmitCallable(&IoTEventsClient::DeleteDetectorModel, request);
        }
 
        template<typename DeleteDetectorModelRequestT = Model::DeleteDetectorModelRequest>
        void DeleteDetectorModelAsync(const DeleteDetectorModelRequestT& request, const DeleteDetectorModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTEventsClient::DeleteDetectorModel, request, handler, context);
        }
 
        virtual Model::DeleteInputOutcome DeleteInput(const Model::DeleteInputRequest& request) const;
 
        template<typename DeleteInputRequestT = Model::DeleteInputRequest>
        Model::DeleteInputOutcomeCallable DeleteInputCallable(const DeleteInputRequestT& request) const
        {
            return SubmitCallable(&IoTEventsClient::DeleteInput, request);
        }
 
        template<typename DeleteInputRequestT = Model::DeleteInputRequest>
        void DeleteInputAsync(const DeleteInputRequestT& request, const DeleteInputResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTEventsClient::DeleteInput, request, handler, context);
        }
 
        virtual Model::DescribeAlarmModelOutcome DescribeAlarmModel(const Model::DescribeAlarmModelRequest& request) const;
 
        template<typename DescribeAlarmModelRequestT = Model::DescribeAlarmModelRequest>
        Model::DescribeAlarmModelOutcomeCallable DescribeAlarmModelCallable(const DescribeAlarmModelRequestT& request) const
        {
            return SubmitCallable(&IoTEventsClient::DescribeAlarmModel, request);
        }
 
        template<typename DescribeAlarmModelRequestT = Model::DescribeAlarmModelRequest>
        void DescribeAlarmModelAsync(const DescribeAlarmModelRequestT& request, const DescribeAlarmModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTEventsClient::DescribeAlarmModel, request, handler, context);
        }
 
        virtual Model::DescribeDetectorModelOutcome DescribeDetectorModel(const Model::DescribeDetectorModelRequest& request) const;
 
        template<typename DescribeDetectorModelRequestT = Model::DescribeDetectorModelRequest>
        Model::DescribeDetectorModelOutcomeCallable DescribeDetectorModelCallable(const DescribeDetectorModelRequestT& request) const
        {
            return SubmitCallable(&IoTEventsClient::DescribeDetectorModel, request);
        }
 
        template<typename DescribeDetectorModelRequestT = Model::DescribeDetectorModelRequest>
        void DescribeDetectorModelAsync(const DescribeDetectorModelRequestT& request, const DescribeDetectorModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTEventsClient::DescribeDetectorModel, request, handler, context);
        }
 
        virtual Model::DescribeDetectorModelAnalysisOutcome DescribeDetectorModelAnalysis(const Model::DescribeDetectorModelAnalysisRequest& request) const;
 
        template<typename DescribeDetectorModelAnalysisRequestT = Model::DescribeDetectorModelAnalysisRequest>
        Model::DescribeDetectorModelAnalysisOutcomeCallable DescribeDetectorModelAnalysisCallable(const DescribeDetectorModelAnalysisRequestT& request) const
        {
            return SubmitCallable(&IoTEventsClient::DescribeDetectorModelAnalysis, request);
        }
 
        template<typename DescribeDetectorModelAnalysisRequestT = Model::DescribeDetectorModelAnalysisRequest>
        void DescribeDetectorModelAnalysisAsync(const DescribeDetectorModelAnalysisRequestT& request, const DescribeDetectorModelAnalysisResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTEventsClient::DescribeDetectorModelAnalysis, request, handler, context);
        }
 
        virtual Model::DescribeInputOutcome DescribeInput(const Model::DescribeInputRequest& request) const;
 
        template<typename DescribeInputRequestT = Model::DescribeInputRequest>
        Model::DescribeInputOutcomeCallable DescribeInputCallable(const DescribeInputRequestT& request) const
        {
            return SubmitCallable(&IoTEventsClient::DescribeInput, request);
        }
 
        template<typename DescribeInputRequestT = Model::DescribeInputRequest>
        void DescribeInputAsync(const DescribeInputRequestT& request, const DescribeInputResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTEventsClient::DescribeInput, request, handler, context);
        }
 
        virtual Model::DescribeLoggingOptionsOutcome DescribeLoggingOptions(const Model::DescribeLoggingOptionsRequest& request = {}) const;
 
        template<typename DescribeLoggingOptionsRequestT = Model::DescribeLoggingOptionsRequest>
        Model::DescribeLoggingOptionsOutcomeCallable DescribeLoggingOptionsCallable(const DescribeLoggingOptionsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTEventsClient::DescribeLoggingOptions, request);
        }
 
        template<typename DescribeLoggingOptionsRequestT = Model::DescribeLoggingOptionsRequest>
        void DescribeLoggingOptionsAsync(const DescribeLoggingOptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeLoggingOptionsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTEventsClient::DescribeLoggingOptions, request, handler, context);
        }
 
        virtual Model::GetDetectorModelAnalysisResultsOutcome GetDetectorModelAnalysisResults(const Model::GetDetectorModelAnalysisResultsRequest& request) const;
 
        template<typename GetDetectorModelAnalysisResultsRequestT = Model::GetDetectorModelAnalysisResultsRequest>
        Model::GetDetectorModelAnalysisResultsOutcomeCallable GetDetectorModelAnalysisResultsCallable(const GetDetectorModelAnalysisResultsRequestT& request) const
        {
            return SubmitCallable(&IoTEventsClient::GetDetectorModelAnalysisResults, request);
        }
 
        template<typename GetDetectorModelAnalysisResultsRequestT = Model::GetDetectorModelAnalysisResultsRequest>
        void GetDetectorModelAnalysisResultsAsync(const GetDetectorModelAnalysisResultsRequestT& request, const GetDetectorModelAnalysisResultsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTEventsClient::GetDetectorModelAnalysisResults, request, handler, context);
        }
 
        virtual Model::ListAlarmModelVersionsOutcome ListAlarmModelVersions(const Model::ListAlarmModelVersionsRequest& request) const;
 
        template<typename ListAlarmModelVersionsRequestT = Model::ListAlarmModelVersionsRequest>
        Model::ListAlarmModelVersionsOutcomeCallable ListAlarmModelVersionsCallable(const ListAlarmModelVersionsRequestT& request) const
        {
            return SubmitCallable(&IoTEventsClient::ListAlarmModelVersions, request);
        }
 
        template<typename ListAlarmModelVersionsRequestT = Model::ListAlarmModelVersionsRequest>
        void ListAlarmModelVersionsAsync(const ListAlarmModelVersionsRequestT& request, const ListAlarmModelVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTEventsClient::ListAlarmModelVersions, request, handler, context);
        }
 
        virtual Model::ListAlarmModelsOutcome ListAlarmModels(const Model::ListAlarmModelsRequest& request = {}) const;
 
        template<typename ListAlarmModelsRequestT = Model::ListAlarmModelsRequest>
        Model::ListAlarmModelsOutcomeCallable ListAlarmModelsCallable(const ListAlarmModelsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTEventsClient::ListAlarmModels, request);
        }
 
        template<typename ListAlarmModelsRequestT = Model::ListAlarmModelsRequest>
        void ListAlarmModelsAsync(const ListAlarmModelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAlarmModelsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTEventsClient::ListAlarmModels, request, handler, context);
        }
 
        virtual Model::ListDetectorModelVersionsOutcome ListDetectorModelVersions(const Model::ListDetectorModelVersionsRequest& request) const;
 
        template<typename ListDetectorModelVersionsRequestT = Model::ListDetectorModelVersionsRequest>
        Model::ListDetectorModelVersionsOutcomeCallable ListDetectorModelVersionsCallable(const ListDetectorModelVersionsRequestT& request) const
        {
            return SubmitCallable(&IoTEventsClient::ListDetectorModelVersions, request);
        }
 
        template<typename ListDetectorModelVersionsRequestT = Model::ListDetectorModelVersionsRequest>
        void ListDetectorModelVersionsAsync(const ListDetectorModelVersionsRequestT& request, const ListDetectorModelVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTEventsClient::ListDetectorModelVersions, request, handler, context);
        }
 
        virtual Model::ListDetectorModelsOutcome ListDetectorModels(const Model::ListDetectorModelsRequest& request = {}) const;
 
        template<typename ListDetectorModelsRequestT = Model::ListDetectorModelsRequest>
        Model::ListDetectorModelsOutcomeCallable ListDetectorModelsCallable(const ListDetectorModelsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTEventsClient::ListDetectorModels, request);
        }
 
        template<typename ListDetectorModelsRequestT = Model::ListDetectorModelsRequest>
        void ListDetectorModelsAsync(const ListDetectorModelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDetectorModelsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTEventsClient::ListDetectorModels, request, handler, context);
        }
 
        virtual Model::ListInputRoutingsOutcome ListInputRoutings(const Model::ListInputRoutingsRequest& request) const;
 
        template<typename ListInputRoutingsRequestT = Model::ListInputRoutingsRequest>
        Model::ListInputRoutingsOutcomeCallable ListInputRoutingsCallable(const ListInputRoutingsRequestT& request) const
        {
            return SubmitCallable(&IoTEventsClient::ListInputRoutings, request);
        }
 
        template<typename ListInputRoutingsRequestT = Model::ListInputRoutingsRequest>
        void ListInputRoutingsAsync(const ListInputRoutingsRequestT& request, const ListInputRoutingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTEventsClient::ListInputRoutings, request, handler, context);
        }
 
        virtual Model::ListInputsOutcome ListInputs(const Model::ListInputsRequest& request = {}) const;
 
        template<typename ListInputsRequestT = Model::ListInputsRequest>
        Model::ListInputsOutcomeCallable ListInputsCallable(const ListInputsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTEventsClient::ListInputs, request);
        }
 
        template<typename ListInputsRequestT = Model::ListInputsRequest>
        void ListInputsAsync(const ListInputsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListInputsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTEventsClient::ListInputs, 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(&IoTEventsClient::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(&IoTEventsClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutLoggingOptionsOutcome PutLoggingOptions(const Model::PutLoggingOptionsRequest& request) const;
 
        template<typename PutLoggingOptionsRequestT = Model::PutLoggingOptionsRequest>
        Model::PutLoggingOptionsOutcomeCallable PutLoggingOptionsCallable(const PutLoggingOptionsRequestT& request) const
        {
            return SubmitCallable(&IoTEventsClient::PutLoggingOptions, request);
        }
 
        template<typename PutLoggingOptionsRequestT = Model::PutLoggingOptionsRequest>
        void PutLoggingOptionsAsync(const PutLoggingOptionsRequestT& request, const PutLoggingOptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTEventsClient::PutLoggingOptions, request, handler, context);
        }
 
        virtual Model::StartDetectorModelAnalysisOutcome StartDetectorModelAnalysis(const Model::StartDetectorModelAnalysisRequest& request) const;
 
        template<typename StartDetectorModelAnalysisRequestT = Model::StartDetectorModelAnalysisRequest>
        Model::StartDetectorModelAnalysisOutcomeCallable StartDetectorModelAnalysisCallable(const StartDetectorModelAnalysisRequestT& request) const
        {
            return SubmitCallable(&IoTEventsClient::StartDetectorModelAnalysis, request);
        }
 
        template<typename StartDetectorModelAnalysisRequestT = Model::StartDetectorModelAnalysisRequest>
        void StartDetectorModelAnalysisAsync(const StartDetectorModelAnalysisRequestT& request, const StartDetectorModelAnalysisResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTEventsClient::StartDetectorModelAnalysis, 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(&IoTEventsClient::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(&IoTEventsClient::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(&IoTEventsClient::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(&IoTEventsClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAlarmModelOutcome UpdateAlarmModel(const Model::UpdateAlarmModelRequest& request) const;
 
        template<typename UpdateAlarmModelRequestT = Model::UpdateAlarmModelRequest>
        Model::UpdateAlarmModelOutcomeCallable UpdateAlarmModelCallable(const UpdateAlarmModelRequestT& request) const
        {
            return SubmitCallable(&IoTEventsClient::UpdateAlarmModel, request);
        }
 
        template<typename UpdateAlarmModelRequestT = Model::UpdateAlarmModelRequest>
        void UpdateAlarmModelAsync(const UpdateAlarmModelRequestT& request, const UpdateAlarmModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTEventsClient::UpdateAlarmModel, request, handler, context);
        }
 
        virtual Model::UpdateDetectorModelOutcome UpdateDetectorModel(const Model::UpdateDetectorModelRequest& request) const;
 
        template<typename UpdateDetectorModelRequestT = Model::UpdateDetectorModelRequest>
        Model::UpdateDetectorModelOutcomeCallable UpdateDetectorModelCallable(const UpdateDetectorModelRequestT& request) const
        {
            return SubmitCallable(&IoTEventsClient::UpdateDetectorModel, request);
        }
 
        template<typename UpdateDetectorModelRequestT = Model::UpdateDetectorModelRequest>
        void UpdateDetectorModelAsync(const UpdateDetectorModelRequestT& request, const UpdateDetectorModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTEventsClient::UpdateDetectorModel, request, handler, context);
        }
 
        virtual Model::UpdateInputOutcome UpdateInput(const Model::UpdateInputRequest& request) const;
 
        template<typename UpdateInputRequestT = Model::UpdateInputRequest>
        Model::UpdateInputOutcomeCallable UpdateInputCallable(const UpdateInputRequestT& request) const
        {
            return SubmitCallable(&IoTEventsClient::UpdateInput, request);
        }
 
        template<typename UpdateInputRequestT = Model::UpdateInputRequest>
        void UpdateInputAsync(const UpdateInputRequestT& request, const UpdateInputResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTEventsClient::UpdateInput, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<IoTEventsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<IoTEventsClient>;
      void init(const IoTEventsClientConfiguration& clientConfiguration);
 
      IoTEventsClientConfiguration m_clientConfiguration;
      std::shared_ptr<IoTEventsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace IoTEvents
} // namespace Aws