IoTTwinMakerClient.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/iottwinmaker/IoTTwinMakerPaginationBase.h>
#include <aws/iottwinmaker/IoTTwinMakerServiceClientModel.h>
#include <aws/iottwinmaker/IoTTwinMakerWaiter.h>
#include <aws/iottwinmaker/IoTTwinMaker_EXPORTS.h>
 
namespace Aws {
namespace IoTTwinMaker {
class AWS_IOTTWINMAKER_API IoTTwinMakerClient : public Aws::Client::AWSJsonClient,
                                                public Aws::Client::ClientWithAsyncTemplateMethods<IoTTwinMakerClient>,
                                                public IoTTwinMakerPaginationBase<IoTTwinMakerClient>,
                                                public IoTTwinMakerWaiter<IoTTwinMakerClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef IoTTwinMakerClientConfiguration ClientConfigurationType;
  typedef IoTTwinMakerEndpointProvider EndpointProviderType;
 
  IoTTwinMakerClient(
      const Aws::IoTTwinMaker::IoTTwinMakerClientConfiguration& clientConfiguration = Aws::IoTTwinMaker::IoTTwinMakerClientConfiguration(),
      std::shared_ptr<IoTTwinMakerEndpointProviderBase> endpointProvider = nullptr);
 
  IoTTwinMakerClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<IoTTwinMakerEndpointProviderBase> endpointProvider = nullptr,
      const Aws::IoTTwinMaker::IoTTwinMakerClientConfiguration& clientConfiguration = Aws::IoTTwinMaker::IoTTwinMakerClientConfiguration());
 
  IoTTwinMakerClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<IoTTwinMakerEndpointProviderBase> endpointProvider = nullptr,
      const Aws::IoTTwinMaker::IoTTwinMakerClientConfiguration& clientConfiguration = Aws::IoTTwinMaker::IoTTwinMakerClientConfiguration());
 
  /* Legacy constructors due deprecation */
  IoTTwinMakerClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  IoTTwinMakerClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  IoTTwinMakerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~IoTTwinMakerClient();
 
  virtual Model::BatchPutPropertyValuesOutcome BatchPutPropertyValues(const Model::BatchPutPropertyValuesRequest& request) const;
 
  template <typename BatchPutPropertyValuesRequestT = Model::BatchPutPropertyValuesRequest>
  Model::BatchPutPropertyValuesOutcomeCallable BatchPutPropertyValuesCallable(const BatchPutPropertyValuesRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::BatchPutPropertyValues, request);
  }
 
  template <typename BatchPutPropertyValuesRequestT = Model::BatchPutPropertyValuesRequest>
  void BatchPutPropertyValuesAsync(const BatchPutPropertyValuesRequestT& request,
                                   const BatchPutPropertyValuesResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::BatchPutPropertyValues, request, handler, context);
  }
 
  virtual Model::CancelMetadataTransferJobOutcome CancelMetadataTransferJob(const Model::CancelMetadataTransferJobRequest& request) const;
 
  template <typename CancelMetadataTransferJobRequestT = Model::CancelMetadataTransferJobRequest>
  Model::CancelMetadataTransferJobOutcomeCallable CancelMetadataTransferJobCallable(
      const CancelMetadataTransferJobRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::CancelMetadataTransferJob, request);
  }
 
  template <typename CancelMetadataTransferJobRequestT = Model::CancelMetadataTransferJobRequest>
  void CancelMetadataTransferJobAsync(const CancelMetadataTransferJobRequestT& request,
                                      const CancelMetadataTransferJobResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::CancelMetadataTransferJob, request, handler, context);
  }
 
  virtual Model::CreateComponentTypeOutcome CreateComponentType(const Model::CreateComponentTypeRequest& request) const;
 
  template <typename CreateComponentTypeRequestT = Model::CreateComponentTypeRequest>
  Model::CreateComponentTypeOutcomeCallable CreateComponentTypeCallable(const CreateComponentTypeRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::CreateComponentType, request);
  }
 
  template <typename CreateComponentTypeRequestT = Model::CreateComponentTypeRequest>
  void CreateComponentTypeAsync(const CreateComponentTypeRequestT& request, const CreateComponentTypeResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::CreateComponentType, request, handler, context);
  }
 
  virtual Model::CreateEntityOutcome CreateEntity(const Model::CreateEntityRequest& request) const;
 
  template <typename CreateEntityRequestT = Model::CreateEntityRequest>
  Model::CreateEntityOutcomeCallable CreateEntityCallable(const CreateEntityRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::CreateEntity, request);
  }
 
  template <typename CreateEntityRequestT = Model::CreateEntityRequest>
  void CreateEntityAsync(const CreateEntityRequestT& request, const CreateEntityResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::CreateEntity, request, handler, context);
  }
 
  virtual Model::CreateMetadataTransferJobOutcome CreateMetadataTransferJob(const Model::CreateMetadataTransferJobRequest& request) const;
 
  template <typename CreateMetadataTransferJobRequestT = Model::CreateMetadataTransferJobRequest>
  Model::CreateMetadataTransferJobOutcomeCallable CreateMetadataTransferJobCallable(
      const CreateMetadataTransferJobRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::CreateMetadataTransferJob, request);
  }
 
  template <typename CreateMetadataTransferJobRequestT = Model::CreateMetadataTransferJobRequest>
  void CreateMetadataTransferJobAsync(const CreateMetadataTransferJobRequestT& request,
                                      const CreateMetadataTransferJobResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::CreateMetadataTransferJob, request, handler, context);
  }
 
  virtual Model::CreateSceneOutcome CreateScene(const Model::CreateSceneRequest& request) const;
 
  template <typename CreateSceneRequestT = Model::CreateSceneRequest>
  Model::CreateSceneOutcomeCallable CreateSceneCallable(const CreateSceneRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::CreateScene, request);
  }
 
  template <typename CreateSceneRequestT = Model::CreateSceneRequest>
  void CreateSceneAsync(const CreateSceneRequestT& request, const CreateSceneResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::CreateScene, request, handler, context);
  }
 
  virtual Model::CreateSyncJobOutcome CreateSyncJob(const Model::CreateSyncJobRequest& request) const;
 
  template <typename CreateSyncJobRequestT = Model::CreateSyncJobRequest>
  Model::CreateSyncJobOutcomeCallable CreateSyncJobCallable(const CreateSyncJobRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::CreateSyncJob, request);
  }
 
  template <typename CreateSyncJobRequestT = Model::CreateSyncJobRequest>
  void CreateSyncJobAsync(const CreateSyncJobRequestT& request, const CreateSyncJobResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::CreateSyncJob, request, handler, context);
  }
 
  virtual Model::CreateWorkspaceOutcome CreateWorkspace(const Model::CreateWorkspaceRequest& request) const;
 
  template <typename CreateWorkspaceRequestT = Model::CreateWorkspaceRequest>
  Model::CreateWorkspaceOutcomeCallable CreateWorkspaceCallable(const CreateWorkspaceRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::CreateWorkspace, request);
  }
 
  template <typename CreateWorkspaceRequestT = Model::CreateWorkspaceRequest>
  void CreateWorkspaceAsync(const CreateWorkspaceRequestT& request, const CreateWorkspaceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::CreateWorkspace, request, handler, context);
  }
 
  virtual Model::DeleteComponentTypeOutcome DeleteComponentType(const Model::DeleteComponentTypeRequest& request) const;
 
  template <typename DeleteComponentTypeRequestT = Model::DeleteComponentTypeRequest>
  Model::DeleteComponentTypeOutcomeCallable DeleteComponentTypeCallable(const DeleteComponentTypeRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::DeleteComponentType, request);
  }
 
  template <typename DeleteComponentTypeRequestT = Model::DeleteComponentTypeRequest>
  void DeleteComponentTypeAsync(const DeleteComponentTypeRequestT& request, const DeleteComponentTypeResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::DeleteComponentType, request, handler, context);
  }
 
  virtual Model::DeleteEntityOutcome DeleteEntity(const Model::DeleteEntityRequest& request) const;
 
  template <typename DeleteEntityRequestT = Model::DeleteEntityRequest>
  Model::DeleteEntityOutcomeCallable DeleteEntityCallable(const DeleteEntityRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::DeleteEntity, request);
  }
 
  template <typename DeleteEntityRequestT = Model::DeleteEntityRequest>
  void DeleteEntityAsync(const DeleteEntityRequestT& request, const DeleteEntityResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::DeleteEntity, request, handler, context);
  }
 
  virtual Model::DeleteSceneOutcome DeleteScene(const Model::DeleteSceneRequest& request) const;
 
  template <typename DeleteSceneRequestT = Model::DeleteSceneRequest>
  Model::DeleteSceneOutcomeCallable DeleteSceneCallable(const DeleteSceneRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::DeleteScene, request);
  }
 
  template <typename DeleteSceneRequestT = Model::DeleteSceneRequest>
  void DeleteSceneAsync(const DeleteSceneRequestT& request, const DeleteSceneResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::DeleteScene, request, handler, context);
  }
 
  virtual Model::DeleteSyncJobOutcome DeleteSyncJob(const Model::DeleteSyncJobRequest& request) const;
 
  template <typename DeleteSyncJobRequestT = Model::DeleteSyncJobRequest>
  Model::DeleteSyncJobOutcomeCallable DeleteSyncJobCallable(const DeleteSyncJobRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::DeleteSyncJob, request);
  }
 
  template <typename DeleteSyncJobRequestT = Model::DeleteSyncJobRequest>
  void DeleteSyncJobAsync(const DeleteSyncJobRequestT& request, const DeleteSyncJobResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::DeleteSyncJob, request, handler, context);
  }
 
  virtual Model::DeleteWorkspaceOutcome DeleteWorkspace(const Model::DeleteWorkspaceRequest& request) const;
 
  template <typename DeleteWorkspaceRequestT = Model::DeleteWorkspaceRequest>
  Model::DeleteWorkspaceOutcomeCallable DeleteWorkspaceCallable(const DeleteWorkspaceRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::DeleteWorkspace, request);
  }
 
  template <typename DeleteWorkspaceRequestT = Model::DeleteWorkspaceRequest>
  void DeleteWorkspaceAsync(const DeleteWorkspaceRequestT& request, const DeleteWorkspaceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::DeleteWorkspace, request, handler, context);
  }
 
  virtual Model::ExecuteQueryOutcome ExecuteQuery(const Model::ExecuteQueryRequest& request) const;
 
  template <typename ExecuteQueryRequestT = Model::ExecuteQueryRequest>
  Model::ExecuteQueryOutcomeCallable ExecuteQueryCallable(const ExecuteQueryRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::ExecuteQuery, request);
  }
 
  template <typename ExecuteQueryRequestT = Model::ExecuteQueryRequest>
  void ExecuteQueryAsync(const ExecuteQueryRequestT& request, const ExecuteQueryResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::ExecuteQuery, request, handler, context);
  }
 
  virtual Model::GetComponentTypeOutcome GetComponentType(const Model::GetComponentTypeRequest& request) const;
 
  template <typename GetComponentTypeRequestT = Model::GetComponentTypeRequest>
  Model::GetComponentTypeOutcomeCallable GetComponentTypeCallable(const GetComponentTypeRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::GetComponentType, request);
  }
 
  template <typename GetComponentTypeRequestT = Model::GetComponentTypeRequest>
  void GetComponentTypeAsync(const GetComponentTypeRequestT& request, const GetComponentTypeResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::GetComponentType, request, handler, context);
  }
 
  virtual Model::GetEntityOutcome GetEntity(const Model::GetEntityRequest& request) const;
 
  template <typename GetEntityRequestT = Model::GetEntityRequest>
  Model::GetEntityOutcomeCallable GetEntityCallable(const GetEntityRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::GetEntity, request);
  }
 
  template <typename GetEntityRequestT = Model::GetEntityRequest>
  void GetEntityAsync(const GetEntityRequestT& request, const GetEntityResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::GetEntity, request, handler, context);
  }
 
  virtual Model::GetMetadataTransferJobOutcome GetMetadataTransferJob(const Model::GetMetadataTransferJobRequest& request) const;
 
  template <typename GetMetadataTransferJobRequestT = Model::GetMetadataTransferJobRequest>
  Model::GetMetadataTransferJobOutcomeCallable GetMetadataTransferJobCallable(const GetMetadataTransferJobRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::GetMetadataTransferJob, request);
  }
 
  template <typename GetMetadataTransferJobRequestT = Model::GetMetadataTransferJobRequest>
  void GetMetadataTransferJobAsync(const GetMetadataTransferJobRequestT& request,
                                   const GetMetadataTransferJobResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::GetMetadataTransferJob, request, handler, context);
  }
 
  virtual Model::GetPricingPlanOutcome GetPricingPlan(const Model::GetPricingPlanRequest& request = {}) const;
 
  template <typename GetPricingPlanRequestT = Model::GetPricingPlanRequest>
  Model::GetPricingPlanOutcomeCallable GetPricingPlanCallable(const GetPricingPlanRequestT& request = {}) const {
    return SubmitCallable(&IoTTwinMakerClient::GetPricingPlan, request);
  }
 
  template <typename GetPricingPlanRequestT = Model::GetPricingPlanRequest>
  void GetPricingPlanAsync(const GetPricingPlanResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const GetPricingPlanRequestT& request = {}) const {
    return SubmitAsync(&IoTTwinMakerClient::GetPricingPlan, request, handler, context);
  }
 
  virtual Model::GetPropertyValueOutcome GetPropertyValue(const Model::GetPropertyValueRequest& request) const;
 
  template <typename GetPropertyValueRequestT = Model::GetPropertyValueRequest>
  Model::GetPropertyValueOutcomeCallable GetPropertyValueCallable(const GetPropertyValueRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::GetPropertyValue, request);
  }
 
  template <typename GetPropertyValueRequestT = Model::GetPropertyValueRequest>
  void GetPropertyValueAsync(const GetPropertyValueRequestT& request, const GetPropertyValueResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::GetPropertyValue, request, handler, context);
  }
 
  virtual Model::GetPropertyValueHistoryOutcome GetPropertyValueHistory(const Model::GetPropertyValueHistoryRequest& request) const;
 
  template <typename GetPropertyValueHistoryRequestT = Model::GetPropertyValueHistoryRequest>
  Model::GetPropertyValueHistoryOutcomeCallable GetPropertyValueHistoryCallable(const GetPropertyValueHistoryRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::GetPropertyValueHistory, request);
  }
 
  template <typename GetPropertyValueHistoryRequestT = Model::GetPropertyValueHistoryRequest>
  void GetPropertyValueHistoryAsync(const GetPropertyValueHistoryRequestT& request,
                                    const GetPropertyValueHistoryResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::GetPropertyValueHistory, request, handler, context);
  }
 
  virtual Model::GetSceneOutcome GetScene(const Model::GetSceneRequest& request) const;
 
  template <typename GetSceneRequestT = Model::GetSceneRequest>
  Model::GetSceneOutcomeCallable GetSceneCallable(const GetSceneRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::GetScene, request);
  }
 
  template <typename GetSceneRequestT = Model::GetSceneRequest>
  void GetSceneAsync(const GetSceneRequestT& request, const GetSceneResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::GetScene, request, handler, context);
  }
 
  virtual Model::GetSyncJobOutcome GetSyncJob(const Model::GetSyncJobRequest& request) const;
 
  template <typename GetSyncJobRequestT = Model::GetSyncJobRequest>
  Model::GetSyncJobOutcomeCallable GetSyncJobCallable(const GetSyncJobRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::GetSyncJob, request);
  }
 
  template <typename GetSyncJobRequestT = Model::GetSyncJobRequest>
  void GetSyncJobAsync(const GetSyncJobRequestT& request, const GetSyncJobResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::GetSyncJob, request, handler, context);
  }
 
  virtual Model::GetWorkspaceOutcome GetWorkspace(const Model::GetWorkspaceRequest& request) const;
 
  template <typename GetWorkspaceRequestT = Model::GetWorkspaceRequest>
  Model::GetWorkspaceOutcomeCallable GetWorkspaceCallable(const GetWorkspaceRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::GetWorkspace, request);
  }
 
  template <typename GetWorkspaceRequestT = Model::GetWorkspaceRequest>
  void GetWorkspaceAsync(const GetWorkspaceRequestT& request, const GetWorkspaceResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::GetWorkspace, request, handler, context);
  }
 
  virtual Model::ListComponentTypesOutcome ListComponentTypes(const Model::ListComponentTypesRequest& request) const;
 
  template <typename ListComponentTypesRequestT = Model::ListComponentTypesRequest>
  Model::ListComponentTypesOutcomeCallable ListComponentTypesCallable(const ListComponentTypesRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::ListComponentTypes, request);
  }
 
  template <typename ListComponentTypesRequestT = Model::ListComponentTypesRequest>
  void ListComponentTypesAsync(const ListComponentTypesRequestT& request, const ListComponentTypesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::ListComponentTypes, request, handler, context);
  }
 
  virtual Model::ListComponentsOutcome ListComponents(const Model::ListComponentsRequest& request) const;
 
  template <typename ListComponentsRequestT = Model::ListComponentsRequest>
  Model::ListComponentsOutcomeCallable ListComponentsCallable(const ListComponentsRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::ListComponents, request);
  }
 
  template <typename ListComponentsRequestT = Model::ListComponentsRequest>
  void ListComponentsAsync(const ListComponentsRequestT& request, const ListComponentsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::ListComponents, request, handler, context);
  }
 
  virtual Model::ListEntitiesOutcome ListEntities(const Model::ListEntitiesRequest& request) const;
 
  template <typename ListEntitiesRequestT = Model::ListEntitiesRequest>
  Model::ListEntitiesOutcomeCallable ListEntitiesCallable(const ListEntitiesRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::ListEntities, request);
  }
 
  template <typename ListEntitiesRequestT = Model::ListEntitiesRequest>
  void ListEntitiesAsync(const ListEntitiesRequestT& request, const ListEntitiesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::ListEntities, request, handler, context);
  }
 
  virtual Model::ListMetadataTransferJobsOutcome ListMetadataTransferJobs(const Model::ListMetadataTransferJobsRequest& request) const;
 
  template <typename ListMetadataTransferJobsRequestT = Model::ListMetadataTransferJobsRequest>
  Model::ListMetadataTransferJobsOutcomeCallable ListMetadataTransferJobsCallable(const ListMetadataTransferJobsRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::ListMetadataTransferJobs, request);
  }
 
  template <typename ListMetadataTransferJobsRequestT = Model::ListMetadataTransferJobsRequest>
  void ListMetadataTransferJobsAsync(const ListMetadataTransferJobsRequestT& request,
                                     const ListMetadataTransferJobsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::ListMetadataTransferJobs, request, handler, context);
  }
 
  virtual Model::ListPropertiesOutcome ListProperties(const Model::ListPropertiesRequest& request) const;
 
  template <typename ListPropertiesRequestT = Model::ListPropertiesRequest>
  Model::ListPropertiesOutcomeCallable ListPropertiesCallable(const ListPropertiesRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::ListProperties, request);
  }
 
  template <typename ListPropertiesRequestT = Model::ListPropertiesRequest>
  void ListPropertiesAsync(const ListPropertiesRequestT& request, const ListPropertiesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::ListProperties, request, handler, context);
  }
 
  virtual Model::ListScenesOutcome ListScenes(const Model::ListScenesRequest& request) const;
 
  template <typename ListScenesRequestT = Model::ListScenesRequest>
  Model::ListScenesOutcomeCallable ListScenesCallable(const ListScenesRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::ListScenes, request);
  }
 
  template <typename ListScenesRequestT = Model::ListScenesRequest>
  void ListScenesAsync(const ListScenesRequestT& request, const ListScenesResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::ListScenes, request, handler, context);
  }
 
  virtual Model::ListSyncJobsOutcome ListSyncJobs(const Model::ListSyncJobsRequest& request) const;
 
  template <typename ListSyncJobsRequestT = Model::ListSyncJobsRequest>
  Model::ListSyncJobsOutcomeCallable ListSyncJobsCallable(const ListSyncJobsRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::ListSyncJobs, request);
  }
 
  template <typename ListSyncJobsRequestT = Model::ListSyncJobsRequest>
  void ListSyncJobsAsync(const ListSyncJobsRequestT& request, const ListSyncJobsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::ListSyncJobs, request, handler, context);
  }
 
  virtual Model::ListSyncResourcesOutcome ListSyncResources(const Model::ListSyncResourcesRequest& request) const;
 
  template <typename ListSyncResourcesRequestT = Model::ListSyncResourcesRequest>
  Model::ListSyncResourcesOutcomeCallable ListSyncResourcesCallable(const ListSyncResourcesRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::ListSyncResources, request);
  }
 
  template <typename ListSyncResourcesRequestT = Model::ListSyncResourcesRequest>
  void ListSyncResourcesAsync(const ListSyncResourcesRequestT& request, const ListSyncResourcesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::ListSyncResources, 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(&IoTTwinMakerClient::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(&IoTTwinMakerClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListWorkspacesOutcome ListWorkspaces(const Model::ListWorkspacesRequest& request = {}) const;
 
  template <typename ListWorkspacesRequestT = Model::ListWorkspacesRequest>
  Model::ListWorkspacesOutcomeCallable ListWorkspacesCallable(const ListWorkspacesRequestT& request = {}) const {
    return SubmitCallable(&IoTTwinMakerClient::ListWorkspaces, request);
  }
 
  template <typename ListWorkspacesRequestT = Model::ListWorkspacesRequest>
  void ListWorkspacesAsync(const ListWorkspacesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListWorkspacesRequestT& request = {}) const {
    return SubmitAsync(&IoTTwinMakerClient::ListWorkspaces, 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(&IoTTwinMakerClient::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(&IoTTwinMakerClient::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(&IoTTwinMakerClient::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(&IoTTwinMakerClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateComponentTypeOutcome UpdateComponentType(const Model::UpdateComponentTypeRequest& request) const;
 
  template <typename UpdateComponentTypeRequestT = Model::UpdateComponentTypeRequest>
  Model::UpdateComponentTypeOutcomeCallable UpdateComponentTypeCallable(const UpdateComponentTypeRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::UpdateComponentType, request);
  }
 
  template <typename UpdateComponentTypeRequestT = Model::UpdateComponentTypeRequest>
  void UpdateComponentTypeAsync(const UpdateComponentTypeRequestT& request, const UpdateComponentTypeResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::UpdateComponentType, request, handler, context);
  }
 
  virtual Model::UpdateEntityOutcome UpdateEntity(const Model::UpdateEntityRequest& request) const;
 
  template <typename UpdateEntityRequestT = Model::UpdateEntityRequest>
  Model::UpdateEntityOutcomeCallable UpdateEntityCallable(const UpdateEntityRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::UpdateEntity, request);
  }
 
  template <typename UpdateEntityRequestT = Model::UpdateEntityRequest>
  void UpdateEntityAsync(const UpdateEntityRequestT& request, const UpdateEntityResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::UpdateEntity, request, handler, context);
  }
 
  virtual Model::UpdatePricingPlanOutcome UpdatePricingPlan(const Model::UpdatePricingPlanRequest& request) const;
 
  template <typename UpdatePricingPlanRequestT = Model::UpdatePricingPlanRequest>
  Model::UpdatePricingPlanOutcomeCallable UpdatePricingPlanCallable(const UpdatePricingPlanRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::UpdatePricingPlan, request);
  }
 
  template <typename UpdatePricingPlanRequestT = Model::UpdatePricingPlanRequest>
  void UpdatePricingPlanAsync(const UpdatePricingPlanRequestT& request, const UpdatePricingPlanResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::UpdatePricingPlan, request, handler, context);
  }
 
  virtual Model::UpdateSceneOutcome UpdateScene(const Model::UpdateSceneRequest& request) const;
 
  template <typename UpdateSceneRequestT = Model::UpdateSceneRequest>
  Model::UpdateSceneOutcomeCallable UpdateSceneCallable(const UpdateSceneRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::UpdateScene, request);
  }
 
  template <typename UpdateSceneRequestT = Model::UpdateSceneRequest>
  void UpdateSceneAsync(const UpdateSceneRequestT& request, const UpdateSceneResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::UpdateScene, request, handler, context);
  }
 
  virtual Model::UpdateWorkspaceOutcome UpdateWorkspace(const Model::UpdateWorkspaceRequest& request) const;
 
  template <typename UpdateWorkspaceRequestT = Model::UpdateWorkspaceRequest>
  Model::UpdateWorkspaceOutcomeCallable UpdateWorkspaceCallable(const UpdateWorkspaceRequestT& request) const {
    return SubmitCallable(&IoTTwinMakerClient::UpdateWorkspace, request);
  }
 
  template <typename UpdateWorkspaceRequestT = Model::UpdateWorkspaceRequest>
  void UpdateWorkspaceAsync(const UpdateWorkspaceRequestT& request, const UpdateWorkspaceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTTwinMakerClient::UpdateWorkspace, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<IoTTwinMakerEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<IoTTwinMakerClient>;
  void init(const IoTTwinMakerClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, IoTTwinMakerError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  IoTTwinMakerClientConfiguration m_clientConfiguration;
  std::shared_ptr<IoTTwinMakerEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace IoTTwinMaker
}  // namespace Aws