IoTSiteWiseClient.h

 
#pragma once
#include <aws/iotsitewise/IoTSiteWise_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/iotsitewise/IoTSiteWiseServiceClientModel.h>
 
namespace Aws
{
namespace IoTSiteWise
{
  class AWS_IOTSITEWISE_API IoTSiteWiseClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<IoTSiteWiseClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef IoTSiteWiseClientConfiguration ClientConfigurationType;
      typedef IoTSiteWiseEndpointProvider EndpointProviderType;
 
        IoTSiteWiseClient(const Aws::IoTSiteWise::IoTSiteWiseClientConfiguration& clientConfiguration = Aws::IoTSiteWise::IoTSiteWiseClientConfiguration(),
                          std::shared_ptr<IoTSiteWiseEndpointProviderBase> endpointProvider = nullptr);
 
        IoTSiteWiseClient(const Aws::Auth::AWSCredentials& credentials,
                          std::shared_ptr<IoTSiteWiseEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::IoTSiteWise::IoTSiteWiseClientConfiguration& clientConfiguration = Aws::IoTSiteWise::IoTSiteWiseClientConfiguration());
 
        IoTSiteWiseClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          std::shared_ptr<IoTSiteWiseEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::IoTSiteWise::IoTSiteWiseClientConfiguration& clientConfiguration = Aws::IoTSiteWise::IoTSiteWiseClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        IoTSiteWiseClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IoTSiteWiseClient(const Aws::Auth::AWSCredentials& credentials,
                          const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IoTSiteWiseClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~IoTSiteWiseClient();
 
        virtual Model::AssociateAssetsOutcome AssociateAssets(const Model::AssociateAssetsRequest& request) const;
 
        template<typename AssociateAssetsRequestT = Model::AssociateAssetsRequest>
        Model::AssociateAssetsOutcomeCallable AssociateAssetsCallable(const AssociateAssetsRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::AssociateAssets, request);
        }
 
        template<typename AssociateAssetsRequestT = Model::AssociateAssetsRequest>
        void AssociateAssetsAsync(const AssociateAssetsRequestT& request, const AssociateAssetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::AssociateAssets, request, handler, context);
        }
 
        virtual Model::AssociateTimeSeriesToAssetPropertyOutcome AssociateTimeSeriesToAssetProperty(const Model::AssociateTimeSeriesToAssetPropertyRequest& request) const;
 
        template<typename AssociateTimeSeriesToAssetPropertyRequestT = Model::AssociateTimeSeriesToAssetPropertyRequest>
        Model::AssociateTimeSeriesToAssetPropertyOutcomeCallable AssociateTimeSeriesToAssetPropertyCallable(const AssociateTimeSeriesToAssetPropertyRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::AssociateTimeSeriesToAssetProperty, request);
        }
 
        template<typename AssociateTimeSeriesToAssetPropertyRequestT = Model::AssociateTimeSeriesToAssetPropertyRequest>
        void AssociateTimeSeriesToAssetPropertyAsync(const AssociateTimeSeriesToAssetPropertyRequestT& request, const AssociateTimeSeriesToAssetPropertyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::AssociateTimeSeriesToAssetProperty, request, handler, context);
        }
 
        virtual Model::BatchAssociateProjectAssetsOutcome BatchAssociateProjectAssets(const Model::BatchAssociateProjectAssetsRequest& request) const;
 
        template<typename BatchAssociateProjectAssetsRequestT = Model::BatchAssociateProjectAssetsRequest>
        Model::BatchAssociateProjectAssetsOutcomeCallable BatchAssociateProjectAssetsCallable(const BatchAssociateProjectAssetsRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::BatchAssociateProjectAssets, request);
        }
 
        template<typename BatchAssociateProjectAssetsRequestT = Model::BatchAssociateProjectAssetsRequest>
        void BatchAssociateProjectAssetsAsync(const BatchAssociateProjectAssetsRequestT& request, const BatchAssociateProjectAssetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::BatchAssociateProjectAssets, request, handler, context);
        }
 
        virtual Model::BatchDisassociateProjectAssetsOutcome BatchDisassociateProjectAssets(const Model::BatchDisassociateProjectAssetsRequest& request) const;
 
        template<typename BatchDisassociateProjectAssetsRequestT = Model::BatchDisassociateProjectAssetsRequest>
        Model::BatchDisassociateProjectAssetsOutcomeCallable BatchDisassociateProjectAssetsCallable(const BatchDisassociateProjectAssetsRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::BatchDisassociateProjectAssets, request);
        }
 
        template<typename BatchDisassociateProjectAssetsRequestT = Model::BatchDisassociateProjectAssetsRequest>
        void BatchDisassociateProjectAssetsAsync(const BatchDisassociateProjectAssetsRequestT& request, const BatchDisassociateProjectAssetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::BatchDisassociateProjectAssets, request, handler, context);
        }
 
        virtual Model::BatchGetAssetPropertyAggregatesOutcome BatchGetAssetPropertyAggregates(const Model::BatchGetAssetPropertyAggregatesRequest& request) const;
 
        template<typename BatchGetAssetPropertyAggregatesRequestT = Model::BatchGetAssetPropertyAggregatesRequest>
        Model::BatchGetAssetPropertyAggregatesOutcomeCallable BatchGetAssetPropertyAggregatesCallable(const BatchGetAssetPropertyAggregatesRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::BatchGetAssetPropertyAggregates, request);
        }
 
        template<typename BatchGetAssetPropertyAggregatesRequestT = Model::BatchGetAssetPropertyAggregatesRequest>
        void BatchGetAssetPropertyAggregatesAsync(const BatchGetAssetPropertyAggregatesRequestT& request, const BatchGetAssetPropertyAggregatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::BatchGetAssetPropertyAggregates, request, handler, context);
        }
 
        virtual Model::BatchGetAssetPropertyValueOutcome BatchGetAssetPropertyValue(const Model::BatchGetAssetPropertyValueRequest& request) const;
 
        template<typename BatchGetAssetPropertyValueRequestT = Model::BatchGetAssetPropertyValueRequest>
        Model::BatchGetAssetPropertyValueOutcomeCallable BatchGetAssetPropertyValueCallable(const BatchGetAssetPropertyValueRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::BatchGetAssetPropertyValue, request);
        }
 
        template<typename BatchGetAssetPropertyValueRequestT = Model::BatchGetAssetPropertyValueRequest>
        void BatchGetAssetPropertyValueAsync(const BatchGetAssetPropertyValueRequestT& request, const BatchGetAssetPropertyValueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::BatchGetAssetPropertyValue, request, handler, context);
        }
 
        virtual Model::BatchGetAssetPropertyValueHistoryOutcome BatchGetAssetPropertyValueHistory(const Model::BatchGetAssetPropertyValueHistoryRequest& request) const;
 
        template<typename BatchGetAssetPropertyValueHistoryRequestT = Model::BatchGetAssetPropertyValueHistoryRequest>
        Model::BatchGetAssetPropertyValueHistoryOutcomeCallable BatchGetAssetPropertyValueHistoryCallable(const BatchGetAssetPropertyValueHistoryRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::BatchGetAssetPropertyValueHistory, request);
        }
 
        template<typename BatchGetAssetPropertyValueHistoryRequestT = Model::BatchGetAssetPropertyValueHistoryRequest>
        void BatchGetAssetPropertyValueHistoryAsync(const BatchGetAssetPropertyValueHistoryRequestT& request, const BatchGetAssetPropertyValueHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::BatchGetAssetPropertyValueHistory, request, handler, context);
        }
 
        virtual Model::BatchPutAssetPropertyValueOutcome BatchPutAssetPropertyValue(const Model::BatchPutAssetPropertyValueRequest& request) const;
 
        template<typename BatchPutAssetPropertyValueRequestT = Model::BatchPutAssetPropertyValueRequest>
        Model::BatchPutAssetPropertyValueOutcomeCallable BatchPutAssetPropertyValueCallable(const BatchPutAssetPropertyValueRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::BatchPutAssetPropertyValue, request);
        }
 
        template<typename BatchPutAssetPropertyValueRequestT = Model::BatchPutAssetPropertyValueRequest>
        void BatchPutAssetPropertyValueAsync(const BatchPutAssetPropertyValueRequestT& request, const BatchPutAssetPropertyValueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::BatchPutAssetPropertyValue, request, handler, context);
        }
 
        virtual Model::CreateAccessPolicyOutcome CreateAccessPolicy(const Model::CreateAccessPolicyRequest& request) const;
 
        template<typename CreateAccessPolicyRequestT = Model::CreateAccessPolicyRequest>
        Model::CreateAccessPolicyOutcomeCallable CreateAccessPolicyCallable(const CreateAccessPolicyRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::CreateAccessPolicy, request);
        }
 
        template<typename CreateAccessPolicyRequestT = Model::CreateAccessPolicyRequest>
        void CreateAccessPolicyAsync(const CreateAccessPolicyRequestT& request, const CreateAccessPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::CreateAccessPolicy, request, handler, context);
        }
 
        virtual Model::CreateAssetOutcome CreateAsset(const Model::CreateAssetRequest& request) const;
 
        template<typename CreateAssetRequestT = Model::CreateAssetRequest>
        Model::CreateAssetOutcomeCallable CreateAssetCallable(const CreateAssetRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::CreateAsset, request);
        }
 
        template<typename CreateAssetRequestT = Model::CreateAssetRequest>
        void CreateAssetAsync(const CreateAssetRequestT& request, const CreateAssetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::CreateAsset, request, handler, context);
        }
 
        virtual Model::CreateAssetModelOutcome CreateAssetModel(const Model::CreateAssetModelRequest& request) const;
 
        template<typename CreateAssetModelRequestT = Model::CreateAssetModelRequest>
        Model::CreateAssetModelOutcomeCallable CreateAssetModelCallable(const CreateAssetModelRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::CreateAssetModel, request);
        }
 
        template<typename CreateAssetModelRequestT = Model::CreateAssetModelRequest>
        void CreateAssetModelAsync(const CreateAssetModelRequestT& request, const CreateAssetModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::CreateAssetModel, request, handler, context);
        }
 
        virtual Model::CreateAssetModelCompositeModelOutcome CreateAssetModelCompositeModel(const Model::CreateAssetModelCompositeModelRequest& request) const;
 
        template<typename CreateAssetModelCompositeModelRequestT = Model::CreateAssetModelCompositeModelRequest>
        Model::CreateAssetModelCompositeModelOutcomeCallable CreateAssetModelCompositeModelCallable(const CreateAssetModelCompositeModelRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::CreateAssetModelCompositeModel, request);
        }
 
        template<typename CreateAssetModelCompositeModelRequestT = Model::CreateAssetModelCompositeModelRequest>
        void CreateAssetModelCompositeModelAsync(const CreateAssetModelCompositeModelRequestT& request, const CreateAssetModelCompositeModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::CreateAssetModelCompositeModel, request, handler, context);
        }
 
        virtual Model::CreateBulkImportJobOutcome CreateBulkImportJob(const Model::CreateBulkImportJobRequest& request) const;
 
        template<typename CreateBulkImportJobRequestT = Model::CreateBulkImportJobRequest>
        Model::CreateBulkImportJobOutcomeCallable CreateBulkImportJobCallable(const CreateBulkImportJobRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::CreateBulkImportJob, request);
        }
 
        template<typename CreateBulkImportJobRequestT = Model::CreateBulkImportJobRequest>
        void CreateBulkImportJobAsync(const CreateBulkImportJobRequestT& request, const CreateBulkImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::CreateBulkImportJob, request, handler, context);
        }
 
        virtual Model::CreateDashboardOutcome CreateDashboard(const Model::CreateDashboardRequest& request) const;
 
        template<typename CreateDashboardRequestT = Model::CreateDashboardRequest>
        Model::CreateDashboardOutcomeCallable CreateDashboardCallable(const CreateDashboardRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::CreateDashboard, request);
        }
 
        template<typename CreateDashboardRequestT = Model::CreateDashboardRequest>
        void CreateDashboardAsync(const CreateDashboardRequestT& request, const CreateDashboardResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::CreateDashboard, request, handler, context);
        }
 
        virtual Model::CreateGatewayOutcome CreateGateway(const Model::CreateGatewayRequest& request) const;
 
        template<typename CreateGatewayRequestT = Model::CreateGatewayRequest>
        Model::CreateGatewayOutcomeCallable CreateGatewayCallable(const CreateGatewayRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::CreateGateway, request);
        }
 
        template<typename CreateGatewayRequestT = Model::CreateGatewayRequest>
        void CreateGatewayAsync(const CreateGatewayRequestT& request, const CreateGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::CreateGateway, request, handler, context);
        }
 
        virtual Model::CreatePortalOutcome CreatePortal(const Model::CreatePortalRequest& request) const;
 
        template<typename CreatePortalRequestT = Model::CreatePortalRequest>
        Model::CreatePortalOutcomeCallable CreatePortalCallable(const CreatePortalRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::CreatePortal, request);
        }
 
        template<typename CreatePortalRequestT = Model::CreatePortalRequest>
        void CreatePortalAsync(const CreatePortalRequestT& request, const CreatePortalResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::CreatePortal, request, handler, context);
        }
 
        virtual Model::CreateProjectOutcome CreateProject(const Model::CreateProjectRequest& request) const;
 
        template<typename CreateProjectRequestT = Model::CreateProjectRequest>
        Model::CreateProjectOutcomeCallable CreateProjectCallable(const CreateProjectRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::CreateProject, request);
        }
 
        template<typename CreateProjectRequestT = Model::CreateProjectRequest>
        void CreateProjectAsync(const CreateProjectRequestT& request, const CreateProjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::CreateProject, request, handler, context);
        }
 
        virtual Model::DeleteAccessPolicyOutcome DeleteAccessPolicy(const Model::DeleteAccessPolicyRequest& request) const;
 
        template<typename DeleteAccessPolicyRequestT = Model::DeleteAccessPolicyRequest>
        Model::DeleteAccessPolicyOutcomeCallable DeleteAccessPolicyCallable(const DeleteAccessPolicyRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DeleteAccessPolicy, request);
        }
 
        template<typename DeleteAccessPolicyRequestT = Model::DeleteAccessPolicyRequest>
        void DeleteAccessPolicyAsync(const DeleteAccessPolicyRequestT& request, const DeleteAccessPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DeleteAccessPolicy, request, handler, context);
        }
 
        virtual Model::DeleteAssetOutcome DeleteAsset(const Model::DeleteAssetRequest& request) const;
 
        template<typename DeleteAssetRequestT = Model::DeleteAssetRequest>
        Model::DeleteAssetOutcomeCallable DeleteAssetCallable(const DeleteAssetRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DeleteAsset, request);
        }
 
        template<typename DeleteAssetRequestT = Model::DeleteAssetRequest>
        void DeleteAssetAsync(const DeleteAssetRequestT& request, const DeleteAssetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DeleteAsset, request, handler, context);
        }
 
        virtual Model::DeleteAssetModelOutcome DeleteAssetModel(const Model::DeleteAssetModelRequest& request) const;
 
        template<typename DeleteAssetModelRequestT = Model::DeleteAssetModelRequest>
        Model::DeleteAssetModelOutcomeCallable DeleteAssetModelCallable(const DeleteAssetModelRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DeleteAssetModel, request);
        }
 
        template<typename DeleteAssetModelRequestT = Model::DeleteAssetModelRequest>
        void DeleteAssetModelAsync(const DeleteAssetModelRequestT& request, const DeleteAssetModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DeleteAssetModel, request, handler, context);
        }
 
        virtual Model::DeleteAssetModelCompositeModelOutcome DeleteAssetModelCompositeModel(const Model::DeleteAssetModelCompositeModelRequest& request) const;
 
        template<typename DeleteAssetModelCompositeModelRequestT = Model::DeleteAssetModelCompositeModelRequest>
        Model::DeleteAssetModelCompositeModelOutcomeCallable DeleteAssetModelCompositeModelCallable(const DeleteAssetModelCompositeModelRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DeleteAssetModelCompositeModel, request);
        }
 
        template<typename DeleteAssetModelCompositeModelRequestT = Model::DeleteAssetModelCompositeModelRequest>
        void DeleteAssetModelCompositeModelAsync(const DeleteAssetModelCompositeModelRequestT& request, const DeleteAssetModelCompositeModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DeleteAssetModelCompositeModel, request, handler, context);
        }
 
        virtual Model::DeleteDashboardOutcome DeleteDashboard(const Model::DeleteDashboardRequest& request) const;
 
        template<typename DeleteDashboardRequestT = Model::DeleteDashboardRequest>
        Model::DeleteDashboardOutcomeCallable DeleteDashboardCallable(const DeleteDashboardRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DeleteDashboard, request);
        }
 
        template<typename DeleteDashboardRequestT = Model::DeleteDashboardRequest>
        void DeleteDashboardAsync(const DeleteDashboardRequestT& request, const DeleteDashboardResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DeleteDashboard, request, handler, context);
        }
 
        virtual Model::DeleteGatewayOutcome DeleteGateway(const Model::DeleteGatewayRequest& request) const;
 
        template<typename DeleteGatewayRequestT = Model::DeleteGatewayRequest>
        Model::DeleteGatewayOutcomeCallable DeleteGatewayCallable(const DeleteGatewayRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DeleteGateway, request);
        }
 
        template<typename DeleteGatewayRequestT = Model::DeleteGatewayRequest>
        void DeleteGatewayAsync(const DeleteGatewayRequestT& request, const DeleteGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DeleteGateway, request, handler, context);
        }
 
        virtual Model::DeletePortalOutcome DeletePortal(const Model::DeletePortalRequest& request) const;
 
        template<typename DeletePortalRequestT = Model::DeletePortalRequest>
        Model::DeletePortalOutcomeCallable DeletePortalCallable(const DeletePortalRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DeletePortal, request);
        }
 
        template<typename DeletePortalRequestT = Model::DeletePortalRequest>
        void DeletePortalAsync(const DeletePortalRequestT& request, const DeletePortalResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DeletePortal, request, handler, context);
        }
 
        virtual Model::DeleteProjectOutcome DeleteProject(const Model::DeleteProjectRequest& request) const;
 
        template<typename DeleteProjectRequestT = Model::DeleteProjectRequest>
        Model::DeleteProjectOutcomeCallable DeleteProjectCallable(const DeleteProjectRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DeleteProject, request);
        }
 
        template<typename DeleteProjectRequestT = Model::DeleteProjectRequest>
        void DeleteProjectAsync(const DeleteProjectRequestT& request, const DeleteProjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DeleteProject, request, handler, context);
        }
 
        virtual Model::DeleteTimeSeriesOutcome DeleteTimeSeries(const Model::DeleteTimeSeriesRequest& request = {}) const;
 
        template<typename DeleteTimeSeriesRequestT = Model::DeleteTimeSeriesRequest>
        Model::DeleteTimeSeriesOutcomeCallable DeleteTimeSeriesCallable(const DeleteTimeSeriesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DeleteTimeSeries, request);
        }
 
        template<typename DeleteTimeSeriesRequestT = Model::DeleteTimeSeriesRequest>
        void DeleteTimeSeriesAsync(const DeleteTimeSeriesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteTimeSeriesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DeleteTimeSeries, request, handler, context);
        }
 
        virtual Model::DescribeAccessPolicyOutcome DescribeAccessPolicy(const Model::DescribeAccessPolicyRequest& request) const;
 
        template<typename DescribeAccessPolicyRequestT = Model::DescribeAccessPolicyRequest>
        Model::DescribeAccessPolicyOutcomeCallable DescribeAccessPolicyCallable(const DescribeAccessPolicyRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DescribeAccessPolicy, request);
        }
 
        template<typename DescribeAccessPolicyRequestT = Model::DescribeAccessPolicyRequest>
        void DescribeAccessPolicyAsync(const DescribeAccessPolicyRequestT& request, const DescribeAccessPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DescribeAccessPolicy, request, handler, context);
        }
 
        virtual Model::DescribeActionOutcome DescribeAction(const Model::DescribeActionRequest& request) const;
 
        template<typename DescribeActionRequestT = Model::DescribeActionRequest>
        Model::DescribeActionOutcomeCallable DescribeActionCallable(const DescribeActionRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DescribeAction, request);
        }
 
        template<typename DescribeActionRequestT = Model::DescribeActionRequest>
        void DescribeActionAsync(const DescribeActionRequestT& request, const DescribeActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DescribeAction, request, handler, context);
        }
 
        virtual Model::DescribeAssetOutcome DescribeAsset(const Model::DescribeAssetRequest& request) const;
 
        template<typename DescribeAssetRequestT = Model::DescribeAssetRequest>
        Model::DescribeAssetOutcomeCallable DescribeAssetCallable(const DescribeAssetRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DescribeAsset, request);
        }
 
        template<typename DescribeAssetRequestT = Model::DescribeAssetRequest>
        void DescribeAssetAsync(const DescribeAssetRequestT& request, const DescribeAssetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DescribeAsset, request, handler, context);
        }
 
        virtual Model::DescribeAssetCompositeModelOutcome DescribeAssetCompositeModel(const Model::DescribeAssetCompositeModelRequest& request) const;
 
        template<typename DescribeAssetCompositeModelRequestT = Model::DescribeAssetCompositeModelRequest>
        Model::DescribeAssetCompositeModelOutcomeCallable DescribeAssetCompositeModelCallable(const DescribeAssetCompositeModelRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DescribeAssetCompositeModel, request);
        }
 
        template<typename DescribeAssetCompositeModelRequestT = Model::DescribeAssetCompositeModelRequest>
        void DescribeAssetCompositeModelAsync(const DescribeAssetCompositeModelRequestT& request, const DescribeAssetCompositeModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DescribeAssetCompositeModel, request, handler, context);
        }
 
        virtual Model::DescribeAssetModelOutcome DescribeAssetModel(const Model::DescribeAssetModelRequest& request) const;
 
        template<typename DescribeAssetModelRequestT = Model::DescribeAssetModelRequest>
        Model::DescribeAssetModelOutcomeCallable DescribeAssetModelCallable(const DescribeAssetModelRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DescribeAssetModel, request);
        }
 
        template<typename DescribeAssetModelRequestT = Model::DescribeAssetModelRequest>
        void DescribeAssetModelAsync(const DescribeAssetModelRequestT& request, const DescribeAssetModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DescribeAssetModel, request, handler, context);
        }
 
        virtual Model::DescribeAssetModelCompositeModelOutcome DescribeAssetModelCompositeModel(const Model::DescribeAssetModelCompositeModelRequest& request) const;
 
        template<typename DescribeAssetModelCompositeModelRequestT = Model::DescribeAssetModelCompositeModelRequest>
        Model::DescribeAssetModelCompositeModelOutcomeCallable DescribeAssetModelCompositeModelCallable(const DescribeAssetModelCompositeModelRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DescribeAssetModelCompositeModel, request);
        }
 
        template<typename DescribeAssetModelCompositeModelRequestT = Model::DescribeAssetModelCompositeModelRequest>
        void DescribeAssetModelCompositeModelAsync(const DescribeAssetModelCompositeModelRequestT& request, const DescribeAssetModelCompositeModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DescribeAssetModelCompositeModel, request, handler, context);
        }
 
        virtual Model::DescribeAssetPropertyOutcome DescribeAssetProperty(const Model::DescribeAssetPropertyRequest& request) const;
 
        template<typename DescribeAssetPropertyRequestT = Model::DescribeAssetPropertyRequest>
        Model::DescribeAssetPropertyOutcomeCallable DescribeAssetPropertyCallable(const DescribeAssetPropertyRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DescribeAssetProperty, request);
        }
 
        template<typename DescribeAssetPropertyRequestT = Model::DescribeAssetPropertyRequest>
        void DescribeAssetPropertyAsync(const DescribeAssetPropertyRequestT& request, const DescribeAssetPropertyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DescribeAssetProperty, request, handler, context);
        }
 
        virtual Model::DescribeBulkImportJobOutcome DescribeBulkImportJob(const Model::DescribeBulkImportJobRequest& request) const;
 
        template<typename DescribeBulkImportJobRequestT = Model::DescribeBulkImportJobRequest>
        Model::DescribeBulkImportJobOutcomeCallable DescribeBulkImportJobCallable(const DescribeBulkImportJobRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DescribeBulkImportJob, request);
        }
 
        template<typename DescribeBulkImportJobRequestT = Model::DescribeBulkImportJobRequest>
        void DescribeBulkImportJobAsync(const DescribeBulkImportJobRequestT& request, const DescribeBulkImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DescribeBulkImportJob, request, handler, context);
        }
 
        virtual Model::DescribeDashboardOutcome DescribeDashboard(const Model::DescribeDashboardRequest& request) const;
 
        template<typename DescribeDashboardRequestT = Model::DescribeDashboardRequest>
        Model::DescribeDashboardOutcomeCallable DescribeDashboardCallable(const DescribeDashboardRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DescribeDashboard, request);
        }
 
        template<typename DescribeDashboardRequestT = Model::DescribeDashboardRequest>
        void DescribeDashboardAsync(const DescribeDashboardRequestT& request, const DescribeDashboardResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DescribeDashboard, request, handler, context);
        }
 
        virtual Model::DescribeDefaultEncryptionConfigurationOutcome DescribeDefaultEncryptionConfiguration(const Model::DescribeDefaultEncryptionConfigurationRequest& request = {}) const;
 
        template<typename DescribeDefaultEncryptionConfigurationRequestT = Model::DescribeDefaultEncryptionConfigurationRequest>
        Model::DescribeDefaultEncryptionConfigurationOutcomeCallable DescribeDefaultEncryptionConfigurationCallable(const DescribeDefaultEncryptionConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DescribeDefaultEncryptionConfiguration, request);
        }
 
        template<typename DescribeDefaultEncryptionConfigurationRequestT = Model::DescribeDefaultEncryptionConfigurationRequest>
        void DescribeDefaultEncryptionConfigurationAsync(const DescribeDefaultEncryptionConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeDefaultEncryptionConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DescribeDefaultEncryptionConfiguration, request, handler, context);
        }
 
        virtual Model::DescribeGatewayOutcome DescribeGateway(const Model::DescribeGatewayRequest& request) const;
 
        template<typename DescribeGatewayRequestT = Model::DescribeGatewayRequest>
        Model::DescribeGatewayOutcomeCallable DescribeGatewayCallable(const DescribeGatewayRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DescribeGateway, request);
        }
 
        template<typename DescribeGatewayRequestT = Model::DescribeGatewayRequest>
        void DescribeGatewayAsync(const DescribeGatewayRequestT& request, const DescribeGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DescribeGateway, request, handler, context);
        }
 
        virtual Model::DescribeGatewayCapabilityConfigurationOutcome DescribeGatewayCapabilityConfiguration(const Model::DescribeGatewayCapabilityConfigurationRequest& request) const;
 
        template<typename DescribeGatewayCapabilityConfigurationRequestT = Model::DescribeGatewayCapabilityConfigurationRequest>
        Model::DescribeGatewayCapabilityConfigurationOutcomeCallable DescribeGatewayCapabilityConfigurationCallable(const DescribeGatewayCapabilityConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DescribeGatewayCapabilityConfiguration, request);
        }
 
        template<typename DescribeGatewayCapabilityConfigurationRequestT = Model::DescribeGatewayCapabilityConfigurationRequest>
        void DescribeGatewayCapabilityConfigurationAsync(const DescribeGatewayCapabilityConfigurationRequestT& request, const DescribeGatewayCapabilityConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DescribeGatewayCapabilityConfiguration, request, handler, context);
        }
 
        virtual Model::DescribeLoggingOptionsOutcome DescribeLoggingOptions(const Model::DescribeLoggingOptionsRequest& request = {}) const;
 
        template<typename DescribeLoggingOptionsRequestT = Model::DescribeLoggingOptionsRequest>
        Model::DescribeLoggingOptionsOutcomeCallable DescribeLoggingOptionsCallable(const DescribeLoggingOptionsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DescribeLoggingOptions, request);
        }
 
        template<typename DescribeLoggingOptionsRequestT = Model::DescribeLoggingOptionsRequest>
        void DescribeLoggingOptionsAsync(const DescribeLoggingOptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeLoggingOptionsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DescribeLoggingOptions, request, handler, context);
        }
 
        virtual Model::DescribePortalOutcome DescribePortal(const Model::DescribePortalRequest& request) const;
 
        template<typename DescribePortalRequestT = Model::DescribePortalRequest>
        Model::DescribePortalOutcomeCallable DescribePortalCallable(const DescribePortalRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DescribePortal, request);
        }
 
        template<typename DescribePortalRequestT = Model::DescribePortalRequest>
        void DescribePortalAsync(const DescribePortalRequestT& request, const DescribePortalResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DescribePortal, request, handler, context);
        }
 
        virtual Model::DescribeProjectOutcome DescribeProject(const Model::DescribeProjectRequest& request) const;
 
        template<typename DescribeProjectRequestT = Model::DescribeProjectRequest>
        Model::DescribeProjectOutcomeCallable DescribeProjectCallable(const DescribeProjectRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DescribeProject, request);
        }
 
        template<typename DescribeProjectRequestT = Model::DescribeProjectRequest>
        void DescribeProjectAsync(const DescribeProjectRequestT& request, const DescribeProjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DescribeProject, request, handler, context);
        }
 
        virtual Model::DescribeStorageConfigurationOutcome DescribeStorageConfiguration(const Model::DescribeStorageConfigurationRequest& request = {}) const;
 
        template<typename DescribeStorageConfigurationRequestT = Model::DescribeStorageConfigurationRequest>
        Model::DescribeStorageConfigurationOutcomeCallable DescribeStorageConfigurationCallable(const DescribeStorageConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DescribeStorageConfiguration, request);
        }
 
        template<typename DescribeStorageConfigurationRequestT = Model::DescribeStorageConfigurationRequest>
        void DescribeStorageConfigurationAsync(const DescribeStorageConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeStorageConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DescribeStorageConfiguration, request, handler, context);
        }
 
        virtual Model::DescribeTimeSeriesOutcome DescribeTimeSeries(const Model::DescribeTimeSeriesRequest& request = {}) const;
 
        template<typename DescribeTimeSeriesRequestT = Model::DescribeTimeSeriesRequest>
        Model::DescribeTimeSeriesOutcomeCallable DescribeTimeSeriesCallable(const DescribeTimeSeriesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DescribeTimeSeries, request);
        }
 
        template<typename DescribeTimeSeriesRequestT = Model::DescribeTimeSeriesRequest>
        void DescribeTimeSeriesAsync(const DescribeTimeSeriesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeTimeSeriesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DescribeTimeSeries, request, handler, context);
        }
 
        virtual Model::DisassociateAssetsOutcome DisassociateAssets(const Model::DisassociateAssetsRequest& request) const;
 
        template<typename DisassociateAssetsRequestT = Model::DisassociateAssetsRequest>
        Model::DisassociateAssetsOutcomeCallable DisassociateAssetsCallable(const DisassociateAssetsRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DisassociateAssets, request);
        }
 
        template<typename DisassociateAssetsRequestT = Model::DisassociateAssetsRequest>
        void DisassociateAssetsAsync(const DisassociateAssetsRequestT& request, const DisassociateAssetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DisassociateAssets, request, handler, context);
        }
 
        virtual Model::DisassociateTimeSeriesFromAssetPropertyOutcome DisassociateTimeSeriesFromAssetProperty(const Model::DisassociateTimeSeriesFromAssetPropertyRequest& request) const;
 
        template<typename DisassociateTimeSeriesFromAssetPropertyRequestT = Model::DisassociateTimeSeriesFromAssetPropertyRequest>
        Model::DisassociateTimeSeriesFromAssetPropertyOutcomeCallable DisassociateTimeSeriesFromAssetPropertyCallable(const DisassociateTimeSeriesFromAssetPropertyRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::DisassociateTimeSeriesFromAssetProperty, request);
        }
 
        template<typename DisassociateTimeSeriesFromAssetPropertyRequestT = Model::DisassociateTimeSeriesFromAssetPropertyRequest>
        void DisassociateTimeSeriesFromAssetPropertyAsync(const DisassociateTimeSeriesFromAssetPropertyRequestT& request, const DisassociateTimeSeriesFromAssetPropertyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::DisassociateTimeSeriesFromAssetProperty, request, handler, context);
        }
 
        virtual Model::ExecuteActionOutcome ExecuteAction(const Model::ExecuteActionRequest& request) const;
 
        template<typename ExecuteActionRequestT = Model::ExecuteActionRequest>
        Model::ExecuteActionOutcomeCallable ExecuteActionCallable(const ExecuteActionRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::ExecuteAction, request);
        }
 
        template<typename ExecuteActionRequestT = Model::ExecuteActionRequest>
        void ExecuteActionAsync(const ExecuteActionRequestT& request, const ExecuteActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::ExecuteAction, 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(&IoTSiteWiseClient::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(&IoTSiteWiseClient::ExecuteQuery, request, handler, context);
        }
 
        virtual Model::GetAssetPropertyAggregatesOutcome GetAssetPropertyAggregates(const Model::GetAssetPropertyAggregatesRequest& request) const;
 
        template<typename GetAssetPropertyAggregatesRequestT = Model::GetAssetPropertyAggregatesRequest>
        Model::GetAssetPropertyAggregatesOutcomeCallable GetAssetPropertyAggregatesCallable(const GetAssetPropertyAggregatesRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::GetAssetPropertyAggregates, request);
        }
 
        template<typename GetAssetPropertyAggregatesRequestT = Model::GetAssetPropertyAggregatesRequest>
        void GetAssetPropertyAggregatesAsync(const GetAssetPropertyAggregatesRequestT& request, const GetAssetPropertyAggregatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::GetAssetPropertyAggregates, request, handler, context);
        }
 
        virtual Model::GetAssetPropertyValueOutcome GetAssetPropertyValue(const Model::GetAssetPropertyValueRequest& request = {}) const;
 
        template<typename GetAssetPropertyValueRequestT = Model::GetAssetPropertyValueRequest>
        Model::GetAssetPropertyValueOutcomeCallable GetAssetPropertyValueCallable(const GetAssetPropertyValueRequestT& request = {}) const
        {
            return SubmitCallable(&IoTSiteWiseClient::GetAssetPropertyValue, request);
        }
 
        template<typename GetAssetPropertyValueRequestT = Model::GetAssetPropertyValueRequest>
        void GetAssetPropertyValueAsync(const GetAssetPropertyValueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetAssetPropertyValueRequestT& request = {}) const
        {
            return SubmitAsync(&IoTSiteWiseClient::GetAssetPropertyValue, request, handler, context);
        }
 
        virtual Model::GetAssetPropertyValueHistoryOutcome GetAssetPropertyValueHistory(const Model::GetAssetPropertyValueHistoryRequest& request = {}) const;
 
        template<typename GetAssetPropertyValueHistoryRequestT = Model::GetAssetPropertyValueHistoryRequest>
        Model::GetAssetPropertyValueHistoryOutcomeCallable GetAssetPropertyValueHistoryCallable(const GetAssetPropertyValueHistoryRequestT& request = {}) const
        {
            return SubmitCallable(&IoTSiteWiseClient::GetAssetPropertyValueHistory, request);
        }
 
        template<typename GetAssetPropertyValueHistoryRequestT = Model::GetAssetPropertyValueHistoryRequest>
        void GetAssetPropertyValueHistoryAsync(const GetAssetPropertyValueHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetAssetPropertyValueHistoryRequestT& request = {}) const
        {
            return SubmitAsync(&IoTSiteWiseClient::GetAssetPropertyValueHistory, request, handler, context);
        }
 
        virtual Model::GetInterpolatedAssetPropertyValuesOutcome GetInterpolatedAssetPropertyValues(const Model::GetInterpolatedAssetPropertyValuesRequest& request) const;
 
        template<typename GetInterpolatedAssetPropertyValuesRequestT = Model::GetInterpolatedAssetPropertyValuesRequest>
        Model::GetInterpolatedAssetPropertyValuesOutcomeCallable GetInterpolatedAssetPropertyValuesCallable(const GetInterpolatedAssetPropertyValuesRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::GetInterpolatedAssetPropertyValues, request);
        }
 
        template<typename GetInterpolatedAssetPropertyValuesRequestT = Model::GetInterpolatedAssetPropertyValuesRequest>
        void GetInterpolatedAssetPropertyValuesAsync(const GetInterpolatedAssetPropertyValuesRequestT& request, const GetInterpolatedAssetPropertyValuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::GetInterpolatedAssetPropertyValues, request, handler, context);
        }
 
        virtual Model::ListAccessPoliciesOutcome ListAccessPolicies(const Model::ListAccessPoliciesRequest& request = {}) const;
 
        template<typename ListAccessPoliciesRequestT = Model::ListAccessPoliciesRequest>
        Model::ListAccessPoliciesOutcomeCallable ListAccessPoliciesCallable(const ListAccessPoliciesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTSiteWiseClient::ListAccessPolicies, request);
        }
 
        template<typename ListAccessPoliciesRequestT = Model::ListAccessPoliciesRequest>
        void ListAccessPoliciesAsync(const ListAccessPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAccessPoliciesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTSiteWiseClient::ListAccessPolicies, request, handler, context);
        }
 
        virtual Model::ListActionsOutcome ListActions(const Model::ListActionsRequest& request) const;
 
        template<typename ListActionsRequestT = Model::ListActionsRequest>
        Model::ListActionsOutcomeCallable ListActionsCallable(const ListActionsRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::ListActions, request);
        }
 
        template<typename ListActionsRequestT = Model::ListActionsRequest>
        void ListActionsAsync(const ListActionsRequestT& request, const ListActionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::ListActions, request, handler, context);
        }
 
        virtual Model::ListAssetModelCompositeModelsOutcome ListAssetModelCompositeModels(const Model::ListAssetModelCompositeModelsRequest& request) const;
 
        template<typename ListAssetModelCompositeModelsRequestT = Model::ListAssetModelCompositeModelsRequest>
        Model::ListAssetModelCompositeModelsOutcomeCallable ListAssetModelCompositeModelsCallable(const ListAssetModelCompositeModelsRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::ListAssetModelCompositeModels, request);
        }
 
        template<typename ListAssetModelCompositeModelsRequestT = Model::ListAssetModelCompositeModelsRequest>
        void ListAssetModelCompositeModelsAsync(const ListAssetModelCompositeModelsRequestT& request, const ListAssetModelCompositeModelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::ListAssetModelCompositeModels, request, handler, context);
        }
 
        virtual Model::ListAssetModelPropertiesOutcome ListAssetModelProperties(const Model::ListAssetModelPropertiesRequest& request) const;
 
        template<typename ListAssetModelPropertiesRequestT = Model::ListAssetModelPropertiesRequest>
        Model::ListAssetModelPropertiesOutcomeCallable ListAssetModelPropertiesCallable(const ListAssetModelPropertiesRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::ListAssetModelProperties, request);
        }
 
        template<typename ListAssetModelPropertiesRequestT = Model::ListAssetModelPropertiesRequest>
        void ListAssetModelPropertiesAsync(const ListAssetModelPropertiesRequestT& request, const ListAssetModelPropertiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::ListAssetModelProperties, request, handler, context);
        }
 
        virtual Model::ListAssetModelsOutcome ListAssetModels(const Model::ListAssetModelsRequest& request = {}) const;
 
        template<typename ListAssetModelsRequestT = Model::ListAssetModelsRequest>
        Model::ListAssetModelsOutcomeCallable ListAssetModelsCallable(const ListAssetModelsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTSiteWiseClient::ListAssetModels, request);
        }
 
        template<typename ListAssetModelsRequestT = Model::ListAssetModelsRequest>
        void ListAssetModelsAsync(const ListAssetModelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAssetModelsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTSiteWiseClient::ListAssetModels, request, handler, context);
        }
 
        virtual Model::ListAssetPropertiesOutcome ListAssetProperties(const Model::ListAssetPropertiesRequest& request) const;
 
        template<typename ListAssetPropertiesRequestT = Model::ListAssetPropertiesRequest>
        Model::ListAssetPropertiesOutcomeCallable ListAssetPropertiesCallable(const ListAssetPropertiesRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::ListAssetProperties, request);
        }
 
        template<typename ListAssetPropertiesRequestT = Model::ListAssetPropertiesRequest>
        void ListAssetPropertiesAsync(const ListAssetPropertiesRequestT& request, const ListAssetPropertiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::ListAssetProperties, request, handler, context);
        }
 
        virtual Model::ListAssetRelationshipsOutcome ListAssetRelationships(const Model::ListAssetRelationshipsRequest& request) const;
 
        template<typename ListAssetRelationshipsRequestT = Model::ListAssetRelationshipsRequest>
        Model::ListAssetRelationshipsOutcomeCallable ListAssetRelationshipsCallable(const ListAssetRelationshipsRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::ListAssetRelationships, request);
        }
 
        template<typename ListAssetRelationshipsRequestT = Model::ListAssetRelationshipsRequest>
        void ListAssetRelationshipsAsync(const ListAssetRelationshipsRequestT& request, const ListAssetRelationshipsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::ListAssetRelationships, request, handler, context);
        }
 
        virtual Model::ListAssetsOutcome ListAssets(const Model::ListAssetsRequest& request = {}) const;
 
        template<typename ListAssetsRequestT = Model::ListAssetsRequest>
        Model::ListAssetsOutcomeCallable ListAssetsCallable(const ListAssetsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTSiteWiseClient::ListAssets, request);
        }
 
        template<typename ListAssetsRequestT = Model::ListAssetsRequest>
        void ListAssetsAsync(const ListAssetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAssetsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTSiteWiseClient::ListAssets, request, handler, context);
        }
 
        virtual Model::ListAssociatedAssetsOutcome ListAssociatedAssets(const Model::ListAssociatedAssetsRequest& request) const;
 
        template<typename ListAssociatedAssetsRequestT = Model::ListAssociatedAssetsRequest>
        Model::ListAssociatedAssetsOutcomeCallable ListAssociatedAssetsCallable(const ListAssociatedAssetsRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::ListAssociatedAssets, request);
        }
 
        template<typename ListAssociatedAssetsRequestT = Model::ListAssociatedAssetsRequest>
        void ListAssociatedAssetsAsync(const ListAssociatedAssetsRequestT& request, const ListAssociatedAssetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::ListAssociatedAssets, request, handler, context);
        }
 
        virtual Model::ListBulkImportJobsOutcome ListBulkImportJobs(const Model::ListBulkImportJobsRequest& request = {}) const;
 
        template<typename ListBulkImportJobsRequestT = Model::ListBulkImportJobsRequest>
        Model::ListBulkImportJobsOutcomeCallable ListBulkImportJobsCallable(const ListBulkImportJobsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTSiteWiseClient::ListBulkImportJobs, request);
        }
 
        template<typename ListBulkImportJobsRequestT = Model::ListBulkImportJobsRequest>
        void ListBulkImportJobsAsync(const ListBulkImportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListBulkImportJobsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTSiteWiseClient::ListBulkImportJobs, request, handler, context);
        }
 
        virtual Model::ListCompositionRelationshipsOutcome ListCompositionRelationships(const Model::ListCompositionRelationshipsRequest& request) const;
 
        template<typename ListCompositionRelationshipsRequestT = Model::ListCompositionRelationshipsRequest>
        Model::ListCompositionRelationshipsOutcomeCallable ListCompositionRelationshipsCallable(const ListCompositionRelationshipsRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::ListCompositionRelationships, request);
        }
 
        template<typename ListCompositionRelationshipsRequestT = Model::ListCompositionRelationshipsRequest>
        void ListCompositionRelationshipsAsync(const ListCompositionRelationshipsRequestT& request, const ListCompositionRelationshipsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::ListCompositionRelationships, request, handler, context);
        }
 
        virtual Model::ListDashboardsOutcome ListDashboards(const Model::ListDashboardsRequest& request) const;
 
        template<typename ListDashboardsRequestT = Model::ListDashboardsRequest>
        Model::ListDashboardsOutcomeCallable ListDashboardsCallable(const ListDashboardsRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::ListDashboards, request);
        }
 
        template<typename ListDashboardsRequestT = Model::ListDashboardsRequest>
        void ListDashboardsAsync(const ListDashboardsRequestT& request, const ListDashboardsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::ListDashboards, request, handler, context);
        }
 
        virtual Model::ListGatewaysOutcome ListGateways(const Model::ListGatewaysRequest& request = {}) const;
 
        template<typename ListGatewaysRequestT = Model::ListGatewaysRequest>
        Model::ListGatewaysOutcomeCallable ListGatewaysCallable(const ListGatewaysRequestT& request = {}) const
        {
            return SubmitCallable(&IoTSiteWiseClient::ListGateways, request);
        }
 
        template<typename ListGatewaysRequestT = Model::ListGatewaysRequest>
        void ListGatewaysAsync(const ListGatewaysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListGatewaysRequestT& request = {}) const
        {
            return SubmitAsync(&IoTSiteWiseClient::ListGateways, request, handler, context);
        }
 
        virtual Model::ListPortalsOutcome ListPortals(const Model::ListPortalsRequest& request = {}) const;
 
        template<typename ListPortalsRequestT = Model::ListPortalsRequest>
        Model::ListPortalsOutcomeCallable ListPortalsCallable(const ListPortalsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTSiteWiseClient::ListPortals, request);
        }
 
        template<typename ListPortalsRequestT = Model::ListPortalsRequest>
        void ListPortalsAsync(const ListPortalsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPortalsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTSiteWiseClient::ListPortals, request, handler, context);
        }
 
        virtual Model::ListProjectAssetsOutcome ListProjectAssets(const Model::ListProjectAssetsRequest& request) const;
 
        template<typename ListProjectAssetsRequestT = Model::ListProjectAssetsRequest>
        Model::ListProjectAssetsOutcomeCallable ListProjectAssetsCallable(const ListProjectAssetsRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::ListProjectAssets, request);
        }
 
        template<typename ListProjectAssetsRequestT = Model::ListProjectAssetsRequest>
        void ListProjectAssetsAsync(const ListProjectAssetsRequestT& request, const ListProjectAssetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::ListProjectAssets, request, handler, context);
        }
 
        virtual Model::ListProjectsOutcome ListProjects(const Model::ListProjectsRequest& request) const;
 
        template<typename ListProjectsRequestT = Model::ListProjectsRequest>
        Model::ListProjectsOutcomeCallable ListProjectsCallable(const ListProjectsRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::ListProjects, request);
        }
 
        template<typename ListProjectsRequestT = Model::ListProjectsRequest>
        void ListProjectsAsync(const ListProjectsRequestT& request, const ListProjectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::ListProjects, 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(&IoTSiteWiseClient::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(&IoTSiteWiseClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListTimeSeriesOutcome ListTimeSeries(const Model::ListTimeSeriesRequest& request = {}) const;
 
        template<typename ListTimeSeriesRequestT = Model::ListTimeSeriesRequest>
        Model::ListTimeSeriesOutcomeCallable ListTimeSeriesCallable(const ListTimeSeriesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTSiteWiseClient::ListTimeSeries, request);
        }
 
        template<typename ListTimeSeriesRequestT = Model::ListTimeSeriesRequest>
        void ListTimeSeriesAsync(const ListTimeSeriesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTimeSeriesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTSiteWiseClient::ListTimeSeries, request, handler, context);
        }
 
        virtual Model::PutDefaultEncryptionConfigurationOutcome PutDefaultEncryptionConfiguration(const Model::PutDefaultEncryptionConfigurationRequest& request) const;
 
        template<typename PutDefaultEncryptionConfigurationRequestT = Model::PutDefaultEncryptionConfigurationRequest>
        Model::PutDefaultEncryptionConfigurationOutcomeCallable PutDefaultEncryptionConfigurationCallable(const PutDefaultEncryptionConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::PutDefaultEncryptionConfiguration, request);
        }
 
        template<typename PutDefaultEncryptionConfigurationRequestT = Model::PutDefaultEncryptionConfigurationRequest>
        void PutDefaultEncryptionConfigurationAsync(const PutDefaultEncryptionConfigurationRequestT& request, const PutDefaultEncryptionConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::PutDefaultEncryptionConfiguration, request, handler, context);
        }
 
        virtual Model::PutLoggingOptionsOutcome PutLoggingOptions(const Model::PutLoggingOptionsRequest& request) const;
 
        template<typename PutLoggingOptionsRequestT = Model::PutLoggingOptionsRequest>
        Model::PutLoggingOptionsOutcomeCallable PutLoggingOptionsCallable(const PutLoggingOptionsRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::PutLoggingOptions, request);
        }
 
        template<typename PutLoggingOptionsRequestT = Model::PutLoggingOptionsRequest>
        void PutLoggingOptionsAsync(const PutLoggingOptionsRequestT& request, const PutLoggingOptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::PutLoggingOptions, request, handler, context);
        }
 
        virtual Model::PutStorageConfigurationOutcome PutStorageConfiguration(const Model::PutStorageConfigurationRequest& request) const;
 
        template<typename PutStorageConfigurationRequestT = Model::PutStorageConfigurationRequest>
        Model::PutStorageConfigurationOutcomeCallable PutStorageConfigurationCallable(const PutStorageConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::PutStorageConfiguration, request);
        }
 
        template<typename PutStorageConfigurationRequestT = Model::PutStorageConfigurationRequest>
        void PutStorageConfigurationAsync(const PutStorageConfigurationRequestT& request, const PutStorageConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::PutStorageConfiguration, 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(&IoTSiteWiseClient::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(&IoTSiteWiseClient::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(&IoTSiteWiseClient::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(&IoTSiteWiseClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAccessPolicyOutcome UpdateAccessPolicy(const Model::UpdateAccessPolicyRequest& request) const;
 
        template<typename UpdateAccessPolicyRequestT = Model::UpdateAccessPolicyRequest>
        Model::UpdateAccessPolicyOutcomeCallable UpdateAccessPolicyCallable(const UpdateAccessPolicyRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::UpdateAccessPolicy, request);
        }
 
        template<typename UpdateAccessPolicyRequestT = Model::UpdateAccessPolicyRequest>
        void UpdateAccessPolicyAsync(const UpdateAccessPolicyRequestT& request, const UpdateAccessPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::UpdateAccessPolicy, request, handler, context);
        }
 
        virtual Model::UpdateAssetOutcome UpdateAsset(const Model::UpdateAssetRequest& request) const;
 
        template<typename UpdateAssetRequestT = Model::UpdateAssetRequest>
        Model::UpdateAssetOutcomeCallable UpdateAssetCallable(const UpdateAssetRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::UpdateAsset, request);
        }
 
        template<typename UpdateAssetRequestT = Model::UpdateAssetRequest>
        void UpdateAssetAsync(const UpdateAssetRequestT& request, const UpdateAssetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::UpdateAsset, request, handler, context);
        }
 
        virtual Model::UpdateAssetModelOutcome UpdateAssetModel(const Model::UpdateAssetModelRequest& request) const;
 
        template<typename UpdateAssetModelRequestT = Model::UpdateAssetModelRequest>
        Model::UpdateAssetModelOutcomeCallable UpdateAssetModelCallable(const UpdateAssetModelRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::UpdateAssetModel, request);
        }
 
        template<typename UpdateAssetModelRequestT = Model::UpdateAssetModelRequest>
        void UpdateAssetModelAsync(const UpdateAssetModelRequestT& request, const UpdateAssetModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::UpdateAssetModel, request, handler, context);
        }
 
        virtual Model::UpdateAssetModelCompositeModelOutcome UpdateAssetModelCompositeModel(const Model::UpdateAssetModelCompositeModelRequest& request) const;
 
        template<typename UpdateAssetModelCompositeModelRequestT = Model::UpdateAssetModelCompositeModelRequest>
        Model::UpdateAssetModelCompositeModelOutcomeCallable UpdateAssetModelCompositeModelCallable(const UpdateAssetModelCompositeModelRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::UpdateAssetModelCompositeModel, request);
        }
 
        template<typename UpdateAssetModelCompositeModelRequestT = Model::UpdateAssetModelCompositeModelRequest>
        void UpdateAssetModelCompositeModelAsync(const UpdateAssetModelCompositeModelRequestT& request, const UpdateAssetModelCompositeModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::UpdateAssetModelCompositeModel, request, handler, context);
        }
 
        virtual Model::UpdateAssetPropertyOutcome UpdateAssetProperty(const Model::UpdateAssetPropertyRequest& request) const;
 
        template<typename UpdateAssetPropertyRequestT = Model::UpdateAssetPropertyRequest>
        Model::UpdateAssetPropertyOutcomeCallable UpdateAssetPropertyCallable(const UpdateAssetPropertyRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::UpdateAssetProperty, request);
        }
 
        template<typename UpdateAssetPropertyRequestT = Model::UpdateAssetPropertyRequest>
        void UpdateAssetPropertyAsync(const UpdateAssetPropertyRequestT& request, const UpdateAssetPropertyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::UpdateAssetProperty, request, handler, context);
        }
 
        virtual Model::UpdateDashboardOutcome UpdateDashboard(const Model::UpdateDashboardRequest& request) const;
 
        template<typename UpdateDashboardRequestT = Model::UpdateDashboardRequest>
        Model::UpdateDashboardOutcomeCallable UpdateDashboardCallable(const UpdateDashboardRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::UpdateDashboard, request);
        }
 
        template<typename UpdateDashboardRequestT = Model::UpdateDashboardRequest>
        void UpdateDashboardAsync(const UpdateDashboardRequestT& request, const UpdateDashboardResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::UpdateDashboard, request, handler, context);
        }
 
        virtual Model::UpdateGatewayOutcome UpdateGateway(const Model::UpdateGatewayRequest& request) const;
 
        template<typename UpdateGatewayRequestT = Model::UpdateGatewayRequest>
        Model::UpdateGatewayOutcomeCallable UpdateGatewayCallable(const UpdateGatewayRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::UpdateGateway, request);
        }
 
        template<typename UpdateGatewayRequestT = Model::UpdateGatewayRequest>
        void UpdateGatewayAsync(const UpdateGatewayRequestT& request, const UpdateGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::UpdateGateway, request, handler, context);
        }
 
        virtual Model::UpdateGatewayCapabilityConfigurationOutcome UpdateGatewayCapabilityConfiguration(const Model::UpdateGatewayCapabilityConfigurationRequest& request) const;
 
        template<typename UpdateGatewayCapabilityConfigurationRequestT = Model::UpdateGatewayCapabilityConfigurationRequest>
        Model::UpdateGatewayCapabilityConfigurationOutcomeCallable UpdateGatewayCapabilityConfigurationCallable(const UpdateGatewayCapabilityConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::UpdateGatewayCapabilityConfiguration, request);
        }
 
        template<typename UpdateGatewayCapabilityConfigurationRequestT = Model::UpdateGatewayCapabilityConfigurationRequest>
        void UpdateGatewayCapabilityConfigurationAsync(const UpdateGatewayCapabilityConfigurationRequestT& request, const UpdateGatewayCapabilityConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::UpdateGatewayCapabilityConfiguration, request, handler, context);
        }
 
        virtual Model::UpdatePortalOutcome UpdatePortal(const Model::UpdatePortalRequest& request) const;
 
        template<typename UpdatePortalRequestT = Model::UpdatePortalRequest>
        Model::UpdatePortalOutcomeCallable UpdatePortalCallable(const UpdatePortalRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::UpdatePortal, request);
        }
 
        template<typename UpdatePortalRequestT = Model::UpdatePortalRequest>
        void UpdatePortalAsync(const UpdatePortalRequestT& request, const UpdatePortalResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::UpdatePortal, request, handler, context);
        }
 
        virtual Model::UpdateProjectOutcome UpdateProject(const Model::UpdateProjectRequest& request) const;
 
        template<typename UpdateProjectRequestT = Model::UpdateProjectRequest>
        Model::UpdateProjectOutcomeCallable UpdateProjectCallable(const UpdateProjectRequestT& request) const
        {
            return SubmitCallable(&IoTSiteWiseClient::UpdateProject, request);
        }
 
        template<typename UpdateProjectRequestT = Model::UpdateProjectRequest>
        void UpdateProjectAsync(const UpdateProjectRequestT& request, const UpdateProjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTSiteWiseClient::UpdateProject, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<IoTSiteWiseEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<IoTSiteWiseClient>;
      void init(const IoTSiteWiseClientConfiguration& clientConfiguration);
 
      IoTSiteWiseClientConfiguration m_clientConfiguration;
      std::shared_ptr<IoTSiteWiseEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace IoTSiteWise
} // namespace Aws