SMSClient.h

 
#pragma once
#include <aws/sms/SMS_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/sms/SMSServiceClientModel.h>
 
namespace Aws
{
namespace SMS
{
  class AWS_SMS_API SMSClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<SMSClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef SMSClientConfiguration ClientConfigurationType;
      typedef SMSEndpointProvider EndpointProviderType;
 
        SMSClient(const Aws::SMS::SMSClientConfiguration& clientConfiguration = Aws::SMS::SMSClientConfiguration(),
                  std::shared_ptr<SMSEndpointProviderBase> endpointProvider = nullptr);
 
        SMSClient(const Aws::Auth::AWSCredentials& credentials,
                  std::shared_ptr<SMSEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::SMS::SMSClientConfiguration& clientConfiguration = Aws::SMS::SMSClientConfiguration());
 
        SMSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<SMSEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::SMS::SMSClientConfiguration& clientConfiguration = Aws::SMS::SMSClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        SMSClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SMSClient(const Aws::Auth::AWSCredentials& credentials,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SMSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~SMSClient();
 
        virtual Model::CreateAppOutcome CreateApp(const Model::CreateAppRequest& request = {}) const;
 
        template<typename CreateAppRequestT = Model::CreateAppRequest>
        Model::CreateAppOutcomeCallable CreateAppCallable(const CreateAppRequestT& request = {}) const
        {
            return SubmitCallable(&SMSClient::CreateApp, request);
        }
 
        template<typename CreateAppRequestT = Model::CreateAppRequest>
        void CreateAppAsync(const CreateAppResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateAppRequestT& request = {}) const
        {
            return SubmitAsync(&SMSClient::CreateApp, request, handler, context);
        }
 
        virtual Model::CreateReplicationJobOutcome CreateReplicationJob(const Model::CreateReplicationJobRequest& request) const;
 
        template<typename CreateReplicationJobRequestT = Model::CreateReplicationJobRequest>
        Model::CreateReplicationJobOutcomeCallable CreateReplicationJobCallable(const CreateReplicationJobRequestT& request) const
        {
            return SubmitCallable(&SMSClient::CreateReplicationJob, request);
        }
 
        template<typename CreateReplicationJobRequestT = Model::CreateReplicationJobRequest>
        void CreateReplicationJobAsync(const CreateReplicationJobRequestT& request, const CreateReplicationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SMSClient::CreateReplicationJob, request, handler, context);
        }
 
        virtual Model::DeleteAppOutcome DeleteApp(const Model::DeleteAppRequest& request = {}) const;
 
        template<typename DeleteAppRequestT = Model::DeleteAppRequest>
        Model::DeleteAppOutcomeCallable DeleteAppCallable(const DeleteAppRequestT& request = {}) const
        {
            return SubmitCallable(&SMSClient::DeleteApp, request);
        }
 
        template<typename DeleteAppRequestT = Model::DeleteAppRequest>
        void DeleteAppAsync(const DeleteAppResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteAppRequestT& request = {}) const
        {
            return SubmitAsync(&SMSClient::DeleteApp, request, handler, context);
        }
 
        virtual Model::DeleteAppLaunchConfigurationOutcome DeleteAppLaunchConfiguration(const Model::DeleteAppLaunchConfigurationRequest& request = {}) const;
 
        template<typename DeleteAppLaunchConfigurationRequestT = Model::DeleteAppLaunchConfigurationRequest>
        Model::DeleteAppLaunchConfigurationOutcomeCallable DeleteAppLaunchConfigurationCallable(const DeleteAppLaunchConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&SMSClient::DeleteAppLaunchConfiguration, request);
        }
 
        template<typename DeleteAppLaunchConfigurationRequestT = Model::DeleteAppLaunchConfigurationRequest>
        void DeleteAppLaunchConfigurationAsync(const DeleteAppLaunchConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteAppLaunchConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&SMSClient::DeleteAppLaunchConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteAppReplicationConfigurationOutcome DeleteAppReplicationConfiguration(const Model::DeleteAppReplicationConfigurationRequest& request = {}) const;
 
        template<typename DeleteAppReplicationConfigurationRequestT = Model::DeleteAppReplicationConfigurationRequest>
        Model::DeleteAppReplicationConfigurationOutcomeCallable DeleteAppReplicationConfigurationCallable(const DeleteAppReplicationConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&SMSClient::DeleteAppReplicationConfiguration, request);
        }
 
        template<typename DeleteAppReplicationConfigurationRequestT = Model::DeleteAppReplicationConfigurationRequest>
        void DeleteAppReplicationConfigurationAsync(const DeleteAppReplicationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteAppReplicationConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&SMSClient::DeleteAppReplicationConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteAppValidationConfigurationOutcome DeleteAppValidationConfiguration(const Model::DeleteAppValidationConfigurationRequest& request) const;
 
        template<typename DeleteAppValidationConfigurationRequestT = Model::DeleteAppValidationConfigurationRequest>
        Model::DeleteAppValidationConfigurationOutcomeCallable DeleteAppValidationConfigurationCallable(const DeleteAppValidationConfigurationRequestT& request) const
        {
            return SubmitCallable(&SMSClient::DeleteAppValidationConfiguration, request);
        }
 
        template<typename DeleteAppValidationConfigurationRequestT = Model::DeleteAppValidationConfigurationRequest>
        void DeleteAppValidationConfigurationAsync(const DeleteAppValidationConfigurationRequestT& request, const DeleteAppValidationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SMSClient::DeleteAppValidationConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteReplicationJobOutcome DeleteReplicationJob(const Model::DeleteReplicationJobRequest& request) const;
 
        template<typename DeleteReplicationJobRequestT = Model::DeleteReplicationJobRequest>
        Model::DeleteReplicationJobOutcomeCallable DeleteReplicationJobCallable(const DeleteReplicationJobRequestT& request) const
        {
            return SubmitCallable(&SMSClient::DeleteReplicationJob, request);
        }
 
        template<typename DeleteReplicationJobRequestT = Model::DeleteReplicationJobRequest>
        void DeleteReplicationJobAsync(const DeleteReplicationJobRequestT& request, const DeleteReplicationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SMSClient::DeleteReplicationJob, request, handler, context);
        }
 
        virtual Model::DeleteServerCatalogOutcome DeleteServerCatalog(const Model::DeleteServerCatalogRequest& request = {}) const;
 
        template<typename DeleteServerCatalogRequestT = Model::DeleteServerCatalogRequest>
        Model::DeleteServerCatalogOutcomeCallable DeleteServerCatalogCallable(const DeleteServerCatalogRequestT& request = {}) const
        {
            return SubmitCallable(&SMSClient::DeleteServerCatalog, request);
        }
 
        template<typename DeleteServerCatalogRequestT = Model::DeleteServerCatalogRequest>
        void DeleteServerCatalogAsync(const DeleteServerCatalogResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteServerCatalogRequestT& request = {}) const
        {
            return SubmitAsync(&SMSClient::DeleteServerCatalog, request, handler, context);
        }
 
        virtual Model::DisassociateConnectorOutcome DisassociateConnector(const Model::DisassociateConnectorRequest& request) const;
 
        template<typename DisassociateConnectorRequestT = Model::DisassociateConnectorRequest>
        Model::DisassociateConnectorOutcomeCallable DisassociateConnectorCallable(const DisassociateConnectorRequestT& request) const
        {
            return SubmitCallable(&SMSClient::DisassociateConnector, request);
        }
 
        template<typename DisassociateConnectorRequestT = Model::DisassociateConnectorRequest>
        void DisassociateConnectorAsync(const DisassociateConnectorRequestT& request, const DisassociateConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SMSClient::DisassociateConnector, request, handler, context);
        }
 
        virtual Model::GenerateChangeSetOutcome GenerateChangeSet(const Model::GenerateChangeSetRequest& request = {}) const;
 
        template<typename GenerateChangeSetRequestT = Model::GenerateChangeSetRequest>
        Model::GenerateChangeSetOutcomeCallable GenerateChangeSetCallable(const GenerateChangeSetRequestT& request = {}) const
        {
            return SubmitCallable(&SMSClient::GenerateChangeSet, request);
        }
 
        template<typename GenerateChangeSetRequestT = Model::GenerateChangeSetRequest>
        void GenerateChangeSetAsync(const GenerateChangeSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GenerateChangeSetRequestT& request = {}) const
        {
            return SubmitAsync(&SMSClient::GenerateChangeSet, request, handler, context);
        }
 
        virtual Model::GenerateTemplateOutcome GenerateTemplate(const Model::GenerateTemplateRequest& request = {}) const;
 
        template<typename GenerateTemplateRequestT = Model::GenerateTemplateRequest>
        Model::GenerateTemplateOutcomeCallable GenerateTemplateCallable(const GenerateTemplateRequestT& request = {}) const
        {
            return SubmitCallable(&SMSClient::GenerateTemplate, request);
        }
 
        template<typename GenerateTemplateRequestT = Model::GenerateTemplateRequest>
        void GenerateTemplateAsync(const GenerateTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GenerateTemplateRequestT& request = {}) const
        {
            return SubmitAsync(&SMSClient::GenerateTemplate, request, handler, context);
        }
 
        virtual Model::GetAppOutcome GetApp(const Model::GetAppRequest& request = {}) const;
 
        template<typename GetAppRequestT = Model::GetAppRequest>
        Model::GetAppOutcomeCallable GetAppCallable(const GetAppRequestT& request = {}) const
        {
            return SubmitCallable(&SMSClient::GetApp, request);
        }
 
        template<typename GetAppRequestT = Model::GetAppRequest>
        void GetAppAsync(const GetAppResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetAppRequestT& request = {}) const
        {
            return SubmitAsync(&SMSClient::GetApp, request, handler, context);
        }
 
        virtual Model::GetAppLaunchConfigurationOutcome GetAppLaunchConfiguration(const Model::GetAppLaunchConfigurationRequest& request = {}) const;
 
        template<typename GetAppLaunchConfigurationRequestT = Model::GetAppLaunchConfigurationRequest>
        Model::GetAppLaunchConfigurationOutcomeCallable GetAppLaunchConfigurationCallable(const GetAppLaunchConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&SMSClient::GetAppLaunchConfiguration, request);
        }
 
        template<typename GetAppLaunchConfigurationRequestT = Model::GetAppLaunchConfigurationRequest>
        void GetAppLaunchConfigurationAsync(const GetAppLaunchConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetAppLaunchConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&SMSClient::GetAppLaunchConfiguration, request, handler, context);
        }
 
        virtual Model::GetAppReplicationConfigurationOutcome GetAppReplicationConfiguration(const Model::GetAppReplicationConfigurationRequest& request = {}) const;
 
        template<typename GetAppReplicationConfigurationRequestT = Model::GetAppReplicationConfigurationRequest>
        Model::GetAppReplicationConfigurationOutcomeCallable GetAppReplicationConfigurationCallable(const GetAppReplicationConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&SMSClient::GetAppReplicationConfiguration, request);
        }
 
        template<typename GetAppReplicationConfigurationRequestT = Model::GetAppReplicationConfigurationRequest>
        void GetAppReplicationConfigurationAsync(const GetAppReplicationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetAppReplicationConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&SMSClient::GetAppReplicationConfiguration, request, handler, context);
        }
 
        virtual Model::GetAppValidationConfigurationOutcome GetAppValidationConfiguration(const Model::GetAppValidationConfigurationRequest& request) const;
 
        template<typename GetAppValidationConfigurationRequestT = Model::GetAppValidationConfigurationRequest>
        Model::GetAppValidationConfigurationOutcomeCallable GetAppValidationConfigurationCallable(const GetAppValidationConfigurationRequestT& request) const
        {
            return SubmitCallable(&SMSClient::GetAppValidationConfiguration, request);
        }
 
        template<typename GetAppValidationConfigurationRequestT = Model::GetAppValidationConfigurationRequest>
        void GetAppValidationConfigurationAsync(const GetAppValidationConfigurationRequestT& request, const GetAppValidationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SMSClient::GetAppValidationConfiguration, request, handler, context);
        }
 
        virtual Model::GetAppValidationOutputOutcome GetAppValidationOutput(const Model::GetAppValidationOutputRequest& request) const;
 
        template<typename GetAppValidationOutputRequestT = Model::GetAppValidationOutputRequest>
        Model::GetAppValidationOutputOutcomeCallable GetAppValidationOutputCallable(const GetAppValidationOutputRequestT& request) const
        {
            return SubmitCallable(&SMSClient::GetAppValidationOutput, request);
        }
 
        template<typename GetAppValidationOutputRequestT = Model::GetAppValidationOutputRequest>
        void GetAppValidationOutputAsync(const GetAppValidationOutputRequestT& request, const GetAppValidationOutputResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SMSClient::GetAppValidationOutput, request, handler, context);
        }
 
        virtual Model::GetConnectorsOutcome GetConnectors(const Model::GetConnectorsRequest& request = {}) const;
 
        template<typename GetConnectorsRequestT = Model::GetConnectorsRequest>
        Model::GetConnectorsOutcomeCallable GetConnectorsCallable(const GetConnectorsRequestT& request = {}) const
        {
            return SubmitCallable(&SMSClient::GetConnectors, request);
        }
 
        template<typename GetConnectorsRequestT = Model::GetConnectorsRequest>
        void GetConnectorsAsync(const GetConnectorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetConnectorsRequestT& request = {}) const
        {
            return SubmitAsync(&SMSClient::GetConnectors, request, handler, context);
        }
 
        virtual Model::GetReplicationJobsOutcome GetReplicationJobs(const Model::GetReplicationJobsRequest& request = {}) const;
 
        template<typename GetReplicationJobsRequestT = Model::GetReplicationJobsRequest>
        Model::GetReplicationJobsOutcomeCallable GetReplicationJobsCallable(const GetReplicationJobsRequestT& request = {}) const
        {
            return SubmitCallable(&SMSClient::GetReplicationJobs, request);
        }
 
        template<typename GetReplicationJobsRequestT = Model::GetReplicationJobsRequest>
        void GetReplicationJobsAsync(const GetReplicationJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetReplicationJobsRequestT& request = {}) const
        {
            return SubmitAsync(&SMSClient::GetReplicationJobs, request, handler, context);
        }
 
        virtual Model::GetReplicationRunsOutcome GetReplicationRuns(const Model::GetReplicationRunsRequest& request) const;
 
        template<typename GetReplicationRunsRequestT = Model::GetReplicationRunsRequest>
        Model::GetReplicationRunsOutcomeCallable GetReplicationRunsCallable(const GetReplicationRunsRequestT& request) const
        {
            return SubmitCallable(&SMSClient::GetReplicationRuns, request);
        }
 
        template<typename GetReplicationRunsRequestT = Model::GetReplicationRunsRequest>
        void GetReplicationRunsAsync(const GetReplicationRunsRequestT& request, const GetReplicationRunsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SMSClient::GetReplicationRuns, request, handler, context);
        }
 
        virtual Model::GetServersOutcome GetServers(const Model::GetServersRequest& request = {}) const;
 
        template<typename GetServersRequestT = Model::GetServersRequest>
        Model::GetServersOutcomeCallable GetServersCallable(const GetServersRequestT& request = {}) const
        {
            return SubmitCallable(&SMSClient::GetServers, request);
        }
 
        template<typename GetServersRequestT = Model::GetServersRequest>
        void GetServersAsync(const GetServersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetServersRequestT& request = {}) const
        {
            return SubmitAsync(&SMSClient::GetServers, request, handler, context);
        }
 
        virtual Model::ImportAppCatalogOutcome ImportAppCatalog(const Model::ImportAppCatalogRequest& request = {}) const;
 
        template<typename ImportAppCatalogRequestT = Model::ImportAppCatalogRequest>
        Model::ImportAppCatalogOutcomeCallable ImportAppCatalogCallable(const ImportAppCatalogRequestT& request = {}) const
        {
            return SubmitCallable(&SMSClient::ImportAppCatalog, request);
        }
 
        template<typename ImportAppCatalogRequestT = Model::ImportAppCatalogRequest>
        void ImportAppCatalogAsync(const ImportAppCatalogResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ImportAppCatalogRequestT& request = {}) const
        {
            return SubmitAsync(&SMSClient::ImportAppCatalog, request, handler, context);
        }
 
        virtual Model::ImportServerCatalogOutcome ImportServerCatalog(const Model::ImportServerCatalogRequest& request = {}) const;
 
        template<typename ImportServerCatalogRequestT = Model::ImportServerCatalogRequest>
        Model::ImportServerCatalogOutcomeCallable ImportServerCatalogCallable(const ImportServerCatalogRequestT& request = {}) const
        {
            return SubmitCallable(&SMSClient::ImportServerCatalog, request);
        }
 
        template<typename ImportServerCatalogRequestT = Model::ImportServerCatalogRequest>
        void ImportServerCatalogAsync(const ImportServerCatalogResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ImportServerCatalogRequestT& request = {}) const
        {
            return SubmitAsync(&SMSClient::ImportServerCatalog, request, handler, context);
        }
 
        virtual Model::LaunchAppOutcome LaunchApp(const Model::LaunchAppRequest& request = {}) const;
 
        template<typename LaunchAppRequestT = Model::LaunchAppRequest>
        Model::LaunchAppOutcomeCallable LaunchAppCallable(const LaunchAppRequestT& request = {}) const
        {
            return SubmitCallable(&SMSClient::LaunchApp, request);
        }
 
        template<typename LaunchAppRequestT = Model::LaunchAppRequest>
        void LaunchAppAsync(const LaunchAppResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const LaunchAppRequestT& request = {}) const
        {
            return SubmitAsync(&SMSClient::LaunchApp, request, handler, context);
        }
 
        virtual Model::ListAppsOutcome ListApps(const Model::ListAppsRequest& request = {}) const;
 
        template<typename ListAppsRequestT = Model::ListAppsRequest>
        Model::ListAppsOutcomeCallable ListAppsCallable(const ListAppsRequestT& request = {}) const
        {
            return SubmitCallable(&SMSClient::ListApps, request);
        }
 
        template<typename ListAppsRequestT = Model::ListAppsRequest>
        void ListAppsAsync(const ListAppsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAppsRequestT& request = {}) const
        {
            return SubmitAsync(&SMSClient::ListApps, request, handler, context);
        }
 
        virtual Model::NotifyAppValidationOutputOutcome NotifyAppValidationOutput(const Model::NotifyAppValidationOutputRequest& request) const;
 
        template<typename NotifyAppValidationOutputRequestT = Model::NotifyAppValidationOutputRequest>
        Model::NotifyAppValidationOutputOutcomeCallable NotifyAppValidationOutputCallable(const NotifyAppValidationOutputRequestT& request) const
        {
            return SubmitCallable(&SMSClient::NotifyAppValidationOutput, request);
        }
 
        template<typename NotifyAppValidationOutputRequestT = Model::NotifyAppValidationOutputRequest>
        void NotifyAppValidationOutputAsync(const NotifyAppValidationOutputRequestT& request, const NotifyAppValidationOutputResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SMSClient::NotifyAppValidationOutput, request, handler, context);
        }
 
        virtual Model::PutAppLaunchConfigurationOutcome PutAppLaunchConfiguration(const Model::PutAppLaunchConfigurationRequest& request = {}) const;
 
        template<typename PutAppLaunchConfigurationRequestT = Model::PutAppLaunchConfigurationRequest>
        Model::PutAppLaunchConfigurationOutcomeCallable PutAppLaunchConfigurationCallable(const PutAppLaunchConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&SMSClient::PutAppLaunchConfiguration, request);
        }
 
        template<typename PutAppLaunchConfigurationRequestT = Model::PutAppLaunchConfigurationRequest>
        void PutAppLaunchConfigurationAsync(const PutAppLaunchConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const PutAppLaunchConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&SMSClient::PutAppLaunchConfiguration, request, handler, context);
        }
 
        virtual Model::PutAppReplicationConfigurationOutcome PutAppReplicationConfiguration(const Model::PutAppReplicationConfigurationRequest& request = {}) const;
 
        template<typename PutAppReplicationConfigurationRequestT = Model::PutAppReplicationConfigurationRequest>
        Model::PutAppReplicationConfigurationOutcomeCallable PutAppReplicationConfigurationCallable(const PutAppReplicationConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&SMSClient::PutAppReplicationConfiguration, request);
        }
 
        template<typename PutAppReplicationConfigurationRequestT = Model::PutAppReplicationConfigurationRequest>
        void PutAppReplicationConfigurationAsync(const PutAppReplicationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const PutAppReplicationConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&SMSClient::PutAppReplicationConfiguration, request, handler, context);
        }
 
        virtual Model::PutAppValidationConfigurationOutcome PutAppValidationConfiguration(const Model::PutAppValidationConfigurationRequest& request) const;
 
        template<typename PutAppValidationConfigurationRequestT = Model::PutAppValidationConfigurationRequest>
        Model::PutAppValidationConfigurationOutcomeCallable PutAppValidationConfigurationCallable(const PutAppValidationConfigurationRequestT& request) const
        {
            return SubmitCallable(&SMSClient::PutAppValidationConfiguration, request);
        }
 
        template<typename PutAppValidationConfigurationRequestT = Model::PutAppValidationConfigurationRequest>
        void PutAppValidationConfigurationAsync(const PutAppValidationConfigurationRequestT& request, const PutAppValidationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SMSClient::PutAppValidationConfiguration, request, handler, context);
        }
 
        virtual Model::StartAppReplicationOutcome StartAppReplication(const Model::StartAppReplicationRequest& request = {}) const;
 
        template<typename StartAppReplicationRequestT = Model::StartAppReplicationRequest>
        Model::StartAppReplicationOutcomeCallable StartAppReplicationCallable(const StartAppReplicationRequestT& request = {}) const
        {
            return SubmitCallable(&SMSClient::StartAppReplication, request);
        }
 
        template<typename StartAppReplicationRequestT = Model::StartAppReplicationRequest>
        void StartAppReplicationAsync(const StartAppReplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const StartAppReplicationRequestT& request = {}) const
        {
            return SubmitAsync(&SMSClient::StartAppReplication, request, handler, context);
        }
 
        virtual Model::StartOnDemandAppReplicationOutcome StartOnDemandAppReplication(const Model::StartOnDemandAppReplicationRequest& request) const;
 
        template<typename StartOnDemandAppReplicationRequestT = Model::StartOnDemandAppReplicationRequest>
        Model::StartOnDemandAppReplicationOutcomeCallable StartOnDemandAppReplicationCallable(const StartOnDemandAppReplicationRequestT& request) const
        {
            return SubmitCallable(&SMSClient::StartOnDemandAppReplication, request);
        }
 
        template<typename StartOnDemandAppReplicationRequestT = Model::StartOnDemandAppReplicationRequest>
        void StartOnDemandAppReplicationAsync(const StartOnDemandAppReplicationRequestT& request, const StartOnDemandAppReplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SMSClient::StartOnDemandAppReplication, request, handler, context);
        }
 
        virtual Model::StartOnDemandReplicationRunOutcome StartOnDemandReplicationRun(const Model::StartOnDemandReplicationRunRequest& request) const;
 
        template<typename StartOnDemandReplicationRunRequestT = Model::StartOnDemandReplicationRunRequest>
        Model::StartOnDemandReplicationRunOutcomeCallable StartOnDemandReplicationRunCallable(const StartOnDemandReplicationRunRequestT& request) const
        {
            return SubmitCallable(&SMSClient::StartOnDemandReplicationRun, request);
        }
 
        template<typename StartOnDemandReplicationRunRequestT = Model::StartOnDemandReplicationRunRequest>
        void StartOnDemandReplicationRunAsync(const StartOnDemandReplicationRunRequestT& request, const StartOnDemandReplicationRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SMSClient::StartOnDemandReplicationRun, request, handler, context);
        }
 
        virtual Model::StopAppReplicationOutcome StopAppReplication(const Model::StopAppReplicationRequest& request = {}) const;
 
        template<typename StopAppReplicationRequestT = Model::StopAppReplicationRequest>
        Model::StopAppReplicationOutcomeCallable StopAppReplicationCallable(const StopAppReplicationRequestT& request = {}) const
        {
            return SubmitCallable(&SMSClient::StopAppReplication, request);
        }
 
        template<typename StopAppReplicationRequestT = Model::StopAppReplicationRequest>
        void StopAppReplicationAsync(const StopAppReplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const StopAppReplicationRequestT& request = {}) const
        {
            return SubmitAsync(&SMSClient::StopAppReplication, request, handler, context);
        }
 
        virtual Model::TerminateAppOutcome TerminateApp(const Model::TerminateAppRequest& request = {}) const;
 
        template<typename TerminateAppRequestT = Model::TerminateAppRequest>
        Model::TerminateAppOutcomeCallable TerminateAppCallable(const TerminateAppRequestT& request = {}) const
        {
            return SubmitCallable(&SMSClient::TerminateApp, request);
        }
 
        template<typename TerminateAppRequestT = Model::TerminateAppRequest>
        void TerminateAppAsync(const TerminateAppResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const TerminateAppRequestT& request = {}) const
        {
            return SubmitAsync(&SMSClient::TerminateApp, request, handler, context);
        }
 
        virtual Model::UpdateAppOutcome UpdateApp(const Model::UpdateAppRequest& request = {}) const;
 
        template<typename UpdateAppRequestT = Model::UpdateAppRequest>
        Model::UpdateAppOutcomeCallable UpdateAppCallable(const UpdateAppRequestT& request = {}) const
        {
            return SubmitCallable(&SMSClient::UpdateApp, request);
        }
 
        template<typename UpdateAppRequestT = Model::UpdateAppRequest>
        void UpdateAppAsync(const UpdateAppResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateAppRequestT& request = {}) const
        {
            return SubmitAsync(&SMSClient::UpdateApp, request, handler, context);
        }
 
        virtual Model::UpdateReplicationJobOutcome UpdateReplicationJob(const Model::UpdateReplicationJobRequest& request) const;
 
        template<typename UpdateReplicationJobRequestT = Model::UpdateReplicationJobRequest>
        Model::UpdateReplicationJobOutcomeCallable UpdateReplicationJobCallable(const UpdateReplicationJobRequestT& request) const
        {
            return SubmitCallable(&SMSClient::UpdateReplicationJob, request);
        }
 
        template<typename UpdateReplicationJobRequestT = Model::UpdateReplicationJobRequest>
        void UpdateReplicationJobAsync(const UpdateReplicationJobRequestT& request, const UpdateReplicationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SMSClient::UpdateReplicationJob, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<SMSEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<SMSClient>;
      void init(const SMSClientConfiguration& clientConfiguration);
 
      SMSClientConfiguration m_clientConfiguration;
      std::shared_ptr<SMSEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace SMS
} // namespace Aws