IoTFleetWiseClient.h

 
#pragma once
#include <aws/iotfleetwise/IoTFleetWise_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/iotfleetwise/IoTFleetWiseServiceClientModel.h>
 
namespace Aws
{
namespace IoTFleetWise
{
  class AWS_IOTFLEETWISE_API IoTFleetWiseClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<IoTFleetWiseClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef IoTFleetWiseClientConfiguration ClientConfigurationType;
      typedef IoTFleetWiseEndpointProvider EndpointProviderType;
 
        IoTFleetWiseClient(const Aws::IoTFleetWise::IoTFleetWiseClientConfiguration& clientConfiguration = Aws::IoTFleetWise::IoTFleetWiseClientConfiguration(),
                           std::shared_ptr<IoTFleetWiseEndpointProviderBase> endpointProvider = nullptr);
 
        IoTFleetWiseClient(const Aws::Auth::AWSCredentials& credentials,
                           std::shared_ptr<IoTFleetWiseEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::IoTFleetWise::IoTFleetWiseClientConfiguration& clientConfiguration = Aws::IoTFleetWise::IoTFleetWiseClientConfiguration());
 
        IoTFleetWiseClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           std::shared_ptr<IoTFleetWiseEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::IoTFleetWise::IoTFleetWiseClientConfiguration& clientConfiguration = Aws::IoTFleetWise::IoTFleetWiseClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        IoTFleetWiseClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IoTFleetWiseClient(const Aws::Auth::AWSCredentials& credentials,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IoTFleetWiseClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~IoTFleetWiseClient();
 
        virtual Model::AssociateVehicleFleetOutcome AssociateVehicleFleet(const Model::AssociateVehicleFleetRequest& request) const;
 
        template<typename AssociateVehicleFleetRequestT = Model::AssociateVehicleFleetRequest>
        Model::AssociateVehicleFleetOutcomeCallable AssociateVehicleFleetCallable(const AssociateVehicleFleetRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::AssociateVehicleFleet, request);
        }
 
        template<typename AssociateVehicleFleetRequestT = Model::AssociateVehicleFleetRequest>
        void AssociateVehicleFleetAsync(const AssociateVehicleFleetRequestT& request, const AssociateVehicleFleetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::AssociateVehicleFleet, request, handler, context);
        }
 
        virtual Model::BatchCreateVehicleOutcome BatchCreateVehicle(const Model::BatchCreateVehicleRequest& request) const;
 
        template<typename BatchCreateVehicleRequestT = Model::BatchCreateVehicleRequest>
        Model::BatchCreateVehicleOutcomeCallable BatchCreateVehicleCallable(const BatchCreateVehicleRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::BatchCreateVehicle, request);
        }
 
        template<typename BatchCreateVehicleRequestT = Model::BatchCreateVehicleRequest>
        void BatchCreateVehicleAsync(const BatchCreateVehicleRequestT& request, const BatchCreateVehicleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::BatchCreateVehicle, request, handler, context);
        }
 
        virtual Model::BatchUpdateVehicleOutcome BatchUpdateVehicle(const Model::BatchUpdateVehicleRequest& request) const;
 
        template<typename BatchUpdateVehicleRequestT = Model::BatchUpdateVehicleRequest>
        Model::BatchUpdateVehicleOutcomeCallable BatchUpdateVehicleCallable(const BatchUpdateVehicleRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::BatchUpdateVehicle, request);
        }
 
        template<typename BatchUpdateVehicleRequestT = Model::BatchUpdateVehicleRequest>
        void BatchUpdateVehicleAsync(const BatchUpdateVehicleRequestT& request, const BatchUpdateVehicleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::BatchUpdateVehicle, request, handler, context);
        }
 
        virtual Model::CreateCampaignOutcome CreateCampaign(const Model::CreateCampaignRequest& request) const;
 
        template<typename CreateCampaignRequestT = Model::CreateCampaignRequest>
        Model::CreateCampaignOutcomeCallable CreateCampaignCallable(const CreateCampaignRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::CreateCampaign, request);
        }
 
        template<typename CreateCampaignRequestT = Model::CreateCampaignRequest>
        void CreateCampaignAsync(const CreateCampaignRequestT& request, const CreateCampaignResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::CreateCampaign, request, handler, context);
        }
 
        virtual Model::CreateDecoderManifestOutcome CreateDecoderManifest(const Model::CreateDecoderManifestRequest& request) const;
 
        template<typename CreateDecoderManifestRequestT = Model::CreateDecoderManifestRequest>
        Model::CreateDecoderManifestOutcomeCallable CreateDecoderManifestCallable(const CreateDecoderManifestRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::CreateDecoderManifest, request);
        }
 
        template<typename CreateDecoderManifestRequestT = Model::CreateDecoderManifestRequest>
        void CreateDecoderManifestAsync(const CreateDecoderManifestRequestT& request, const CreateDecoderManifestResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::CreateDecoderManifest, request, handler, context);
        }
 
        virtual Model::CreateFleetOutcome CreateFleet(const Model::CreateFleetRequest& request) const;
 
        template<typename CreateFleetRequestT = Model::CreateFleetRequest>
        Model::CreateFleetOutcomeCallable CreateFleetCallable(const CreateFleetRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::CreateFleet, request);
        }
 
        template<typename CreateFleetRequestT = Model::CreateFleetRequest>
        void CreateFleetAsync(const CreateFleetRequestT& request, const CreateFleetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::CreateFleet, request, handler, context);
        }
 
        virtual Model::CreateModelManifestOutcome CreateModelManifest(const Model::CreateModelManifestRequest& request) const;
 
        template<typename CreateModelManifestRequestT = Model::CreateModelManifestRequest>
        Model::CreateModelManifestOutcomeCallable CreateModelManifestCallable(const CreateModelManifestRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::CreateModelManifest, request);
        }
 
        template<typename CreateModelManifestRequestT = Model::CreateModelManifestRequest>
        void CreateModelManifestAsync(const CreateModelManifestRequestT& request, const CreateModelManifestResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::CreateModelManifest, request, handler, context);
        }
 
        virtual Model::CreateSignalCatalogOutcome CreateSignalCatalog(const Model::CreateSignalCatalogRequest& request) const;
 
        template<typename CreateSignalCatalogRequestT = Model::CreateSignalCatalogRequest>
        Model::CreateSignalCatalogOutcomeCallable CreateSignalCatalogCallable(const CreateSignalCatalogRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::CreateSignalCatalog, request);
        }
 
        template<typename CreateSignalCatalogRequestT = Model::CreateSignalCatalogRequest>
        void CreateSignalCatalogAsync(const CreateSignalCatalogRequestT& request, const CreateSignalCatalogResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::CreateSignalCatalog, request, handler, context);
        }
 
        virtual Model::CreateStateTemplateOutcome CreateStateTemplate(const Model::CreateStateTemplateRequest& request) const;
 
        template<typename CreateStateTemplateRequestT = Model::CreateStateTemplateRequest>
        Model::CreateStateTemplateOutcomeCallable CreateStateTemplateCallable(const CreateStateTemplateRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::CreateStateTemplate, request);
        }
 
        template<typename CreateStateTemplateRequestT = Model::CreateStateTemplateRequest>
        void CreateStateTemplateAsync(const CreateStateTemplateRequestT& request, const CreateStateTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::CreateStateTemplate, request, handler, context);
        }
 
        virtual Model::CreateVehicleOutcome CreateVehicle(const Model::CreateVehicleRequest& request) const;
 
        template<typename CreateVehicleRequestT = Model::CreateVehicleRequest>
        Model::CreateVehicleOutcomeCallable CreateVehicleCallable(const CreateVehicleRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::CreateVehicle, request);
        }
 
        template<typename CreateVehicleRequestT = Model::CreateVehicleRequest>
        void CreateVehicleAsync(const CreateVehicleRequestT& request, const CreateVehicleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::CreateVehicle, request, handler, context);
        }
 
        virtual Model::DeleteCampaignOutcome DeleteCampaign(const Model::DeleteCampaignRequest& request) const;
 
        template<typename DeleteCampaignRequestT = Model::DeleteCampaignRequest>
        Model::DeleteCampaignOutcomeCallable DeleteCampaignCallable(const DeleteCampaignRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::DeleteCampaign, request);
        }
 
        template<typename DeleteCampaignRequestT = Model::DeleteCampaignRequest>
        void DeleteCampaignAsync(const DeleteCampaignRequestT& request, const DeleteCampaignResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::DeleteCampaign, request, handler, context);
        }
 
        virtual Model::DeleteDecoderManifestOutcome DeleteDecoderManifest(const Model::DeleteDecoderManifestRequest& request) const;
 
        template<typename DeleteDecoderManifestRequestT = Model::DeleteDecoderManifestRequest>
        Model::DeleteDecoderManifestOutcomeCallable DeleteDecoderManifestCallable(const DeleteDecoderManifestRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::DeleteDecoderManifest, request);
        }
 
        template<typename DeleteDecoderManifestRequestT = Model::DeleteDecoderManifestRequest>
        void DeleteDecoderManifestAsync(const DeleteDecoderManifestRequestT& request, const DeleteDecoderManifestResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::DeleteDecoderManifest, request, handler, context);
        }
 
        virtual Model::DeleteFleetOutcome DeleteFleet(const Model::DeleteFleetRequest& request) const;
 
        template<typename DeleteFleetRequestT = Model::DeleteFleetRequest>
        Model::DeleteFleetOutcomeCallable DeleteFleetCallable(const DeleteFleetRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::DeleteFleet, request);
        }
 
        template<typename DeleteFleetRequestT = Model::DeleteFleetRequest>
        void DeleteFleetAsync(const DeleteFleetRequestT& request, const DeleteFleetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::DeleteFleet, request, handler, context);
        }
 
        virtual Model::DeleteModelManifestOutcome DeleteModelManifest(const Model::DeleteModelManifestRequest& request) const;
 
        template<typename DeleteModelManifestRequestT = Model::DeleteModelManifestRequest>
        Model::DeleteModelManifestOutcomeCallable DeleteModelManifestCallable(const DeleteModelManifestRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::DeleteModelManifest, request);
        }
 
        template<typename DeleteModelManifestRequestT = Model::DeleteModelManifestRequest>
        void DeleteModelManifestAsync(const DeleteModelManifestRequestT& request, const DeleteModelManifestResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::DeleteModelManifest, request, handler, context);
        }
 
        virtual Model::DeleteSignalCatalogOutcome DeleteSignalCatalog(const Model::DeleteSignalCatalogRequest& request) const;
 
        template<typename DeleteSignalCatalogRequestT = Model::DeleteSignalCatalogRequest>
        Model::DeleteSignalCatalogOutcomeCallable DeleteSignalCatalogCallable(const DeleteSignalCatalogRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::DeleteSignalCatalog, request);
        }
 
        template<typename DeleteSignalCatalogRequestT = Model::DeleteSignalCatalogRequest>
        void DeleteSignalCatalogAsync(const DeleteSignalCatalogRequestT& request, const DeleteSignalCatalogResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::DeleteSignalCatalog, request, handler, context);
        }
 
        virtual Model::DeleteStateTemplateOutcome DeleteStateTemplate(const Model::DeleteStateTemplateRequest& request) const;
 
        template<typename DeleteStateTemplateRequestT = Model::DeleteStateTemplateRequest>
        Model::DeleteStateTemplateOutcomeCallable DeleteStateTemplateCallable(const DeleteStateTemplateRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::DeleteStateTemplate, request);
        }
 
        template<typename DeleteStateTemplateRequestT = Model::DeleteStateTemplateRequest>
        void DeleteStateTemplateAsync(const DeleteStateTemplateRequestT& request, const DeleteStateTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::DeleteStateTemplate, request, handler, context);
        }
 
        virtual Model::DeleteVehicleOutcome DeleteVehicle(const Model::DeleteVehicleRequest& request) const;
 
        template<typename DeleteVehicleRequestT = Model::DeleteVehicleRequest>
        Model::DeleteVehicleOutcomeCallable DeleteVehicleCallable(const DeleteVehicleRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::DeleteVehicle, request);
        }
 
        template<typename DeleteVehicleRequestT = Model::DeleteVehicleRequest>
        void DeleteVehicleAsync(const DeleteVehicleRequestT& request, const DeleteVehicleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::DeleteVehicle, request, handler, context);
        }
 
        virtual Model::DisassociateVehicleFleetOutcome DisassociateVehicleFleet(const Model::DisassociateVehicleFleetRequest& request) const;
 
        template<typename DisassociateVehicleFleetRequestT = Model::DisassociateVehicleFleetRequest>
        Model::DisassociateVehicleFleetOutcomeCallable DisassociateVehicleFleetCallable(const DisassociateVehicleFleetRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::DisassociateVehicleFleet, request);
        }
 
        template<typename DisassociateVehicleFleetRequestT = Model::DisassociateVehicleFleetRequest>
        void DisassociateVehicleFleetAsync(const DisassociateVehicleFleetRequestT& request, const DisassociateVehicleFleetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::DisassociateVehicleFleet, request, handler, context);
        }
 
        virtual Model::GetCampaignOutcome GetCampaign(const Model::GetCampaignRequest& request) const;
 
        template<typename GetCampaignRequestT = Model::GetCampaignRequest>
        Model::GetCampaignOutcomeCallable GetCampaignCallable(const GetCampaignRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::GetCampaign, request);
        }
 
        template<typename GetCampaignRequestT = Model::GetCampaignRequest>
        void GetCampaignAsync(const GetCampaignRequestT& request, const GetCampaignResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::GetCampaign, request, handler, context);
        }
 
        virtual Model::GetDecoderManifestOutcome GetDecoderManifest(const Model::GetDecoderManifestRequest& request) const;
 
        template<typename GetDecoderManifestRequestT = Model::GetDecoderManifestRequest>
        Model::GetDecoderManifestOutcomeCallable GetDecoderManifestCallable(const GetDecoderManifestRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::GetDecoderManifest, request);
        }
 
        template<typename GetDecoderManifestRequestT = Model::GetDecoderManifestRequest>
        void GetDecoderManifestAsync(const GetDecoderManifestRequestT& request, const GetDecoderManifestResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::GetDecoderManifest, request, handler, context);
        }
 
        virtual Model::GetEncryptionConfigurationOutcome GetEncryptionConfiguration(const Model::GetEncryptionConfigurationRequest& request = {}) const;
 
        template<typename GetEncryptionConfigurationRequestT = Model::GetEncryptionConfigurationRequest>
        Model::GetEncryptionConfigurationOutcomeCallable GetEncryptionConfigurationCallable(const GetEncryptionConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&IoTFleetWiseClient::GetEncryptionConfiguration, request);
        }
 
        template<typename GetEncryptionConfigurationRequestT = Model::GetEncryptionConfigurationRequest>
        void GetEncryptionConfigurationAsync(const GetEncryptionConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetEncryptionConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&IoTFleetWiseClient::GetEncryptionConfiguration, request, handler, context);
        }
 
        virtual Model::GetFleetOutcome GetFleet(const Model::GetFleetRequest& request) const;
 
        template<typename GetFleetRequestT = Model::GetFleetRequest>
        Model::GetFleetOutcomeCallable GetFleetCallable(const GetFleetRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::GetFleet, request);
        }
 
        template<typename GetFleetRequestT = Model::GetFleetRequest>
        void GetFleetAsync(const GetFleetRequestT& request, const GetFleetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::GetFleet, request, handler, context);
        }
 
        virtual Model::GetLoggingOptionsOutcome GetLoggingOptions(const Model::GetLoggingOptionsRequest& request = {}) const;
 
        template<typename GetLoggingOptionsRequestT = Model::GetLoggingOptionsRequest>
        Model::GetLoggingOptionsOutcomeCallable GetLoggingOptionsCallable(const GetLoggingOptionsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTFleetWiseClient::GetLoggingOptions, request);
        }
 
        template<typename GetLoggingOptionsRequestT = Model::GetLoggingOptionsRequest>
        void GetLoggingOptionsAsync(const GetLoggingOptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetLoggingOptionsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTFleetWiseClient::GetLoggingOptions, request, handler, context);
        }
 
        virtual Model::GetModelManifestOutcome GetModelManifest(const Model::GetModelManifestRequest& request) const;
 
        template<typename GetModelManifestRequestT = Model::GetModelManifestRequest>
        Model::GetModelManifestOutcomeCallable GetModelManifestCallable(const GetModelManifestRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::GetModelManifest, request);
        }
 
        template<typename GetModelManifestRequestT = Model::GetModelManifestRequest>
        void GetModelManifestAsync(const GetModelManifestRequestT& request, const GetModelManifestResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::GetModelManifest, request, handler, context);
        }
 
        virtual Model::GetRegisterAccountStatusOutcome GetRegisterAccountStatus(const Model::GetRegisterAccountStatusRequest& request = {}) const;
 
        template<typename GetRegisterAccountStatusRequestT = Model::GetRegisterAccountStatusRequest>
        Model::GetRegisterAccountStatusOutcomeCallable GetRegisterAccountStatusCallable(const GetRegisterAccountStatusRequestT& request = {}) const
        {
            return SubmitCallable(&IoTFleetWiseClient::GetRegisterAccountStatus, request);
        }
 
        template<typename GetRegisterAccountStatusRequestT = Model::GetRegisterAccountStatusRequest>
        void GetRegisterAccountStatusAsync(const GetRegisterAccountStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetRegisterAccountStatusRequestT& request = {}) const
        {
            return SubmitAsync(&IoTFleetWiseClient::GetRegisterAccountStatus, request, handler, context);
        }
 
        virtual Model::GetSignalCatalogOutcome GetSignalCatalog(const Model::GetSignalCatalogRequest& request) const;
 
        template<typename GetSignalCatalogRequestT = Model::GetSignalCatalogRequest>
        Model::GetSignalCatalogOutcomeCallable GetSignalCatalogCallable(const GetSignalCatalogRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::GetSignalCatalog, request);
        }
 
        template<typename GetSignalCatalogRequestT = Model::GetSignalCatalogRequest>
        void GetSignalCatalogAsync(const GetSignalCatalogRequestT& request, const GetSignalCatalogResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::GetSignalCatalog, request, handler, context);
        }
 
        virtual Model::GetStateTemplateOutcome GetStateTemplate(const Model::GetStateTemplateRequest& request) const;
 
        template<typename GetStateTemplateRequestT = Model::GetStateTemplateRequest>
        Model::GetStateTemplateOutcomeCallable GetStateTemplateCallable(const GetStateTemplateRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::GetStateTemplate, request);
        }
 
        template<typename GetStateTemplateRequestT = Model::GetStateTemplateRequest>
        void GetStateTemplateAsync(const GetStateTemplateRequestT& request, const GetStateTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::GetStateTemplate, request, handler, context);
        }
 
        virtual Model::GetVehicleOutcome GetVehicle(const Model::GetVehicleRequest& request) const;
 
        template<typename GetVehicleRequestT = Model::GetVehicleRequest>
        Model::GetVehicleOutcomeCallable GetVehicleCallable(const GetVehicleRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::GetVehicle, request);
        }
 
        template<typename GetVehicleRequestT = Model::GetVehicleRequest>
        void GetVehicleAsync(const GetVehicleRequestT& request, const GetVehicleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::GetVehicle, request, handler, context);
        }
 
        virtual Model::GetVehicleStatusOutcome GetVehicleStatus(const Model::GetVehicleStatusRequest& request) const;
 
        template<typename GetVehicleStatusRequestT = Model::GetVehicleStatusRequest>
        Model::GetVehicleStatusOutcomeCallable GetVehicleStatusCallable(const GetVehicleStatusRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::GetVehicleStatus, request);
        }
 
        template<typename GetVehicleStatusRequestT = Model::GetVehicleStatusRequest>
        void GetVehicleStatusAsync(const GetVehicleStatusRequestT& request, const GetVehicleStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::GetVehicleStatus, request, handler, context);
        }
 
        virtual Model::ImportDecoderManifestOutcome ImportDecoderManifest(const Model::ImportDecoderManifestRequest& request) const;
 
        template<typename ImportDecoderManifestRequestT = Model::ImportDecoderManifestRequest>
        Model::ImportDecoderManifestOutcomeCallable ImportDecoderManifestCallable(const ImportDecoderManifestRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::ImportDecoderManifest, request);
        }
 
        template<typename ImportDecoderManifestRequestT = Model::ImportDecoderManifestRequest>
        void ImportDecoderManifestAsync(const ImportDecoderManifestRequestT& request, const ImportDecoderManifestResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::ImportDecoderManifest, request, handler, context);
        }
 
        virtual Model::ImportSignalCatalogOutcome ImportSignalCatalog(const Model::ImportSignalCatalogRequest& request) const;
 
        template<typename ImportSignalCatalogRequestT = Model::ImportSignalCatalogRequest>
        Model::ImportSignalCatalogOutcomeCallable ImportSignalCatalogCallable(const ImportSignalCatalogRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::ImportSignalCatalog, request);
        }
 
        template<typename ImportSignalCatalogRequestT = Model::ImportSignalCatalogRequest>
        void ImportSignalCatalogAsync(const ImportSignalCatalogRequestT& request, const ImportSignalCatalogResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::ImportSignalCatalog, request, handler, context);
        }
 
        virtual Model::ListCampaignsOutcome ListCampaigns(const Model::ListCampaignsRequest& request = {}) const;
 
        template<typename ListCampaignsRequestT = Model::ListCampaignsRequest>
        Model::ListCampaignsOutcomeCallable ListCampaignsCallable(const ListCampaignsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTFleetWiseClient::ListCampaigns, request);
        }
 
        template<typename ListCampaignsRequestT = Model::ListCampaignsRequest>
        void ListCampaignsAsync(const ListCampaignsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCampaignsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTFleetWiseClient::ListCampaigns, request, handler, context);
        }
 
        virtual Model::ListDecoderManifestNetworkInterfacesOutcome ListDecoderManifestNetworkInterfaces(const Model::ListDecoderManifestNetworkInterfacesRequest& request) const;
 
        template<typename ListDecoderManifestNetworkInterfacesRequestT = Model::ListDecoderManifestNetworkInterfacesRequest>
        Model::ListDecoderManifestNetworkInterfacesOutcomeCallable ListDecoderManifestNetworkInterfacesCallable(const ListDecoderManifestNetworkInterfacesRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::ListDecoderManifestNetworkInterfaces, request);
        }
 
        template<typename ListDecoderManifestNetworkInterfacesRequestT = Model::ListDecoderManifestNetworkInterfacesRequest>
        void ListDecoderManifestNetworkInterfacesAsync(const ListDecoderManifestNetworkInterfacesRequestT& request, const ListDecoderManifestNetworkInterfacesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::ListDecoderManifestNetworkInterfaces, request, handler, context);
        }
 
        virtual Model::ListDecoderManifestSignalsOutcome ListDecoderManifestSignals(const Model::ListDecoderManifestSignalsRequest& request) const;
 
        template<typename ListDecoderManifestSignalsRequestT = Model::ListDecoderManifestSignalsRequest>
        Model::ListDecoderManifestSignalsOutcomeCallable ListDecoderManifestSignalsCallable(const ListDecoderManifestSignalsRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::ListDecoderManifestSignals, request);
        }
 
        template<typename ListDecoderManifestSignalsRequestT = Model::ListDecoderManifestSignalsRequest>
        void ListDecoderManifestSignalsAsync(const ListDecoderManifestSignalsRequestT& request, const ListDecoderManifestSignalsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::ListDecoderManifestSignals, request, handler, context);
        }
 
        virtual Model::ListDecoderManifestsOutcome ListDecoderManifests(const Model::ListDecoderManifestsRequest& request = {}) const;
 
        template<typename ListDecoderManifestsRequestT = Model::ListDecoderManifestsRequest>
        Model::ListDecoderManifestsOutcomeCallable ListDecoderManifestsCallable(const ListDecoderManifestsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTFleetWiseClient::ListDecoderManifests, request);
        }
 
        template<typename ListDecoderManifestsRequestT = Model::ListDecoderManifestsRequest>
        void ListDecoderManifestsAsync(const ListDecoderManifestsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDecoderManifestsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTFleetWiseClient::ListDecoderManifests, request, handler, context);
        }
 
        virtual Model::ListFleetsOutcome ListFleets(const Model::ListFleetsRequest& request = {}) const;
 
        template<typename ListFleetsRequestT = Model::ListFleetsRequest>
        Model::ListFleetsOutcomeCallable ListFleetsCallable(const ListFleetsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTFleetWiseClient::ListFleets, request);
        }
 
        template<typename ListFleetsRequestT = Model::ListFleetsRequest>
        void ListFleetsAsync(const ListFleetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListFleetsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTFleetWiseClient::ListFleets, request, handler, context);
        }
 
        virtual Model::ListFleetsForVehicleOutcome ListFleetsForVehicle(const Model::ListFleetsForVehicleRequest& request) const;
 
        template<typename ListFleetsForVehicleRequestT = Model::ListFleetsForVehicleRequest>
        Model::ListFleetsForVehicleOutcomeCallable ListFleetsForVehicleCallable(const ListFleetsForVehicleRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::ListFleetsForVehicle, request);
        }
 
        template<typename ListFleetsForVehicleRequestT = Model::ListFleetsForVehicleRequest>
        void ListFleetsForVehicleAsync(const ListFleetsForVehicleRequestT& request, const ListFleetsForVehicleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::ListFleetsForVehicle, request, handler, context);
        }
 
        virtual Model::ListModelManifestNodesOutcome ListModelManifestNodes(const Model::ListModelManifestNodesRequest& request) const;
 
        template<typename ListModelManifestNodesRequestT = Model::ListModelManifestNodesRequest>
        Model::ListModelManifestNodesOutcomeCallable ListModelManifestNodesCallable(const ListModelManifestNodesRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::ListModelManifestNodes, request);
        }
 
        template<typename ListModelManifestNodesRequestT = Model::ListModelManifestNodesRequest>
        void ListModelManifestNodesAsync(const ListModelManifestNodesRequestT& request, const ListModelManifestNodesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::ListModelManifestNodes, request, handler, context);
        }
 
        virtual Model::ListModelManifestsOutcome ListModelManifests(const Model::ListModelManifestsRequest& request = {}) const;
 
        template<typename ListModelManifestsRequestT = Model::ListModelManifestsRequest>
        Model::ListModelManifestsOutcomeCallable ListModelManifestsCallable(const ListModelManifestsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTFleetWiseClient::ListModelManifests, request);
        }
 
        template<typename ListModelManifestsRequestT = Model::ListModelManifestsRequest>
        void ListModelManifestsAsync(const ListModelManifestsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListModelManifestsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTFleetWiseClient::ListModelManifests, request, handler, context);
        }
 
        virtual Model::ListSignalCatalogNodesOutcome ListSignalCatalogNodes(const Model::ListSignalCatalogNodesRequest& request) const;
 
        template<typename ListSignalCatalogNodesRequestT = Model::ListSignalCatalogNodesRequest>
        Model::ListSignalCatalogNodesOutcomeCallable ListSignalCatalogNodesCallable(const ListSignalCatalogNodesRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::ListSignalCatalogNodes, request);
        }
 
        template<typename ListSignalCatalogNodesRequestT = Model::ListSignalCatalogNodesRequest>
        void ListSignalCatalogNodesAsync(const ListSignalCatalogNodesRequestT& request, const ListSignalCatalogNodesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::ListSignalCatalogNodes, request, handler, context);
        }
 
        virtual Model::ListSignalCatalogsOutcome ListSignalCatalogs(const Model::ListSignalCatalogsRequest& request = {}) const;
 
        template<typename ListSignalCatalogsRequestT = Model::ListSignalCatalogsRequest>
        Model::ListSignalCatalogsOutcomeCallable ListSignalCatalogsCallable(const ListSignalCatalogsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTFleetWiseClient::ListSignalCatalogs, request);
        }
 
        template<typename ListSignalCatalogsRequestT = Model::ListSignalCatalogsRequest>
        void ListSignalCatalogsAsync(const ListSignalCatalogsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSignalCatalogsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTFleetWiseClient::ListSignalCatalogs, request, handler, context);
        }
 
        virtual Model::ListStateTemplatesOutcome ListStateTemplates(const Model::ListStateTemplatesRequest& request = {}) const;
 
        template<typename ListStateTemplatesRequestT = Model::ListStateTemplatesRequest>
        Model::ListStateTemplatesOutcomeCallable ListStateTemplatesCallable(const ListStateTemplatesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTFleetWiseClient::ListStateTemplates, request);
        }
 
        template<typename ListStateTemplatesRequestT = Model::ListStateTemplatesRequest>
        void ListStateTemplatesAsync(const ListStateTemplatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListStateTemplatesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTFleetWiseClient::ListStateTemplates, 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(&IoTFleetWiseClient::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(&IoTFleetWiseClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListVehiclesOutcome ListVehicles(const Model::ListVehiclesRequest& request = {}) const;
 
        template<typename ListVehiclesRequestT = Model::ListVehiclesRequest>
        Model::ListVehiclesOutcomeCallable ListVehiclesCallable(const ListVehiclesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTFleetWiseClient::ListVehicles, request);
        }
 
        template<typename ListVehiclesRequestT = Model::ListVehiclesRequest>
        void ListVehiclesAsync(const ListVehiclesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListVehiclesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTFleetWiseClient::ListVehicles, request, handler, context);
        }
 
        virtual Model::ListVehiclesInFleetOutcome ListVehiclesInFleet(const Model::ListVehiclesInFleetRequest& request) const;
 
        template<typename ListVehiclesInFleetRequestT = Model::ListVehiclesInFleetRequest>
        Model::ListVehiclesInFleetOutcomeCallable ListVehiclesInFleetCallable(const ListVehiclesInFleetRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::ListVehiclesInFleet, request);
        }
 
        template<typename ListVehiclesInFleetRequestT = Model::ListVehiclesInFleetRequest>
        void ListVehiclesInFleetAsync(const ListVehiclesInFleetRequestT& request, const ListVehiclesInFleetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::ListVehiclesInFleet, request, handler, context);
        }
 
        virtual Model::PutEncryptionConfigurationOutcome PutEncryptionConfiguration(const Model::PutEncryptionConfigurationRequest& request) const;
 
        template<typename PutEncryptionConfigurationRequestT = Model::PutEncryptionConfigurationRequest>
        Model::PutEncryptionConfigurationOutcomeCallable PutEncryptionConfigurationCallable(const PutEncryptionConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::PutEncryptionConfiguration, request);
        }
 
        template<typename PutEncryptionConfigurationRequestT = Model::PutEncryptionConfigurationRequest>
        void PutEncryptionConfigurationAsync(const PutEncryptionConfigurationRequestT& request, const PutEncryptionConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::PutEncryptionConfiguration, 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(&IoTFleetWiseClient::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(&IoTFleetWiseClient::PutLoggingOptions, request, handler, context);
        }
 
        virtual Model::RegisterAccountOutcome RegisterAccount(const Model::RegisterAccountRequest& request = {}) const;
 
        template<typename RegisterAccountRequestT = Model::RegisterAccountRequest>
        Model::RegisterAccountOutcomeCallable RegisterAccountCallable(const RegisterAccountRequestT& request = {}) const
        {
            return SubmitCallable(&IoTFleetWiseClient::RegisterAccount, request);
        }
 
        template<typename RegisterAccountRequestT = Model::RegisterAccountRequest>
        void RegisterAccountAsync(const RegisterAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const RegisterAccountRequestT& request = {}) const
        {
            return SubmitAsync(&IoTFleetWiseClient::RegisterAccount, 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(&IoTFleetWiseClient::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(&IoTFleetWiseClient::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(&IoTFleetWiseClient::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(&IoTFleetWiseClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateCampaignOutcome UpdateCampaign(const Model::UpdateCampaignRequest& request) const;
 
        template<typename UpdateCampaignRequestT = Model::UpdateCampaignRequest>
        Model::UpdateCampaignOutcomeCallable UpdateCampaignCallable(const UpdateCampaignRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::UpdateCampaign, request);
        }
 
        template<typename UpdateCampaignRequestT = Model::UpdateCampaignRequest>
        void UpdateCampaignAsync(const UpdateCampaignRequestT& request, const UpdateCampaignResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::UpdateCampaign, request, handler, context);
        }
 
        virtual Model::UpdateDecoderManifestOutcome UpdateDecoderManifest(const Model::UpdateDecoderManifestRequest& request) const;
 
        template<typename UpdateDecoderManifestRequestT = Model::UpdateDecoderManifestRequest>
        Model::UpdateDecoderManifestOutcomeCallable UpdateDecoderManifestCallable(const UpdateDecoderManifestRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::UpdateDecoderManifest, request);
        }
 
        template<typename UpdateDecoderManifestRequestT = Model::UpdateDecoderManifestRequest>
        void UpdateDecoderManifestAsync(const UpdateDecoderManifestRequestT& request, const UpdateDecoderManifestResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::UpdateDecoderManifest, request, handler, context);
        }
 
        virtual Model::UpdateFleetOutcome UpdateFleet(const Model::UpdateFleetRequest& request) const;
 
        template<typename UpdateFleetRequestT = Model::UpdateFleetRequest>
        Model::UpdateFleetOutcomeCallable UpdateFleetCallable(const UpdateFleetRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::UpdateFleet, request);
        }
 
        template<typename UpdateFleetRequestT = Model::UpdateFleetRequest>
        void UpdateFleetAsync(const UpdateFleetRequestT& request, const UpdateFleetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::UpdateFleet, request, handler, context);
        }
 
        virtual Model::UpdateModelManifestOutcome UpdateModelManifest(const Model::UpdateModelManifestRequest& request) const;
 
        template<typename UpdateModelManifestRequestT = Model::UpdateModelManifestRequest>
        Model::UpdateModelManifestOutcomeCallable UpdateModelManifestCallable(const UpdateModelManifestRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::UpdateModelManifest, request);
        }
 
        template<typename UpdateModelManifestRequestT = Model::UpdateModelManifestRequest>
        void UpdateModelManifestAsync(const UpdateModelManifestRequestT& request, const UpdateModelManifestResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::UpdateModelManifest, request, handler, context);
        }
 
        virtual Model::UpdateSignalCatalogOutcome UpdateSignalCatalog(const Model::UpdateSignalCatalogRequest& request) const;
 
        template<typename UpdateSignalCatalogRequestT = Model::UpdateSignalCatalogRequest>
        Model::UpdateSignalCatalogOutcomeCallable UpdateSignalCatalogCallable(const UpdateSignalCatalogRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::UpdateSignalCatalog, request);
        }
 
        template<typename UpdateSignalCatalogRequestT = Model::UpdateSignalCatalogRequest>
        void UpdateSignalCatalogAsync(const UpdateSignalCatalogRequestT& request, const UpdateSignalCatalogResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::UpdateSignalCatalog, request, handler, context);
        }
 
        virtual Model::UpdateStateTemplateOutcome UpdateStateTemplate(const Model::UpdateStateTemplateRequest& request) const;
 
        template<typename UpdateStateTemplateRequestT = Model::UpdateStateTemplateRequest>
        Model::UpdateStateTemplateOutcomeCallable UpdateStateTemplateCallable(const UpdateStateTemplateRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::UpdateStateTemplate, request);
        }
 
        template<typename UpdateStateTemplateRequestT = Model::UpdateStateTemplateRequest>
        void UpdateStateTemplateAsync(const UpdateStateTemplateRequestT& request, const UpdateStateTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::UpdateStateTemplate, request, handler, context);
        }
 
        virtual Model::UpdateVehicleOutcome UpdateVehicle(const Model::UpdateVehicleRequest& request) const;
 
        template<typename UpdateVehicleRequestT = Model::UpdateVehicleRequest>
        Model::UpdateVehicleOutcomeCallable UpdateVehicleCallable(const UpdateVehicleRequestT& request) const
        {
            return SubmitCallable(&IoTFleetWiseClient::UpdateVehicle, request);
        }
 
        template<typename UpdateVehicleRequestT = Model::UpdateVehicleRequest>
        void UpdateVehicleAsync(const UpdateVehicleRequestT& request, const UpdateVehicleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTFleetWiseClient::UpdateVehicle, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<IoTFleetWiseEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<IoTFleetWiseClient>;
      void init(const IoTFleetWiseClientConfiguration& clientConfiguration);
 
      IoTFleetWiseClientConfiguration m_clientConfiguration;
      std::shared_ptr<IoTFleetWiseEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace IoTFleetWise
} // namespace Aws