IoTTwinMakerClient.h

 
#pragma once
#include <aws/iottwinmaker/IoTTwinMaker_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/iottwinmaker/IoTTwinMakerServiceClientModel.h>
 
namespace Aws
{
namespace IoTTwinMaker
{
  class AWS_IOTTWINMAKER_API IoTTwinMakerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<IoTTwinMakerEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<IoTTwinMakerClient>;
      void init(const IoTTwinMakerClientConfiguration& clientConfiguration);
 
      IoTTwinMakerClientConfiguration m_clientConfiguration;
      std::shared_ptr<IoTTwinMakerEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace IoTTwinMaker
} // namespace Aws