SsmSapClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/ssm-sap/SsmSapServiceClientModel.h>
#include <aws/ssm-sap/SsmSap_EXPORTS.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