SsmSapClient.h

 
#pragma once
#include <aws/ssm-sap/SsmSap_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/ssm-sap/SsmSapServiceClientModel.h>
 
namespace Aws
{
namespace SsmSap
{
  class AWS_SSMSAP_API SsmSapClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<SsmSapClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef SsmSapClientConfiguration ClientConfigurationType;
      typedef SsmSapEndpointProvider EndpointProviderType;
 
        SsmSapClient(const Aws::SsmSap::SsmSapClientConfiguration& clientConfiguration = Aws::SsmSap::SsmSapClientConfiguration(),
                     std::shared_ptr<SsmSapEndpointProviderBase> endpointProvider = nullptr);
 
        SsmSapClient(const Aws::Auth::AWSCredentials& credentials,
                     std::shared_ptr<SsmSapEndpointProviderBase> endpointProvider = nullptr,
                     const Aws::SsmSap::SsmSapClientConfiguration& clientConfiguration = Aws::SsmSap::SsmSapClientConfiguration());
 
        SsmSapClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     std::shared_ptr<SsmSapEndpointProviderBase> endpointProvider = nullptr,
                     const Aws::SsmSap::SsmSapClientConfiguration& clientConfiguration = Aws::SsmSap::SsmSapClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        SsmSapClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SsmSapClient(const Aws::Auth::AWSCredentials& credentials,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SsmSapClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~SsmSapClient();
 
        virtual Model::DeleteResourcePermissionOutcome DeleteResourcePermission(const Model::DeleteResourcePermissionRequest& request) const;
 
        template<typename DeleteResourcePermissionRequestT = Model::DeleteResourcePermissionRequest>
        Model::DeleteResourcePermissionOutcomeCallable DeleteResourcePermissionCallable(const DeleteResourcePermissionRequestT& request) const
        {
            return SubmitCallable(&SsmSapClient::DeleteResourcePermission, request);
        }
 
        template<typename DeleteResourcePermissionRequestT = Model::DeleteResourcePermissionRequest>
        void DeleteResourcePermissionAsync(const DeleteResourcePermissionRequestT& request, const DeleteResourcePermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SsmSapClient::DeleteResourcePermission, request, handler, context);
        }
 
        virtual Model::DeregisterApplicationOutcome DeregisterApplication(const Model::DeregisterApplicationRequest& request) const;
 
        template<typename DeregisterApplicationRequestT = Model::DeregisterApplicationRequest>
        Model::DeregisterApplicationOutcomeCallable DeregisterApplicationCallable(const DeregisterApplicationRequestT& request) const
        {
            return SubmitCallable(&SsmSapClient::DeregisterApplication, request);
        }
 
        template<typename DeregisterApplicationRequestT = Model::DeregisterApplicationRequest>
        void DeregisterApplicationAsync(const DeregisterApplicationRequestT& request, const DeregisterApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SsmSapClient::DeregisterApplication, request, handler, context);
        }
 
        virtual Model::GetApplicationOutcome GetApplication(const Model::GetApplicationRequest& request = {}) const;
 
        template<typename GetApplicationRequestT = Model::GetApplicationRequest>
        Model::GetApplicationOutcomeCallable GetApplicationCallable(const GetApplicationRequestT& request = {}) const
        {
            return SubmitCallable(&SsmSapClient::GetApplication, request);
        }
 
        template<typename GetApplicationRequestT = Model::GetApplicationRequest>
        void GetApplicationAsync(const GetApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetApplicationRequestT& request = {}) const
        {
            return SubmitAsync(&SsmSapClient::GetApplication, request, handler, context);
        }
 
        virtual Model::GetComponentOutcome GetComponent(const Model::GetComponentRequest& request) const;
 
        template<typename GetComponentRequestT = Model::GetComponentRequest>
        Model::GetComponentOutcomeCallable GetComponentCallable(const GetComponentRequestT& request) const
        {
            return SubmitCallable(&SsmSapClient::GetComponent, request);
        }
 
        template<typename GetComponentRequestT = Model::GetComponentRequest>
        void GetComponentAsync(const GetComponentRequestT& request, const GetComponentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SsmSapClient::GetComponent, request, handler, context);
        }
 
        virtual Model::GetConfigurationCheckOperationOutcome GetConfigurationCheckOperation(const Model::GetConfigurationCheckOperationRequest& request) const;
 
        template<typename GetConfigurationCheckOperationRequestT = Model::GetConfigurationCheckOperationRequest>
        Model::GetConfigurationCheckOperationOutcomeCallable GetConfigurationCheckOperationCallable(const GetConfigurationCheckOperationRequestT& request) const
        {
            return SubmitCallable(&SsmSapClient::GetConfigurationCheckOperation, request);
        }
 
        template<typename GetConfigurationCheckOperationRequestT = Model::GetConfigurationCheckOperationRequest>
        void GetConfigurationCheckOperationAsync(const GetConfigurationCheckOperationRequestT& request, const GetConfigurationCheckOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SsmSapClient::GetConfigurationCheckOperation, request, handler, context);
        }
 
        virtual Model::GetDatabaseOutcome GetDatabase(const Model::GetDatabaseRequest& request = {}) const;
 
        template<typename GetDatabaseRequestT = Model::GetDatabaseRequest>
        Model::GetDatabaseOutcomeCallable GetDatabaseCallable(const GetDatabaseRequestT& request = {}) const
        {
            return SubmitCallable(&SsmSapClient::GetDatabase, request);
        }
 
        template<typename GetDatabaseRequestT = Model::GetDatabaseRequest>
        void GetDatabaseAsync(const GetDatabaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetDatabaseRequestT& request = {}) const
        {
            return SubmitAsync(&SsmSapClient::GetDatabase, request, handler, context);
        }
 
        virtual Model::GetOperationOutcome GetOperation(const Model::GetOperationRequest& request) const;
 
        template<typename GetOperationRequestT = Model::GetOperationRequest>
        Model::GetOperationOutcomeCallable GetOperationCallable(const GetOperationRequestT& request) const
        {
            return SubmitCallable(&SsmSapClient::GetOperation, request);
        }
 
        template<typename GetOperationRequestT = Model::GetOperationRequest>
        void GetOperationAsync(const GetOperationRequestT& request, const GetOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SsmSapClient::GetOperation, request, handler, context);
        }
 
        virtual Model::GetResourcePermissionOutcome GetResourcePermission(const Model::GetResourcePermissionRequest& request) const;
 
        template<typename GetResourcePermissionRequestT = Model::GetResourcePermissionRequest>
        Model::GetResourcePermissionOutcomeCallable GetResourcePermissionCallable(const GetResourcePermissionRequestT& request) const
        {
            return SubmitCallable(&SsmSapClient::GetResourcePermission, request);
        }
 
        template<typename GetResourcePermissionRequestT = Model::GetResourcePermissionRequest>
        void GetResourcePermissionAsync(const GetResourcePermissionRequestT& request, const GetResourcePermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SsmSapClient::GetResourcePermission, request, handler, context);
        }
 
        virtual Model::ListApplicationsOutcome ListApplications(const Model::ListApplicationsRequest& request = {}) const;
 
        template<typename ListApplicationsRequestT = Model::ListApplicationsRequest>
        Model::ListApplicationsOutcomeCallable ListApplicationsCallable(const ListApplicationsRequestT& request = {}) const
        {
            return SubmitCallable(&SsmSapClient::ListApplications, request);
        }
 
        template<typename ListApplicationsRequestT = Model::ListApplicationsRequest>
        void ListApplicationsAsync(const ListApplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListApplicationsRequestT& request = {}) const
        {
            return SubmitAsync(&SsmSapClient::ListApplications, request, handler, context);
        }
 
        virtual Model::ListComponentsOutcome ListComponents(const Model::ListComponentsRequest& request = {}) const;
 
        template<typename ListComponentsRequestT = Model::ListComponentsRequest>
        Model::ListComponentsOutcomeCallable ListComponentsCallable(const ListComponentsRequestT& request = {}) const
        {
            return SubmitCallable(&SsmSapClient::ListComponents, request);
        }
 
        template<typename ListComponentsRequestT = Model::ListComponentsRequest>
        void ListComponentsAsync(const ListComponentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListComponentsRequestT& request = {}) const
        {
            return SubmitAsync(&SsmSapClient::ListComponents, request, handler, context);
        }
 
        virtual Model::ListConfigurationCheckDefinitionsOutcome ListConfigurationCheckDefinitions(const Model::ListConfigurationCheckDefinitionsRequest& request = {}) const;
 
        template<typename ListConfigurationCheckDefinitionsRequestT = Model::ListConfigurationCheckDefinitionsRequest>
        Model::ListConfigurationCheckDefinitionsOutcomeCallable ListConfigurationCheckDefinitionsCallable(const ListConfigurationCheckDefinitionsRequestT& request = {}) const
        {
            return SubmitCallable(&SsmSapClient::ListConfigurationCheckDefinitions, request);
        }
 
        template<typename ListConfigurationCheckDefinitionsRequestT = Model::ListConfigurationCheckDefinitionsRequest>
        void ListConfigurationCheckDefinitionsAsync(const ListConfigurationCheckDefinitionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListConfigurationCheckDefinitionsRequestT& request = {}) const
        {
            return SubmitAsync(&SsmSapClient::ListConfigurationCheckDefinitions, request, handler, context);
        }
 
        virtual Model::ListConfigurationCheckOperationsOutcome ListConfigurationCheckOperations(const Model::ListConfigurationCheckOperationsRequest& request) const;
 
        template<typename ListConfigurationCheckOperationsRequestT = Model::ListConfigurationCheckOperationsRequest>
        Model::ListConfigurationCheckOperationsOutcomeCallable ListConfigurationCheckOperationsCallable(const ListConfigurationCheckOperationsRequestT& request) const
        {
            return SubmitCallable(&SsmSapClient::ListConfigurationCheckOperations, request);
        }
 
        template<typename ListConfigurationCheckOperationsRequestT = Model::ListConfigurationCheckOperationsRequest>
        void ListConfigurationCheckOperationsAsync(const ListConfigurationCheckOperationsRequestT& request, const ListConfigurationCheckOperationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SsmSapClient::ListConfigurationCheckOperations, request, handler, context);
        }
 
        virtual Model::ListDatabasesOutcome ListDatabases(const Model::ListDatabasesRequest& request = {}) const;
 
        template<typename ListDatabasesRequestT = Model::ListDatabasesRequest>
        Model::ListDatabasesOutcomeCallable ListDatabasesCallable(const ListDatabasesRequestT& request = {}) const
        {
            return SubmitCallable(&SsmSapClient::ListDatabases, request);
        }
 
        template<typename ListDatabasesRequestT = Model::ListDatabasesRequest>
        void ListDatabasesAsync(const ListDatabasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDatabasesRequestT& request = {}) const
        {
            return SubmitAsync(&SsmSapClient::ListDatabases, request, handler, context);
        }
 
        virtual Model::ListOperationEventsOutcome ListOperationEvents(const Model::ListOperationEventsRequest& request) const;
 
        template<typename ListOperationEventsRequestT = Model::ListOperationEventsRequest>
        Model::ListOperationEventsOutcomeCallable ListOperationEventsCallable(const ListOperationEventsRequestT& request) const
        {
            return SubmitCallable(&SsmSapClient::ListOperationEvents, request);
        }
 
        template<typename ListOperationEventsRequestT = Model::ListOperationEventsRequest>
        void ListOperationEventsAsync(const ListOperationEventsRequestT& request, const ListOperationEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SsmSapClient::ListOperationEvents, request, handler, context);
        }
 
        virtual Model::ListOperationsOutcome ListOperations(const Model::ListOperationsRequest& request) const;
 
        template<typename ListOperationsRequestT = Model::ListOperationsRequest>
        Model::ListOperationsOutcomeCallable ListOperationsCallable(const ListOperationsRequestT& request) const
        {
            return SubmitCallable(&SsmSapClient::ListOperations, request);
        }
 
        template<typename ListOperationsRequestT = Model::ListOperationsRequest>
        void ListOperationsAsync(const ListOperationsRequestT& request, const ListOperationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SsmSapClient::ListOperations, request, handler, context);
        }
 
        virtual Model::ListSubCheckResultsOutcome ListSubCheckResults(const Model::ListSubCheckResultsRequest& request) const;
 
        template<typename ListSubCheckResultsRequestT = Model::ListSubCheckResultsRequest>
        Model::ListSubCheckResultsOutcomeCallable ListSubCheckResultsCallable(const ListSubCheckResultsRequestT& request) const
        {
            return SubmitCallable(&SsmSapClient::ListSubCheckResults, request);
        }
 
        template<typename ListSubCheckResultsRequestT = Model::ListSubCheckResultsRequest>
        void ListSubCheckResultsAsync(const ListSubCheckResultsRequestT& request, const ListSubCheckResultsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SsmSapClient::ListSubCheckResults, request, handler, context);
        }
 
        virtual Model::ListSubCheckRuleResultsOutcome ListSubCheckRuleResults(const Model::ListSubCheckRuleResultsRequest& request) const;
 
        template<typename ListSubCheckRuleResultsRequestT = Model::ListSubCheckRuleResultsRequest>
        Model::ListSubCheckRuleResultsOutcomeCallable ListSubCheckRuleResultsCallable(const ListSubCheckRuleResultsRequestT& request) const
        {
            return SubmitCallable(&SsmSapClient::ListSubCheckRuleResults, request);
        }
 
        template<typename ListSubCheckRuleResultsRequestT = Model::ListSubCheckRuleResultsRequest>
        void ListSubCheckRuleResultsAsync(const ListSubCheckRuleResultsRequestT& request, const ListSubCheckRuleResultsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SsmSapClient::ListSubCheckRuleResults, 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(&SsmSapClient::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(&SsmSapClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutResourcePermissionOutcome PutResourcePermission(const Model::PutResourcePermissionRequest& request) const;
 
        template<typename PutResourcePermissionRequestT = Model::PutResourcePermissionRequest>
        Model::PutResourcePermissionOutcomeCallable PutResourcePermissionCallable(const PutResourcePermissionRequestT& request) const
        {
            return SubmitCallable(&SsmSapClient::PutResourcePermission, request);
        }
 
        template<typename PutResourcePermissionRequestT = Model::PutResourcePermissionRequest>
        void PutResourcePermissionAsync(const PutResourcePermissionRequestT& request, const PutResourcePermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SsmSapClient::PutResourcePermission, request, handler, context);
        }
 
        virtual Model::RegisterApplicationOutcome RegisterApplication(const Model::RegisterApplicationRequest& request) const;
 
        template<typename RegisterApplicationRequestT = Model::RegisterApplicationRequest>
        Model::RegisterApplicationOutcomeCallable RegisterApplicationCallable(const RegisterApplicationRequestT& request) const
        {
            return SubmitCallable(&SsmSapClient::RegisterApplication, request);
        }
 
        template<typename RegisterApplicationRequestT = Model::RegisterApplicationRequest>
        void RegisterApplicationAsync(const RegisterApplicationRequestT& request, const RegisterApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SsmSapClient::RegisterApplication, request, handler, context);
        }
 
        virtual Model::StartApplicationOutcome StartApplication(const Model::StartApplicationRequest& request) const;
 
        template<typename StartApplicationRequestT = Model::StartApplicationRequest>
        Model::StartApplicationOutcomeCallable StartApplicationCallable(const StartApplicationRequestT& request) const
        {
            return SubmitCallable(&SsmSapClient::StartApplication, request);
        }
 
        template<typename StartApplicationRequestT = Model::StartApplicationRequest>
        void StartApplicationAsync(const StartApplicationRequestT& request, const StartApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SsmSapClient::StartApplication, request, handler, context);
        }
 
        virtual Model::StartApplicationRefreshOutcome StartApplicationRefresh(const Model::StartApplicationRefreshRequest& request) const;
 
        template<typename StartApplicationRefreshRequestT = Model::StartApplicationRefreshRequest>
        Model::StartApplicationRefreshOutcomeCallable StartApplicationRefreshCallable(const StartApplicationRefreshRequestT& request) const
        {
            return SubmitCallable(&SsmSapClient::StartApplicationRefresh, request);
        }
 
        template<typename StartApplicationRefreshRequestT = Model::StartApplicationRefreshRequest>
        void StartApplicationRefreshAsync(const StartApplicationRefreshRequestT& request, const StartApplicationRefreshResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SsmSapClient::StartApplicationRefresh, request, handler, context);
        }
 
        virtual Model::StartConfigurationChecksOutcome StartConfigurationChecks(const Model::StartConfigurationChecksRequest& request) const;
 
        template<typename StartConfigurationChecksRequestT = Model::StartConfigurationChecksRequest>
        Model::StartConfigurationChecksOutcomeCallable StartConfigurationChecksCallable(const StartConfigurationChecksRequestT& request) const
        {
            return SubmitCallable(&SsmSapClient::StartConfigurationChecks, request);
        }
 
        template<typename StartConfigurationChecksRequestT = Model::StartConfigurationChecksRequest>
        void StartConfigurationChecksAsync(const StartConfigurationChecksRequestT& request, const StartConfigurationChecksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SsmSapClient::StartConfigurationChecks, request, handler, context);
        }
 
        virtual Model::StopApplicationOutcome StopApplication(const Model::StopApplicationRequest& request) const;
 
        template<typename StopApplicationRequestT = Model::StopApplicationRequest>
        Model::StopApplicationOutcomeCallable StopApplicationCallable(const StopApplicationRequestT& request) const
        {
            return SubmitCallable(&SsmSapClient::StopApplication, request);
        }
 
        template<typename StopApplicationRequestT = Model::StopApplicationRequest>
        void StopApplicationAsync(const StopApplicationRequestT& request, const StopApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SsmSapClient::StopApplication, 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(&SsmSapClient::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(&SsmSapClient::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(&SsmSapClient::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(&SsmSapClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateApplicationSettingsOutcome UpdateApplicationSettings(const Model::UpdateApplicationSettingsRequest& request) const;
 
        template<typename UpdateApplicationSettingsRequestT = Model::UpdateApplicationSettingsRequest>
        Model::UpdateApplicationSettingsOutcomeCallable UpdateApplicationSettingsCallable(const UpdateApplicationSettingsRequestT& request) const
        {
            return SubmitCallable(&SsmSapClient::UpdateApplicationSettings, request);
        }
 
        template<typename UpdateApplicationSettingsRequestT = Model::UpdateApplicationSettingsRequest>
        void UpdateApplicationSettingsAsync(const UpdateApplicationSettingsRequestT& request, const UpdateApplicationSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SsmSapClient::UpdateApplicationSettings, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<SsmSapEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<SsmSapClient>;
      void init(const SsmSapClientConfiguration& clientConfiguration);
 
      SsmSapClientConfiguration m_clientConfiguration;
      std::shared_ptr<SsmSapEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace SsmSap
} // namespace Aws