IoTEventsClient.h

 
#pragma once
#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>
#include <aws/iotevents/IoTEventsPaginationBase.h>
#include <aws/iotevents/IoTEventsServiceClientModel.h>
#include <aws/iotevents/IoTEventsWaiter.h>
#include <aws/iotevents/IoTEvents_EXPORTS.h>
 
namespace Aws {
namespace IoTEvents {
class AWS_IOTEVENTS_API IoTEventsClient : public Aws::Client::AWSJsonClient,
                                          public Aws::Client::ClientWithAsyncTemplateMethods<IoTEventsClient>,
                                          public IoTEventsPaginationBase<IoTEventsClient>,
                                          public IoTEventsWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<IoTEventsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<IoTEventsClient>;
  void init(const IoTEventsClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, IoTEventsError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  IoTEventsClientConfiguration m_clientConfiguration;
  std::shared_ptr<IoTEventsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace IoTEvents
}  // namespace Aws