LookoutEquipmentClient.h

 
#pragma once
#include <aws/lookoutequipment/LookoutEquipment_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/lookoutequipment/LookoutEquipmentServiceClientModel.h>
 
namespace Aws
{
namespace LookoutEquipment
{
  class AWS_LOOKOUTEQUIPMENT_API LookoutEquipmentClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<LookoutEquipmentClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef LookoutEquipmentClientConfiguration ClientConfigurationType;
      typedef LookoutEquipmentEndpointProvider EndpointProviderType;
 
        LookoutEquipmentClient(const Aws::LookoutEquipment::LookoutEquipmentClientConfiguration& clientConfiguration = Aws::LookoutEquipment::LookoutEquipmentClientConfiguration(),
                               std::shared_ptr<LookoutEquipmentEndpointProviderBase> endpointProvider = nullptr);
 
        LookoutEquipmentClient(const Aws::Auth::AWSCredentials& credentials,
                               std::shared_ptr<LookoutEquipmentEndpointProviderBase> endpointProvider = nullptr,
                               const Aws::LookoutEquipment::LookoutEquipmentClientConfiguration& clientConfiguration = Aws::LookoutEquipment::LookoutEquipmentClientConfiguration());
 
        LookoutEquipmentClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                               std::shared_ptr<LookoutEquipmentEndpointProviderBase> endpointProvider = nullptr,
                               const Aws::LookoutEquipment::LookoutEquipmentClientConfiguration& clientConfiguration = Aws::LookoutEquipment::LookoutEquipmentClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        LookoutEquipmentClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        LookoutEquipmentClient(const Aws::Auth::AWSCredentials& credentials,
                               const Aws::Client::ClientConfiguration& clientConfiguration);
 
        LookoutEquipmentClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                               const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~LookoutEquipmentClient();
 
        virtual Model::CreateDatasetOutcome CreateDataset(const Model::CreateDatasetRequest& request) const;
 
        template<typename CreateDatasetRequestT = Model::CreateDatasetRequest>
        Model::CreateDatasetOutcomeCallable CreateDatasetCallable(const CreateDatasetRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::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(&LookoutEquipmentClient::CreateDataset, request, handler, context);
        }
 
        virtual Model::CreateInferenceSchedulerOutcome CreateInferenceScheduler(const Model::CreateInferenceSchedulerRequest& request) const;
 
        template<typename CreateInferenceSchedulerRequestT = Model::CreateInferenceSchedulerRequest>
        Model::CreateInferenceSchedulerOutcomeCallable CreateInferenceSchedulerCallable(const CreateInferenceSchedulerRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::CreateInferenceScheduler, request);
        }
 
        template<typename CreateInferenceSchedulerRequestT = Model::CreateInferenceSchedulerRequest>
        void CreateInferenceSchedulerAsync(const CreateInferenceSchedulerRequestT& request, const CreateInferenceSchedulerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::CreateInferenceScheduler, request, handler, context);
        }
 
        virtual Model::CreateLabelOutcome CreateLabel(const Model::CreateLabelRequest& request) const;
 
        template<typename CreateLabelRequestT = Model::CreateLabelRequest>
        Model::CreateLabelOutcomeCallable CreateLabelCallable(const CreateLabelRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::CreateLabel, request);
        }
 
        template<typename CreateLabelRequestT = Model::CreateLabelRequest>
        void CreateLabelAsync(const CreateLabelRequestT& request, const CreateLabelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::CreateLabel, request, handler, context);
        }
 
        virtual Model::CreateLabelGroupOutcome CreateLabelGroup(const Model::CreateLabelGroupRequest& request) const;
 
        template<typename CreateLabelGroupRequestT = Model::CreateLabelGroupRequest>
        Model::CreateLabelGroupOutcomeCallable CreateLabelGroupCallable(const CreateLabelGroupRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::CreateLabelGroup, request);
        }
 
        template<typename CreateLabelGroupRequestT = Model::CreateLabelGroupRequest>
        void CreateLabelGroupAsync(const CreateLabelGroupRequestT& request, const CreateLabelGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::CreateLabelGroup, request, handler, context);
        }
 
        virtual Model::CreateModelOutcome CreateModel(const Model::CreateModelRequest& request) const;
 
        template<typename CreateModelRequestT = Model::CreateModelRequest>
        Model::CreateModelOutcomeCallable CreateModelCallable(const CreateModelRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::CreateModel, request);
        }
 
        template<typename CreateModelRequestT = Model::CreateModelRequest>
        void CreateModelAsync(const CreateModelRequestT& request, const CreateModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::CreateModel, request, handler, context);
        }
 
        virtual Model::CreateRetrainingSchedulerOutcome CreateRetrainingScheduler(const Model::CreateRetrainingSchedulerRequest& request) const;
 
        template<typename CreateRetrainingSchedulerRequestT = Model::CreateRetrainingSchedulerRequest>
        Model::CreateRetrainingSchedulerOutcomeCallable CreateRetrainingSchedulerCallable(const CreateRetrainingSchedulerRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::CreateRetrainingScheduler, request);
        }
 
        template<typename CreateRetrainingSchedulerRequestT = Model::CreateRetrainingSchedulerRequest>
        void CreateRetrainingSchedulerAsync(const CreateRetrainingSchedulerRequestT& request, const CreateRetrainingSchedulerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::CreateRetrainingScheduler, 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(&LookoutEquipmentClient::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(&LookoutEquipmentClient::DeleteDataset, request, handler, context);
        }
 
        virtual Model::DeleteInferenceSchedulerOutcome DeleteInferenceScheduler(const Model::DeleteInferenceSchedulerRequest& request) const;
 
        template<typename DeleteInferenceSchedulerRequestT = Model::DeleteInferenceSchedulerRequest>
        Model::DeleteInferenceSchedulerOutcomeCallable DeleteInferenceSchedulerCallable(const DeleteInferenceSchedulerRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::DeleteInferenceScheduler, request);
        }
 
        template<typename DeleteInferenceSchedulerRequestT = Model::DeleteInferenceSchedulerRequest>
        void DeleteInferenceSchedulerAsync(const DeleteInferenceSchedulerRequestT& request, const DeleteInferenceSchedulerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::DeleteInferenceScheduler, request, handler, context);
        }
 
        virtual Model::DeleteLabelOutcome DeleteLabel(const Model::DeleteLabelRequest& request) const;
 
        template<typename DeleteLabelRequestT = Model::DeleteLabelRequest>
        Model::DeleteLabelOutcomeCallable DeleteLabelCallable(const DeleteLabelRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::DeleteLabel, request);
        }
 
        template<typename DeleteLabelRequestT = Model::DeleteLabelRequest>
        void DeleteLabelAsync(const DeleteLabelRequestT& request, const DeleteLabelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::DeleteLabel, request, handler, context);
        }
 
        virtual Model::DeleteLabelGroupOutcome DeleteLabelGroup(const Model::DeleteLabelGroupRequest& request) const;
 
        template<typename DeleteLabelGroupRequestT = Model::DeleteLabelGroupRequest>
        Model::DeleteLabelGroupOutcomeCallable DeleteLabelGroupCallable(const DeleteLabelGroupRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::DeleteLabelGroup, request);
        }
 
        template<typename DeleteLabelGroupRequestT = Model::DeleteLabelGroupRequest>
        void DeleteLabelGroupAsync(const DeleteLabelGroupRequestT& request, const DeleteLabelGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::DeleteLabelGroup, request, handler, context);
        }
 
        virtual Model::DeleteModelOutcome DeleteModel(const Model::DeleteModelRequest& request) const;
 
        template<typename DeleteModelRequestT = Model::DeleteModelRequest>
        Model::DeleteModelOutcomeCallable DeleteModelCallable(const DeleteModelRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::DeleteModel, request);
        }
 
        template<typename DeleteModelRequestT = Model::DeleteModelRequest>
        void DeleteModelAsync(const DeleteModelRequestT& request, const DeleteModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::DeleteModel, request, handler, context);
        }
 
        virtual Model::DeleteResourcePolicyOutcome DeleteResourcePolicy(const Model::DeleteResourcePolicyRequest& request) const;
 
        template<typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
        Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable(const DeleteResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::DeleteResourcePolicy, request);
        }
 
        template<typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
        void DeleteResourcePolicyAsync(const DeleteResourcePolicyRequestT& request, const DeleteResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::DeleteResourcePolicy, request, handler, context);
        }
 
        virtual Model::DeleteRetrainingSchedulerOutcome DeleteRetrainingScheduler(const Model::DeleteRetrainingSchedulerRequest& request) const;
 
        template<typename DeleteRetrainingSchedulerRequestT = Model::DeleteRetrainingSchedulerRequest>
        Model::DeleteRetrainingSchedulerOutcomeCallable DeleteRetrainingSchedulerCallable(const DeleteRetrainingSchedulerRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::DeleteRetrainingScheduler, request);
        }
 
        template<typename DeleteRetrainingSchedulerRequestT = Model::DeleteRetrainingSchedulerRequest>
        void DeleteRetrainingSchedulerAsync(const DeleteRetrainingSchedulerRequestT& request, const DeleteRetrainingSchedulerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::DeleteRetrainingScheduler, request, handler, context);
        }
 
        virtual Model::DescribeDataIngestionJobOutcome DescribeDataIngestionJob(const Model::DescribeDataIngestionJobRequest& request) const;
 
        template<typename DescribeDataIngestionJobRequestT = Model::DescribeDataIngestionJobRequest>
        Model::DescribeDataIngestionJobOutcomeCallable DescribeDataIngestionJobCallable(const DescribeDataIngestionJobRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::DescribeDataIngestionJob, request);
        }
 
        template<typename DescribeDataIngestionJobRequestT = Model::DescribeDataIngestionJobRequest>
        void DescribeDataIngestionJobAsync(const DescribeDataIngestionJobRequestT& request, const DescribeDataIngestionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::DescribeDataIngestionJob, 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(&LookoutEquipmentClient::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(&LookoutEquipmentClient::DescribeDataset, request, handler, context);
        }
 
        virtual Model::DescribeInferenceSchedulerOutcome DescribeInferenceScheduler(const Model::DescribeInferenceSchedulerRequest& request) const;
 
        template<typename DescribeInferenceSchedulerRequestT = Model::DescribeInferenceSchedulerRequest>
        Model::DescribeInferenceSchedulerOutcomeCallable DescribeInferenceSchedulerCallable(const DescribeInferenceSchedulerRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::DescribeInferenceScheduler, request);
        }
 
        template<typename DescribeInferenceSchedulerRequestT = Model::DescribeInferenceSchedulerRequest>
        void DescribeInferenceSchedulerAsync(const DescribeInferenceSchedulerRequestT& request, const DescribeInferenceSchedulerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::DescribeInferenceScheduler, request, handler, context);
        }
 
        virtual Model::DescribeLabelOutcome DescribeLabel(const Model::DescribeLabelRequest& request) const;
 
        template<typename DescribeLabelRequestT = Model::DescribeLabelRequest>
        Model::DescribeLabelOutcomeCallable DescribeLabelCallable(const DescribeLabelRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::DescribeLabel, request);
        }
 
        template<typename DescribeLabelRequestT = Model::DescribeLabelRequest>
        void DescribeLabelAsync(const DescribeLabelRequestT& request, const DescribeLabelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::DescribeLabel, request, handler, context);
        }
 
        virtual Model::DescribeLabelGroupOutcome DescribeLabelGroup(const Model::DescribeLabelGroupRequest& request) const;
 
        template<typename DescribeLabelGroupRequestT = Model::DescribeLabelGroupRequest>
        Model::DescribeLabelGroupOutcomeCallable DescribeLabelGroupCallable(const DescribeLabelGroupRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::DescribeLabelGroup, request);
        }
 
        template<typename DescribeLabelGroupRequestT = Model::DescribeLabelGroupRequest>
        void DescribeLabelGroupAsync(const DescribeLabelGroupRequestT& request, const DescribeLabelGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::DescribeLabelGroup, request, handler, context);
        }
 
        virtual Model::DescribeModelOutcome DescribeModel(const Model::DescribeModelRequest& request) const;
 
        template<typename DescribeModelRequestT = Model::DescribeModelRequest>
        Model::DescribeModelOutcomeCallable DescribeModelCallable(const DescribeModelRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::DescribeModel, request);
        }
 
        template<typename DescribeModelRequestT = Model::DescribeModelRequest>
        void DescribeModelAsync(const DescribeModelRequestT& request, const DescribeModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::DescribeModel, request, handler, context);
        }
 
        virtual Model::DescribeModelVersionOutcome DescribeModelVersion(const Model::DescribeModelVersionRequest& request) const;
 
        template<typename DescribeModelVersionRequestT = Model::DescribeModelVersionRequest>
        Model::DescribeModelVersionOutcomeCallable DescribeModelVersionCallable(const DescribeModelVersionRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::DescribeModelVersion, request);
        }
 
        template<typename DescribeModelVersionRequestT = Model::DescribeModelVersionRequest>
        void DescribeModelVersionAsync(const DescribeModelVersionRequestT& request, const DescribeModelVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::DescribeModelVersion, request, handler, context);
        }
 
        virtual Model::DescribeResourcePolicyOutcome DescribeResourcePolicy(const Model::DescribeResourcePolicyRequest& request) const;
 
        template<typename DescribeResourcePolicyRequestT = Model::DescribeResourcePolicyRequest>
        Model::DescribeResourcePolicyOutcomeCallable DescribeResourcePolicyCallable(const DescribeResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::DescribeResourcePolicy, request);
        }
 
        template<typename DescribeResourcePolicyRequestT = Model::DescribeResourcePolicyRequest>
        void DescribeResourcePolicyAsync(const DescribeResourcePolicyRequestT& request, const DescribeResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::DescribeResourcePolicy, request, handler, context);
        }
 
        virtual Model::DescribeRetrainingSchedulerOutcome DescribeRetrainingScheduler(const Model::DescribeRetrainingSchedulerRequest& request) const;
 
        template<typename DescribeRetrainingSchedulerRequestT = Model::DescribeRetrainingSchedulerRequest>
        Model::DescribeRetrainingSchedulerOutcomeCallable DescribeRetrainingSchedulerCallable(const DescribeRetrainingSchedulerRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::DescribeRetrainingScheduler, request);
        }
 
        template<typename DescribeRetrainingSchedulerRequestT = Model::DescribeRetrainingSchedulerRequest>
        void DescribeRetrainingSchedulerAsync(const DescribeRetrainingSchedulerRequestT& request, const DescribeRetrainingSchedulerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::DescribeRetrainingScheduler, request, handler, context);
        }
 
        virtual Model::ImportDatasetOutcome ImportDataset(const Model::ImportDatasetRequest& request) const;
 
        template<typename ImportDatasetRequestT = Model::ImportDatasetRequest>
        Model::ImportDatasetOutcomeCallable ImportDatasetCallable(const ImportDatasetRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::ImportDataset, request);
        }
 
        template<typename ImportDatasetRequestT = Model::ImportDatasetRequest>
        void ImportDatasetAsync(const ImportDatasetRequestT& request, const ImportDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::ImportDataset, request, handler, context);
        }
 
        virtual Model::ImportModelVersionOutcome ImportModelVersion(const Model::ImportModelVersionRequest& request) const;
 
        template<typename ImportModelVersionRequestT = Model::ImportModelVersionRequest>
        Model::ImportModelVersionOutcomeCallable ImportModelVersionCallable(const ImportModelVersionRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::ImportModelVersion, request);
        }
 
        template<typename ImportModelVersionRequestT = Model::ImportModelVersionRequest>
        void ImportModelVersionAsync(const ImportModelVersionRequestT& request, const ImportModelVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::ImportModelVersion, request, handler, context);
        }
 
        virtual Model::ListDataIngestionJobsOutcome ListDataIngestionJobs(const Model::ListDataIngestionJobsRequest& request = {}) const;
 
        template<typename ListDataIngestionJobsRequestT = Model::ListDataIngestionJobsRequest>
        Model::ListDataIngestionJobsOutcomeCallable ListDataIngestionJobsCallable(const ListDataIngestionJobsRequestT& request = {}) const
        {
            return SubmitCallable(&LookoutEquipmentClient::ListDataIngestionJobs, request);
        }
 
        template<typename ListDataIngestionJobsRequestT = Model::ListDataIngestionJobsRequest>
        void ListDataIngestionJobsAsync(const ListDataIngestionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDataIngestionJobsRequestT& request = {}) const
        {
            return SubmitAsync(&LookoutEquipmentClient::ListDataIngestionJobs, 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(&LookoutEquipmentClient::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(&LookoutEquipmentClient::ListDatasets, request, handler, context);
        }
 
        virtual Model::ListInferenceEventsOutcome ListInferenceEvents(const Model::ListInferenceEventsRequest& request) const;
 
        template<typename ListInferenceEventsRequestT = Model::ListInferenceEventsRequest>
        Model::ListInferenceEventsOutcomeCallable ListInferenceEventsCallable(const ListInferenceEventsRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::ListInferenceEvents, request);
        }
 
        template<typename ListInferenceEventsRequestT = Model::ListInferenceEventsRequest>
        void ListInferenceEventsAsync(const ListInferenceEventsRequestT& request, const ListInferenceEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::ListInferenceEvents, request, handler, context);
        }
 
        virtual Model::ListInferenceExecutionsOutcome ListInferenceExecutions(const Model::ListInferenceExecutionsRequest& request) const;
 
        template<typename ListInferenceExecutionsRequestT = Model::ListInferenceExecutionsRequest>
        Model::ListInferenceExecutionsOutcomeCallable ListInferenceExecutionsCallable(const ListInferenceExecutionsRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::ListInferenceExecutions, request);
        }
 
        template<typename ListInferenceExecutionsRequestT = Model::ListInferenceExecutionsRequest>
        void ListInferenceExecutionsAsync(const ListInferenceExecutionsRequestT& request, const ListInferenceExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::ListInferenceExecutions, request, handler, context);
        }
 
        virtual Model::ListInferenceSchedulersOutcome ListInferenceSchedulers(const Model::ListInferenceSchedulersRequest& request = {}) const;
 
        template<typename ListInferenceSchedulersRequestT = Model::ListInferenceSchedulersRequest>
        Model::ListInferenceSchedulersOutcomeCallable ListInferenceSchedulersCallable(const ListInferenceSchedulersRequestT& request = {}) const
        {
            return SubmitCallable(&LookoutEquipmentClient::ListInferenceSchedulers, request);
        }
 
        template<typename ListInferenceSchedulersRequestT = Model::ListInferenceSchedulersRequest>
        void ListInferenceSchedulersAsync(const ListInferenceSchedulersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListInferenceSchedulersRequestT& request = {}) const
        {
            return SubmitAsync(&LookoutEquipmentClient::ListInferenceSchedulers, request, handler, context);
        }
 
        virtual Model::ListLabelGroupsOutcome ListLabelGroups(const Model::ListLabelGroupsRequest& request = {}) const;
 
        template<typename ListLabelGroupsRequestT = Model::ListLabelGroupsRequest>
        Model::ListLabelGroupsOutcomeCallable ListLabelGroupsCallable(const ListLabelGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&LookoutEquipmentClient::ListLabelGroups, request);
        }
 
        template<typename ListLabelGroupsRequestT = Model::ListLabelGroupsRequest>
        void ListLabelGroupsAsync(const ListLabelGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListLabelGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&LookoutEquipmentClient::ListLabelGroups, request, handler, context);
        }
 
        virtual Model::ListLabelsOutcome ListLabels(const Model::ListLabelsRequest& request) const;
 
        template<typename ListLabelsRequestT = Model::ListLabelsRequest>
        Model::ListLabelsOutcomeCallable ListLabelsCallable(const ListLabelsRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::ListLabels, request);
        }
 
        template<typename ListLabelsRequestT = Model::ListLabelsRequest>
        void ListLabelsAsync(const ListLabelsRequestT& request, const ListLabelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::ListLabels, request, handler, context);
        }
 
        virtual Model::ListModelVersionsOutcome ListModelVersions(const Model::ListModelVersionsRequest& request) const;
 
        template<typename ListModelVersionsRequestT = Model::ListModelVersionsRequest>
        Model::ListModelVersionsOutcomeCallable ListModelVersionsCallable(const ListModelVersionsRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::ListModelVersions, request);
        }
 
        template<typename ListModelVersionsRequestT = Model::ListModelVersionsRequest>
        void ListModelVersionsAsync(const ListModelVersionsRequestT& request, const ListModelVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::ListModelVersions, request, handler, context);
        }
 
        virtual Model::ListModelsOutcome ListModels(const Model::ListModelsRequest& request = {}) const;
 
        template<typename ListModelsRequestT = Model::ListModelsRequest>
        Model::ListModelsOutcomeCallable ListModelsCallable(const ListModelsRequestT& request = {}) const
        {
            return SubmitCallable(&LookoutEquipmentClient::ListModels, request);
        }
 
        template<typename ListModelsRequestT = Model::ListModelsRequest>
        void ListModelsAsync(const ListModelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListModelsRequestT& request = {}) const
        {
            return SubmitAsync(&LookoutEquipmentClient::ListModels, request, handler, context);
        }
 
        virtual Model::ListRetrainingSchedulersOutcome ListRetrainingSchedulers(const Model::ListRetrainingSchedulersRequest& request = {}) const;
 
        template<typename ListRetrainingSchedulersRequestT = Model::ListRetrainingSchedulersRequest>
        Model::ListRetrainingSchedulersOutcomeCallable ListRetrainingSchedulersCallable(const ListRetrainingSchedulersRequestT& request = {}) const
        {
            return SubmitCallable(&LookoutEquipmentClient::ListRetrainingSchedulers, request);
        }
 
        template<typename ListRetrainingSchedulersRequestT = Model::ListRetrainingSchedulersRequest>
        void ListRetrainingSchedulersAsync(const ListRetrainingSchedulersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRetrainingSchedulersRequestT& request = {}) const
        {
            return SubmitAsync(&LookoutEquipmentClient::ListRetrainingSchedulers, request, handler, context);
        }
 
        virtual Model::ListSensorStatisticsOutcome ListSensorStatistics(const Model::ListSensorStatisticsRequest& request) const;
 
        template<typename ListSensorStatisticsRequestT = Model::ListSensorStatisticsRequest>
        Model::ListSensorStatisticsOutcomeCallable ListSensorStatisticsCallable(const ListSensorStatisticsRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::ListSensorStatistics, request);
        }
 
        template<typename ListSensorStatisticsRequestT = Model::ListSensorStatisticsRequest>
        void ListSensorStatisticsAsync(const ListSensorStatisticsRequestT& request, const ListSensorStatisticsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::ListSensorStatistics, 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(&LookoutEquipmentClient::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(&LookoutEquipmentClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutResourcePolicyOutcome PutResourcePolicy(const Model::PutResourcePolicyRequest& request) const;
 
        template<typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
        Model::PutResourcePolicyOutcomeCallable PutResourcePolicyCallable(const PutResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::PutResourcePolicy, request);
        }
 
        template<typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
        void PutResourcePolicyAsync(const PutResourcePolicyRequestT& request, const PutResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::PutResourcePolicy, request, handler, context);
        }
 
        virtual Model::StartDataIngestionJobOutcome StartDataIngestionJob(const Model::StartDataIngestionJobRequest& request) const;
 
        template<typename StartDataIngestionJobRequestT = Model::StartDataIngestionJobRequest>
        Model::StartDataIngestionJobOutcomeCallable StartDataIngestionJobCallable(const StartDataIngestionJobRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::StartDataIngestionJob, request);
        }
 
        template<typename StartDataIngestionJobRequestT = Model::StartDataIngestionJobRequest>
        void StartDataIngestionJobAsync(const StartDataIngestionJobRequestT& request, const StartDataIngestionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::StartDataIngestionJob, request, handler, context);
        }
 
        virtual Model::StartInferenceSchedulerOutcome StartInferenceScheduler(const Model::StartInferenceSchedulerRequest& request) const;
 
        template<typename StartInferenceSchedulerRequestT = Model::StartInferenceSchedulerRequest>
        Model::StartInferenceSchedulerOutcomeCallable StartInferenceSchedulerCallable(const StartInferenceSchedulerRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::StartInferenceScheduler, request);
        }
 
        template<typename StartInferenceSchedulerRequestT = Model::StartInferenceSchedulerRequest>
        void StartInferenceSchedulerAsync(const StartInferenceSchedulerRequestT& request, const StartInferenceSchedulerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::StartInferenceScheduler, request, handler, context);
        }
 
        virtual Model::StartRetrainingSchedulerOutcome StartRetrainingScheduler(const Model::StartRetrainingSchedulerRequest& request) const;
 
        template<typename StartRetrainingSchedulerRequestT = Model::StartRetrainingSchedulerRequest>
        Model::StartRetrainingSchedulerOutcomeCallable StartRetrainingSchedulerCallable(const StartRetrainingSchedulerRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::StartRetrainingScheduler, request);
        }
 
        template<typename StartRetrainingSchedulerRequestT = Model::StartRetrainingSchedulerRequest>
        void StartRetrainingSchedulerAsync(const StartRetrainingSchedulerRequestT& request, const StartRetrainingSchedulerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::StartRetrainingScheduler, request, handler, context);
        }
 
        virtual Model::StopInferenceSchedulerOutcome StopInferenceScheduler(const Model::StopInferenceSchedulerRequest& request) const;
 
        template<typename StopInferenceSchedulerRequestT = Model::StopInferenceSchedulerRequest>
        Model::StopInferenceSchedulerOutcomeCallable StopInferenceSchedulerCallable(const StopInferenceSchedulerRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::StopInferenceScheduler, request);
        }
 
        template<typename StopInferenceSchedulerRequestT = Model::StopInferenceSchedulerRequest>
        void StopInferenceSchedulerAsync(const StopInferenceSchedulerRequestT& request, const StopInferenceSchedulerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::StopInferenceScheduler, request, handler, context);
        }
 
        virtual Model::StopRetrainingSchedulerOutcome StopRetrainingScheduler(const Model::StopRetrainingSchedulerRequest& request) const;
 
        template<typename StopRetrainingSchedulerRequestT = Model::StopRetrainingSchedulerRequest>
        Model::StopRetrainingSchedulerOutcomeCallable StopRetrainingSchedulerCallable(const StopRetrainingSchedulerRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::StopRetrainingScheduler, request);
        }
 
        template<typename StopRetrainingSchedulerRequestT = Model::StopRetrainingSchedulerRequest>
        void StopRetrainingSchedulerAsync(const StopRetrainingSchedulerRequestT& request, const StopRetrainingSchedulerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::StopRetrainingScheduler, 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(&LookoutEquipmentClient::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(&LookoutEquipmentClient::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(&LookoutEquipmentClient::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(&LookoutEquipmentClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateActiveModelVersionOutcome UpdateActiveModelVersion(const Model::UpdateActiveModelVersionRequest& request) const;
 
        template<typename UpdateActiveModelVersionRequestT = Model::UpdateActiveModelVersionRequest>
        Model::UpdateActiveModelVersionOutcomeCallable UpdateActiveModelVersionCallable(const UpdateActiveModelVersionRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::UpdateActiveModelVersion, request);
        }
 
        template<typename UpdateActiveModelVersionRequestT = Model::UpdateActiveModelVersionRequest>
        void UpdateActiveModelVersionAsync(const UpdateActiveModelVersionRequestT& request, const UpdateActiveModelVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::UpdateActiveModelVersion, request, handler, context);
        }
 
        virtual Model::UpdateInferenceSchedulerOutcome UpdateInferenceScheduler(const Model::UpdateInferenceSchedulerRequest& request) const;
 
        template<typename UpdateInferenceSchedulerRequestT = Model::UpdateInferenceSchedulerRequest>
        Model::UpdateInferenceSchedulerOutcomeCallable UpdateInferenceSchedulerCallable(const UpdateInferenceSchedulerRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::UpdateInferenceScheduler, request);
        }
 
        template<typename UpdateInferenceSchedulerRequestT = Model::UpdateInferenceSchedulerRequest>
        void UpdateInferenceSchedulerAsync(const UpdateInferenceSchedulerRequestT& request, const UpdateInferenceSchedulerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::UpdateInferenceScheduler, request, handler, context);
        }
 
        virtual Model::UpdateLabelGroupOutcome UpdateLabelGroup(const Model::UpdateLabelGroupRequest& request) const;
 
        template<typename UpdateLabelGroupRequestT = Model::UpdateLabelGroupRequest>
        Model::UpdateLabelGroupOutcomeCallable UpdateLabelGroupCallable(const UpdateLabelGroupRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::UpdateLabelGroup, request);
        }
 
        template<typename UpdateLabelGroupRequestT = Model::UpdateLabelGroupRequest>
        void UpdateLabelGroupAsync(const UpdateLabelGroupRequestT& request, const UpdateLabelGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::UpdateLabelGroup, request, handler, context);
        }
 
        virtual Model::UpdateModelOutcome UpdateModel(const Model::UpdateModelRequest& request) const;
 
        template<typename UpdateModelRequestT = Model::UpdateModelRequest>
        Model::UpdateModelOutcomeCallable UpdateModelCallable(const UpdateModelRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::UpdateModel, request);
        }
 
        template<typename UpdateModelRequestT = Model::UpdateModelRequest>
        void UpdateModelAsync(const UpdateModelRequestT& request, const UpdateModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::UpdateModel, request, handler, context);
        }
 
        virtual Model::UpdateRetrainingSchedulerOutcome UpdateRetrainingScheduler(const Model::UpdateRetrainingSchedulerRequest& request) const;
 
        template<typename UpdateRetrainingSchedulerRequestT = Model::UpdateRetrainingSchedulerRequest>
        Model::UpdateRetrainingSchedulerOutcomeCallable UpdateRetrainingSchedulerCallable(const UpdateRetrainingSchedulerRequestT& request) const
        {
            return SubmitCallable(&LookoutEquipmentClient::UpdateRetrainingScheduler, request);
        }
 
        template<typename UpdateRetrainingSchedulerRequestT = Model::UpdateRetrainingSchedulerRequest>
        void UpdateRetrainingSchedulerAsync(const UpdateRetrainingSchedulerRequestT& request, const UpdateRetrainingSchedulerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutEquipmentClient::UpdateRetrainingScheduler, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<LookoutEquipmentEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<LookoutEquipmentClient>;
      void init(const LookoutEquipmentClientConfiguration& clientConfiguration);
 
      LookoutEquipmentClientConfiguration m_clientConfiguration;
      std::shared_ptr<LookoutEquipmentEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace LookoutEquipment
} // namespace Aws