LookoutEquipmentClient.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/lookoutequipment/LookoutEquipmentPaginationBase.h>
#include <aws/lookoutequipment/LookoutEquipmentServiceClientModel.h>
#include <aws/lookoutequipment/LookoutEquipment_EXPORTS.h>
 
namespace Aws {
namespace LookoutEquipment {
class AWS_LOOKOUTEQUIPMENT_API LookoutEquipmentClient : public Aws::Client::AWSJsonClient,
                                                        public Aws::Client::ClientWithAsyncTemplateMethods<LookoutEquipmentClient>,
                                                        public LookoutEquipmentPaginationBase<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual 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