IoTAnalyticsClient.h

 
#pragma once
#include <aws/iotanalytics/IoTAnalytics_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/iotanalytics/IoTAnalyticsServiceClientModel.h>
 
namespace Aws
{
namespace IoTAnalytics
{
  class AWS_IOTANALYTICS_API IoTAnalyticsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<IoTAnalyticsClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef IoTAnalyticsClientConfiguration ClientConfigurationType;
      typedef IoTAnalyticsEndpointProvider EndpointProviderType;
 
        IoTAnalyticsClient(const Aws::IoTAnalytics::IoTAnalyticsClientConfiguration& clientConfiguration = Aws::IoTAnalytics::IoTAnalyticsClientConfiguration(),
                           std::shared_ptr<IoTAnalyticsEndpointProviderBase> endpointProvider = nullptr);
 
        IoTAnalyticsClient(const Aws::Auth::AWSCredentials& credentials,
                           std::shared_ptr<IoTAnalyticsEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::IoTAnalytics::IoTAnalyticsClientConfiguration& clientConfiguration = Aws::IoTAnalytics::IoTAnalyticsClientConfiguration());
 
        IoTAnalyticsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           std::shared_ptr<IoTAnalyticsEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::IoTAnalytics::IoTAnalyticsClientConfiguration& clientConfiguration = Aws::IoTAnalytics::IoTAnalyticsClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        IoTAnalyticsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IoTAnalyticsClient(const Aws::Auth::AWSCredentials& credentials,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IoTAnalyticsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~IoTAnalyticsClient();
 
        virtual Model::BatchPutMessageOutcome BatchPutMessage(const Model::BatchPutMessageRequest& request) const;
 
        template<typename BatchPutMessageRequestT = Model::BatchPutMessageRequest>
        Model::BatchPutMessageOutcomeCallable BatchPutMessageCallable(const BatchPutMessageRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::BatchPutMessage, request);
        }
 
        template<typename BatchPutMessageRequestT = Model::BatchPutMessageRequest>
        void BatchPutMessageAsync(const BatchPutMessageRequestT& request, const BatchPutMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::BatchPutMessage, request, handler, context);
        }
 
        virtual Model::CancelPipelineReprocessingOutcome CancelPipelineReprocessing(const Model::CancelPipelineReprocessingRequest& request) const;
 
        template<typename CancelPipelineReprocessingRequestT = Model::CancelPipelineReprocessingRequest>
        Model::CancelPipelineReprocessingOutcomeCallable CancelPipelineReprocessingCallable(const CancelPipelineReprocessingRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::CancelPipelineReprocessing, request);
        }
 
        template<typename CancelPipelineReprocessingRequestT = Model::CancelPipelineReprocessingRequest>
        void CancelPipelineReprocessingAsync(const CancelPipelineReprocessingRequestT& request, const CancelPipelineReprocessingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::CancelPipelineReprocessing, request, handler, context);
        }
 
        virtual Model::CreateChannelOutcome CreateChannel(const Model::CreateChannelRequest& request) const;
 
        template<typename CreateChannelRequestT = Model::CreateChannelRequest>
        Model::CreateChannelOutcomeCallable CreateChannelCallable(const CreateChannelRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::CreateChannel, request);
        }
 
        template<typename CreateChannelRequestT = Model::CreateChannelRequest>
        void CreateChannelAsync(const CreateChannelRequestT& request, const CreateChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::CreateChannel, request, handler, context);
        }
 
        virtual Model::CreateDatasetOutcome CreateDataset(const Model::CreateDatasetRequest& request) const;
 
        template<typename CreateDatasetRequestT = Model::CreateDatasetRequest>
        Model::CreateDatasetOutcomeCallable CreateDatasetCallable(const CreateDatasetRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::CreateDataset, request);
        }
 
        template<typename CreateDatasetRequestT = Model::CreateDatasetRequest>
        void CreateDatasetAsync(const CreateDatasetRequestT& request, const CreateDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::CreateDataset, request, handler, context);
        }
 
        virtual Model::CreateDatasetContentOutcome CreateDatasetContent(const Model::CreateDatasetContentRequest& request) const;
 
        template<typename CreateDatasetContentRequestT = Model::CreateDatasetContentRequest>
        Model::CreateDatasetContentOutcomeCallable CreateDatasetContentCallable(const CreateDatasetContentRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::CreateDatasetContent, request);
        }
 
        template<typename CreateDatasetContentRequestT = Model::CreateDatasetContentRequest>
        void CreateDatasetContentAsync(const CreateDatasetContentRequestT& request, const CreateDatasetContentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::CreateDatasetContent, request, handler, context);
        }
 
        virtual Model::CreateDatastoreOutcome CreateDatastore(const Model::CreateDatastoreRequest& request) const;
 
        template<typename CreateDatastoreRequestT = Model::CreateDatastoreRequest>
        Model::CreateDatastoreOutcomeCallable CreateDatastoreCallable(const CreateDatastoreRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::CreateDatastore, request);
        }
 
        template<typename CreateDatastoreRequestT = Model::CreateDatastoreRequest>
        void CreateDatastoreAsync(const CreateDatastoreRequestT& request, const CreateDatastoreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::CreateDatastore, request, handler, context);
        }
 
        virtual Model::CreatePipelineOutcome CreatePipeline(const Model::CreatePipelineRequest& request) const;
 
        template<typename CreatePipelineRequestT = Model::CreatePipelineRequest>
        Model::CreatePipelineOutcomeCallable CreatePipelineCallable(const CreatePipelineRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::CreatePipeline, request);
        }
 
        template<typename CreatePipelineRequestT = Model::CreatePipelineRequest>
        void CreatePipelineAsync(const CreatePipelineRequestT& request, const CreatePipelineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::CreatePipeline, request, handler, context);
        }
 
        virtual Model::DeleteChannelOutcome DeleteChannel(const Model::DeleteChannelRequest& request) const;
 
        template<typename DeleteChannelRequestT = Model::DeleteChannelRequest>
        Model::DeleteChannelOutcomeCallable DeleteChannelCallable(const DeleteChannelRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::DeleteChannel, request);
        }
 
        template<typename DeleteChannelRequestT = Model::DeleteChannelRequest>
        void DeleteChannelAsync(const DeleteChannelRequestT& request, const DeleteChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::DeleteChannel, request, handler, context);
        }
 
        virtual Model::DeleteDatasetOutcome DeleteDataset(const Model::DeleteDatasetRequest& request) const;
 
        template<typename DeleteDatasetRequestT = Model::DeleteDatasetRequest>
        Model::DeleteDatasetOutcomeCallable DeleteDatasetCallable(const DeleteDatasetRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::DeleteDataset, request);
        }
 
        template<typename DeleteDatasetRequestT = Model::DeleteDatasetRequest>
        void DeleteDatasetAsync(const DeleteDatasetRequestT& request, const DeleteDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::DeleteDataset, request, handler, context);
        }
 
        virtual Model::DeleteDatasetContentOutcome DeleteDatasetContent(const Model::DeleteDatasetContentRequest& request) const;
 
        template<typename DeleteDatasetContentRequestT = Model::DeleteDatasetContentRequest>
        Model::DeleteDatasetContentOutcomeCallable DeleteDatasetContentCallable(const DeleteDatasetContentRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::DeleteDatasetContent, request);
        }
 
        template<typename DeleteDatasetContentRequestT = Model::DeleteDatasetContentRequest>
        void DeleteDatasetContentAsync(const DeleteDatasetContentRequestT& request, const DeleteDatasetContentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::DeleteDatasetContent, request, handler, context);
        }
 
        virtual Model::DeleteDatastoreOutcome DeleteDatastore(const Model::DeleteDatastoreRequest& request) const;
 
        template<typename DeleteDatastoreRequestT = Model::DeleteDatastoreRequest>
        Model::DeleteDatastoreOutcomeCallable DeleteDatastoreCallable(const DeleteDatastoreRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::DeleteDatastore, request);
        }
 
        template<typename DeleteDatastoreRequestT = Model::DeleteDatastoreRequest>
        void DeleteDatastoreAsync(const DeleteDatastoreRequestT& request, const DeleteDatastoreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::DeleteDatastore, request, handler, context);
        }
 
        virtual Model::DeletePipelineOutcome DeletePipeline(const Model::DeletePipelineRequest& request) const;
 
        template<typename DeletePipelineRequestT = Model::DeletePipelineRequest>
        Model::DeletePipelineOutcomeCallable DeletePipelineCallable(const DeletePipelineRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::DeletePipeline, request);
        }
 
        template<typename DeletePipelineRequestT = Model::DeletePipelineRequest>
        void DeletePipelineAsync(const DeletePipelineRequestT& request, const DeletePipelineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::DeletePipeline, request, handler, context);
        }
 
        virtual Model::DescribeChannelOutcome DescribeChannel(const Model::DescribeChannelRequest& request) const;
 
        template<typename DescribeChannelRequestT = Model::DescribeChannelRequest>
        Model::DescribeChannelOutcomeCallable DescribeChannelCallable(const DescribeChannelRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::DescribeChannel, request);
        }
 
        template<typename DescribeChannelRequestT = Model::DescribeChannelRequest>
        void DescribeChannelAsync(const DescribeChannelRequestT& request, const DescribeChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::DescribeChannel, request, handler, context);
        }
 
        virtual Model::DescribeDatasetOutcome DescribeDataset(const Model::DescribeDatasetRequest& request) const;
 
        template<typename DescribeDatasetRequestT = Model::DescribeDatasetRequest>
        Model::DescribeDatasetOutcomeCallable DescribeDatasetCallable(const DescribeDatasetRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::DescribeDataset, request);
        }
 
        template<typename DescribeDatasetRequestT = Model::DescribeDatasetRequest>
        void DescribeDatasetAsync(const DescribeDatasetRequestT& request, const DescribeDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::DescribeDataset, request, handler, context);
        }
 
        virtual Model::DescribeDatastoreOutcome DescribeDatastore(const Model::DescribeDatastoreRequest& request) const;
 
        template<typename DescribeDatastoreRequestT = Model::DescribeDatastoreRequest>
        Model::DescribeDatastoreOutcomeCallable DescribeDatastoreCallable(const DescribeDatastoreRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::DescribeDatastore, request);
        }
 
        template<typename DescribeDatastoreRequestT = Model::DescribeDatastoreRequest>
        void DescribeDatastoreAsync(const DescribeDatastoreRequestT& request, const DescribeDatastoreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::DescribeDatastore, 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(&IoTAnalyticsClient::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(&IoTAnalyticsClient::DescribeLoggingOptions, request, handler, context);
        }
 
        virtual Model::DescribePipelineOutcome DescribePipeline(const Model::DescribePipelineRequest& request) const;
 
        template<typename DescribePipelineRequestT = Model::DescribePipelineRequest>
        Model::DescribePipelineOutcomeCallable DescribePipelineCallable(const DescribePipelineRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::DescribePipeline, request);
        }
 
        template<typename DescribePipelineRequestT = Model::DescribePipelineRequest>
        void DescribePipelineAsync(const DescribePipelineRequestT& request, const DescribePipelineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::DescribePipeline, request, handler, context);
        }
 
        virtual Model::GetDatasetContentOutcome GetDatasetContent(const Model::GetDatasetContentRequest& request) const;
 
        template<typename GetDatasetContentRequestT = Model::GetDatasetContentRequest>
        Model::GetDatasetContentOutcomeCallable GetDatasetContentCallable(const GetDatasetContentRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::GetDatasetContent, request);
        }
 
        template<typename GetDatasetContentRequestT = Model::GetDatasetContentRequest>
        void GetDatasetContentAsync(const GetDatasetContentRequestT& request, const GetDatasetContentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::GetDatasetContent, request, handler, context);
        }
 
        virtual Model::ListChannelsOutcome ListChannels(const Model::ListChannelsRequest& request = {}) const;
 
        template<typename ListChannelsRequestT = Model::ListChannelsRequest>
        Model::ListChannelsOutcomeCallable ListChannelsCallable(const ListChannelsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTAnalyticsClient::ListChannels, request);
        }
 
        template<typename ListChannelsRequestT = Model::ListChannelsRequest>
        void ListChannelsAsync(const ListChannelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListChannelsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTAnalyticsClient::ListChannels, request, handler, context);
        }
 
        virtual Model::ListDatasetContentsOutcome ListDatasetContents(const Model::ListDatasetContentsRequest& request) const;
 
        template<typename ListDatasetContentsRequestT = Model::ListDatasetContentsRequest>
        Model::ListDatasetContentsOutcomeCallable ListDatasetContentsCallable(const ListDatasetContentsRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::ListDatasetContents, request);
        }
 
        template<typename ListDatasetContentsRequestT = Model::ListDatasetContentsRequest>
        void ListDatasetContentsAsync(const ListDatasetContentsRequestT& request, const ListDatasetContentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::ListDatasetContents, request, handler, context);
        }
 
        virtual Model::ListDatasetsOutcome ListDatasets(const Model::ListDatasetsRequest& request = {}) const;
 
        template<typename ListDatasetsRequestT = Model::ListDatasetsRequest>
        Model::ListDatasetsOutcomeCallable ListDatasetsCallable(const ListDatasetsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTAnalyticsClient::ListDatasets, request);
        }
 
        template<typename ListDatasetsRequestT = Model::ListDatasetsRequest>
        void ListDatasetsAsync(const ListDatasetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDatasetsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTAnalyticsClient::ListDatasets, request, handler, context);
        }
 
        virtual Model::ListDatastoresOutcome ListDatastores(const Model::ListDatastoresRequest& request = {}) const;
 
        template<typename ListDatastoresRequestT = Model::ListDatastoresRequest>
        Model::ListDatastoresOutcomeCallable ListDatastoresCallable(const ListDatastoresRequestT& request = {}) const
        {
            return SubmitCallable(&IoTAnalyticsClient::ListDatastores, request);
        }
 
        template<typename ListDatastoresRequestT = Model::ListDatastoresRequest>
        void ListDatastoresAsync(const ListDatastoresResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDatastoresRequestT& request = {}) const
        {
            return SubmitAsync(&IoTAnalyticsClient::ListDatastores, request, handler, context);
        }
 
        virtual Model::ListPipelinesOutcome ListPipelines(const Model::ListPipelinesRequest& request = {}) const;
 
        template<typename ListPipelinesRequestT = Model::ListPipelinesRequest>
        Model::ListPipelinesOutcomeCallable ListPipelinesCallable(const ListPipelinesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTAnalyticsClient::ListPipelines, request);
        }
 
        template<typename ListPipelinesRequestT = Model::ListPipelinesRequest>
        void ListPipelinesAsync(const ListPipelinesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPipelinesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTAnalyticsClient::ListPipelines, 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(&IoTAnalyticsClient::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(&IoTAnalyticsClient::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(&IoTAnalyticsClient::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(&IoTAnalyticsClient::PutLoggingOptions, request, handler, context);
        }
 
        virtual Model::RunPipelineActivityOutcome RunPipelineActivity(const Model::RunPipelineActivityRequest& request) const;
 
        template<typename RunPipelineActivityRequestT = Model::RunPipelineActivityRequest>
        Model::RunPipelineActivityOutcomeCallable RunPipelineActivityCallable(const RunPipelineActivityRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::RunPipelineActivity, request);
        }
 
        template<typename RunPipelineActivityRequestT = Model::RunPipelineActivityRequest>
        void RunPipelineActivityAsync(const RunPipelineActivityRequestT& request, const RunPipelineActivityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::RunPipelineActivity, request, handler, context);
        }
 
        virtual Model::SampleChannelDataOutcome SampleChannelData(const Model::SampleChannelDataRequest& request) const;
 
        template<typename SampleChannelDataRequestT = Model::SampleChannelDataRequest>
        Model::SampleChannelDataOutcomeCallable SampleChannelDataCallable(const SampleChannelDataRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::SampleChannelData, request);
        }
 
        template<typename SampleChannelDataRequestT = Model::SampleChannelDataRequest>
        void SampleChannelDataAsync(const SampleChannelDataRequestT& request, const SampleChannelDataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::SampleChannelData, request, handler, context);
        }
 
        virtual Model::StartPipelineReprocessingOutcome StartPipelineReprocessing(const Model::StartPipelineReprocessingRequest& request) const;
 
        template<typename StartPipelineReprocessingRequestT = Model::StartPipelineReprocessingRequest>
        Model::StartPipelineReprocessingOutcomeCallable StartPipelineReprocessingCallable(const StartPipelineReprocessingRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::StartPipelineReprocessing, request);
        }
 
        template<typename StartPipelineReprocessingRequestT = Model::StartPipelineReprocessingRequest>
        void StartPipelineReprocessingAsync(const StartPipelineReprocessingRequestT& request, const StartPipelineReprocessingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::StartPipelineReprocessing, 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(&IoTAnalyticsClient::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(&IoTAnalyticsClient::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(&IoTAnalyticsClient::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(&IoTAnalyticsClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateChannelOutcome UpdateChannel(const Model::UpdateChannelRequest& request) const;
 
        template<typename UpdateChannelRequestT = Model::UpdateChannelRequest>
        Model::UpdateChannelOutcomeCallable UpdateChannelCallable(const UpdateChannelRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::UpdateChannel, request);
        }
 
        template<typename UpdateChannelRequestT = Model::UpdateChannelRequest>
        void UpdateChannelAsync(const UpdateChannelRequestT& request, const UpdateChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::UpdateChannel, request, handler, context);
        }
 
        virtual Model::UpdateDatasetOutcome UpdateDataset(const Model::UpdateDatasetRequest& request) const;
 
        template<typename UpdateDatasetRequestT = Model::UpdateDatasetRequest>
        Model::UpdateDatasetOutcomeCallable UpdateDatasetCallable(const UpdateDatasetRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::UpdateDataset, request);
        }
 
        template<typename UpdateDatasetRequestT = Model::UpdateDatasetRequest>
        void UpdateDatasetAsync(const UpdateDatasetRequestT& request, const UpdateDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::UpdateDataset, request, handler, context);
        }
 
        virtual Model::UpdateDatastoreOutcome UpdateDatastore(const Model::UpdateDatastoreRequest& request) const;
 
        template<typename UpdateDatastoreRequestT = Model::UpdateDatastoreRequest>
        Model::UpdateDatastoreOutcomeCallable UpdateDatastoreCallable(const UpdateDatastoreRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::UpdateDatastore, request);
        }
 
        template<typename UpdateDatastoreRequestT = Model::UpdateDatastoreRequest>
        void UpdateDatastoreAsync(const UpdateDatastoreRequestT& request, const UpdateDatastoreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::UpdateDatastore, request, handler, context);
        }
 
        virtual Model::UpdatePipelineOutcome UpdatePipeline(const Model::UpdatePipelineRequest& request) const;
 
        template<typename UpdatePipelineRequestT = Model::UpdatePipelineRequest>
        Model::UpdatePipelineOutcomeCallable UpdatePipelineCallable(const UpdatePipelineRequestT& request) const
        {
            return SubmitCallable(&IoTAnalyticsClient::UpdatePipeline, request);
        }
 
        template<typename UpdatePipelineRequestT = Model::UpdatePipelineRequest>
        void UpdatePipelineAsync(const UpdatePipelineRequestT& request, const UpdatePipelineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTAnalyticsClient::UpdatePipeline, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<IoTAnalyticsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<IoTAnalyticsClient>;
      void init(const IoTAnalyticsClientConfiguration& clientConfiguration);
 
      IoTAnalyticsClientConfiguration m_clientConfiguration;
      std::shared_ptr<IoTAnalyticsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace IoTAnalytics
} // namespace Aws