AutoScalingClient.h

 
#pragma once
#include <aws/autoscaling/AutoScalingPaginationBase.h>
#include <aws/autoscaling/AutoScalingServiceClientModel.h>
#include <aws/autoscaling/AutoScalingWaiter.h>
#include <aws/autoscaling/AutoScaling_EXPORTS.h>
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/xml/XmlSerializer.h>
 
namespace Aws {
namespace AutoScaling {
class AWS_AUTOSCALING_API AutoScalingClient : public Aws::Client::AWSXMLClient,
                                              public Aws::Client::ClientWithAsyncTemplateMethods<AutoScalingClient>,
                                              public AutoScalingPaginationBase<AutoScalingClient>,
                                              public AutoScalingWaiter<AutoScalingClient> {
 public:
  typedef Aws::Client::AWSXMLClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef AutoScalingClientConfiguration ClientConfigurationType;
  typedef AutoScalingEndpointProvider EndpointProviderType;
 
  AutoScalingClient(
      const Aws::AutoScaling::AutoScalingClientConfiguration& clientConfiguration = Aws::AutoScaling::AutoScalingClientConfiguration(),
      std::shared_ptr<AutoScalingEndpointProviderBase> endpointProvider = nullptr);
 
  AutoScalingClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<AutoScalingEndpointProviderBase> endpointProvider = nullptr,
      const Aws::AutoScaling::AutoScalingClientConfiguration& clientConfiguration = Aws::AutoScaling::AutoScalingClientConfiguration());
 
  AutoScalingClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<AutoScalingEndpointProviderBase> endpointProvider = nullptr,
      const Aws::AutoScaling::AutoScalingClientConfiguration& clientConfiguration = Aws::AutoScaling::AutoScalingClientConfiguration());
 
  /* Legacy constructors due deprecation */
  AutoScalingClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AutoScalingClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AutoScalingClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                    const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~AutoScalingClient();
 
  Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const;
 
  virtual Model::AttachInstancesOutcome AttachInstances(const Model::AttachInstancesRequest& request) const;
 
  template <typename AttachInstancesRequestT = Model::AttachInstancesRequest>
  Model::AttachInstancesOutcomeCallable AttachInstancesCallable(const AttachInstancesRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::AttachInstances, request);
  }
 
  template <typename AttachInstancesRequestT = Model::AttachInstancesRequest>
  void AttachInstancesAsync(const AttachInstancesRequestT& request, const AttachInstancesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::AttachInstances, request, handler, context);
  }
 
  virtual Model::AttachLoadBalancerTargetGroupsOutcome AttachLoadBalancerTargetGroups(
      const Model::AttachLoadBalancerTargetGroupsRequest& request) const;
 
  template <typename AttachLoadBalancerTargetGroupsRequestT = Model::AttachLoadBalancerTargetGroupsRequest>
  Model::AttachLoadBalancerTargetGroupsOutcomeCallable AttachLoadBalancerTargetGroupsCallable(
      const AttachLoadBalancerTargetGroupsRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::AttachLoadBalancerTargetGroups, request);
  }
 
  template <typename AttachLoadBalancerTargetGroupsRequestT = Model::AttachLoadBalancerTargetGroupsRequest>
  void AttachLoadBalancerTargetGroupsAsync(const AttachLoadBalancerTargetGroupsRequestT& request,
                                           const AttachLoadBalancerTargetGroupsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::AttachLoadBalancerTargetGroups, request, handler, context);
  }
 
  virtual Model::AttachLoadBalancersOutcome AttachLoadBalancers(const Model::AttachLoadBalancersRequest& request) const;
 
  template <typename AttachLoadBalancersRequestT = Model::AttachLoadBalancersRequest>
  Model::AttachLoadBalancersOutcomeCallable AttachLoadBalancersCallable(const AttachLoadBalancersRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::AttachLoadBalancers, request);
  }
 
  template <typename AttachLoadBalancersRequestT = Model::AttachLoadBalancersRequest>
  void AttachLoadBalancersAsync(const AttachLoadBalancersRequestT& request, const AttachLoadBalancersResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::AttachLoadBalancers, request, handler, context);
  }
 
  virtual Model::AttachTrafficSourcesOutcome AttachTrafficSources(const Model::AttachTrafficSourcesRequest& request) const;
 
  template <typename AttachTrafficSourcesRequestT = Model::AttachTrafficSourcesRequest>
  Model::AttachTrafficSourcesOutcomeCallable AttachTrafficSourcesCallable(const AttachTrafficSourcesRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::AttachTrafficSources, request);
  }
 
  template <typename AttachTrafficSourcesRequestT = Model::AttachTrafficSourcesRequest>
  void AttachTrafficSourcesAsync(const AttachTrafficSourcesRequestT& request, const AttachTrafficSourcesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::AttachTrafficSources, request, handler, context);
  }
 
  virtual Model::BatchDeleteScheduledActionOutcome BatchDeleteScheduledAction(
      const Model::BatchDeleteScheduledActionRequest& request) const;
 
  template <typename BatchDeleteScheduledActionRequestT = Model::BatchDeleteScheduledActionRequest>
  Model::BatchDeleteScheduledActionOutcomeCallable BatchDeleteScheduledActionCallable(
      const BatchDeleteScheduledActionRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::BatchDeleteScheduledAction, request);
  }
 
  template <typename BatchDeleteScheduledActionRequestT = Model::BatchDeleteScheduledActionRequest>
  void BatchDeleteScheduledActionAsync(const BatchDeleteScheduledActionRequestT& request,
                                       const BatchDeleteScheduledActionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::BatchDeleteScheduledAction, request, handler, context);
  }
 
  virtual Model::BatchPutScheduledUpdateGroupActionOutcome BatchPutScheduledUpdateGroupAction(
      const Model::BatchPutScheduledUpdateGroupActionRequest& request) const;
 
  template <typename BatchPutScheduledUpdateGroupActionRequestT = Model::BatchPutScheduledUpdateGroupActionRequest>
  Model::BatchPutScheduledUpdateGroupActionOutcomeCallable BatchPutScheduledUpdateGroupActionCallable(
      const BatchPutScheduledUpdateGroupActionRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::BatchPutScheduledUpdateGroupAction, request);
  }
 
  template <typename BatchPutScheduledUpdateGroupActionRequestT = Model::BatchPutScheduledUpdateGroupActionRequest>
  void BatchPutScheduledUpdateGroupActionAsync(const BatchPutScheduledUpdateGroupActionRequestT& request,
                                               const BatchPutScheduledUpdateGroupActionResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::BatchPutScheduledUpdateGroupAction, request, handler, context);
  }
 
  virtual Model::CancelInstanceRefreshOutcome CancelInstanceRefresh(const Model::CancelInstanceRefreshRequest& request) const;
 
  template <typename CancelInstanceRefreshRequestT = Model::CancelInstanceRefreshRequest>
  Model::CancelInstanceRefreshOutcomeCallable CancelInstanceRefreshCallable(const CancelInstanceRefreshRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::CancelInstanceRefresh, request);
  }
 
  template <typename CancelInstanceRefreshRequestT = Model::CancelInstanceRefreshRequest>
  void CancelInstanceRefreshAsync(const CancelInstanceRefreshRequestT& request, const CancelInstanceRefreshResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::CancelInstanceRefresh, request, handler, context);
  }
 
  virtual Model::CompleteLifecycleActionOutcome CompleteLifecycleAction(const Model::CompleteLifecycleActionRequest& request) const;
 
  template <typename CompleteLifecycleActionRequestT = Model::CompleteLifecycleActionRequest>
  Model::CompleteLifecycleActionOutcomeCallable CompleteLifecycleActionCallable(const CompleteLifecycleActionRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::CompleteLifecycleAction, request);
  }
 
  template <typename CompleteLifecycleActionRequestT = Model::CompleteLifecycleActionRequest>
  void CompleteLifecycleActionAsync(const CompleteLifecycleActionRequestT& request,
                                    const CompleteLifecycleActionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::CompleteLifecycleAction, request, handler, context);
  }
 
  virtual Model::CreateAutoScalingGroupOutcome CreateAutoScalingGroup(const Model::CreateAutoScalingGroupRequest& request) const;
 
  template <typename CreateAutoScalingGroupRequestT = Model::CreateAutoScalingGroupRequest>
  Model::CreateAutoScalingGroupOutcomeCallable CreateAutoScalingGroupCallable(const CreateAutoScalingGroupRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::CreateAutoScalingGroup, request);
  }
 
  template <typename CreateAutoScalingGroupRequestT = Model::CreateAutoScalingGroupRequest>
  void CreateAutoScalingGroupAsync(const CreateAutoScalingGroupRequestT& request,
                                   const CreateAutoScalingGroupResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::CreateAutoScalingGroup, request, handler, context);
  }
 
  virtual Model::CreateLaunchConfigurationOutcome CreateLaunchConfiguration(const Model::CreateLaunchConfigurationRequest& request) const;
 
  template <typename CreateLaunchConfigurationRequestT = Model::CreateLaunchConfigurationRequest>
  Model::CreateLaunchConfigurationOutcomeCallable CreateLaunchConfigurationCallable(
      const CreateLaunchConfigurationRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::CreateLaunchConfiguration, request);
  }
 
  template <typename CreateLaunchConfigurationRequestT = Model::CreateLaunchConfigurationRequest>
  void CreateLaunchConfigurationAsync(const CreateLaunchConfigurationRequestT& request,
                                      const CreateLaunchConfigurationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::CreateLaunchConfiguration, request, handler, context);
  }
 
  virtual Model::CreateOrUpdateTagsOutcome CreateOrUpdateTags(const Model::CreateOrUpdateTagsRequest& request) const;
 
  template <typename CreateOrUpdateTagsRequestT = Model::CreateOrUpdateTagsRequest>
  Model::CreateOrUpdateTagsOutcomeCallable CreateOrUpdateTagsCallable(const CreateOrUpdateTagsRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::CreateOrUpdateTags, request);
  }
 
  template <typename CreateOrUpdateTagsRequestT = Model::CreateOrUpdateTagsRequest>
  void CreateOrUpdateTagsAsync(const CreateOrUpdateTagsRequestT& request, const CreateOrUpdateTagsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::CreateOrUpdateTags, request, handler, context);
  }
 
  virtual Model::DeleteAutoScalingGroupOutcome DeleteAutoScalingGroup(const Model::DeleteAutoScalingGroupRequest& request) const;
 
  template <typename DeleteAutoScalingGroupRequestT = Model::DeleteAutoScalingGroupRequest>
  Model::DeleteAutoScalingGroupOutcomeCallable DeleteAutoScalingGroupCallable(const DeleteAutoScalingGroupRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::DeleteAutoScalingGroup, request);
  }
 
  template <typename DeleteAutoScalingGroupRequestT = Model::DeleteAutoScalingGroupRequest>
  void DeleteAutoScalingGroupAsync(const DeleteAutoScalingGroupRequestT& request,
                                   const DeleteAutoScalingGroupResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::DeleteAutoScalingGroup, request, handler, context);
  }
 
  virtual Model::DeleteLaunchConfigurationOutcome DeleteLaunchConfiguration(const Model::DeleteLaunchConfigurationRequest& request) const;
 
  template <typename DeleteLaunchConfigurationRequestT = Model::DeleteLaunchConfigurationRequest>
  Model::DeleteLaunchConfigurationOutcomeCallable DeleteLaunchConfigurationCallable(
      const DeleteLaunchConfigurationRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::DeleteLaunchConfiguration, request);
  }
 
  template <typename DeleteLaunchConfigurationRequestT = Model::DeleteLaunchConfigurationRequest>
  void DeleteLaunchConfigurationAsync(const DeleteLaunchConfigurationRequestT& request,
                                      const DeleteLaunchConfigurationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::DeleteLaunchConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteLifecycleHookOutcome DeleteLifecycleHook(const Model::DeleteLifecycleHookRequest& request) const;
 
  template <typename DeleteLifecycleHookRequestT = Model::DeleteLifecycleHookRequest>
  Model::DeleteLifecycleHookOutcomeCallable DeleteLifecycleHookCallable(const DeleteLifecycleHookRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::DeleteLifecycleHook, request);
  }
 
  template <typename DeleteLifecycleHookRequestT = Model::DeleteLifecycleHookRequest>
  void DeleteLifecycleHookAsync(const DeleteLifecycleHookRequestT& request, const DeleteLifecycleHookResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::DeleteLifecycleHook, request, handler, context);
  }
 
  virtual Model::DeleteNotificationConfigurationOutcome DeleteNotificationConfiguration(
      const Model::DeleteNotificationConfigurationRequest& request) const;
 
  template <typename DeleteNotificationConfigurationRequestT = Model::DeleteNotificationConfigurationRequest>
  Model::DeleteNotificationConfigurationOutcomeCallable DeleteNotificationConfigurationCallable(
      const DeleteNotificationConfigurationRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::DeleteNotificationConfiguration, request);
  }
 
  template <typename DeleteNotificationConfigurationRequestT = Model::DeleteNotificationConfigurationRequest>
  void DeleteNotificationConfigurationAsync(const DeleteNotificationConfigurationRequestT& request,
                                            const DeleteNotificationConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::DeleteNotificationConfiguration, request, handler, context);
  }
 
  virtual Model::DeletePolicyOutcome DeletePolicy(const Model::DeletePolicyRequest& request) const;
 
  template <typename DeletePolicyRequestT = Model::DeletePolicyRequest>
  Model::DeletePolicyOutcomeCallable DeletePolicyCallable(const DeletePolicyRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::DeletePolicy, request);
  }
 
  template <typename DeletePolicyRequestT = Model::DeletePolicyRequest>
  void DeletePolicyAsync(const DeletePolicyRequestT& request, const DeletePolicyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::DeletePolicy, request, handler, context);
  }
 
  virtual Model::DeleteScheduledActionOutcome DeleteScheduledAction(const Model::DeleteScheduledActionRequest& request) const;
 
  template <typename DeleteScheduledActionRequestT = Model::DeleteScheduledActionRequest>
  Model::DeleteScheduledActionOutcomeCallable DeleteScheduledActionCallable(const DeleteScheduledActionRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::DeleteScheduledAction, request);
  }
 
  template <typename DeleteScheduledActionRequestT = Model::DeleteScheduledActionRequest>
  void DeleteScheduledActionAsync(const DeleteScheduledActionRequestT& request, const DeleteScheduledActionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::DeleteScheduledAction, request, handler, context);
  }
 
  virtual Model::DeleteTagsOutcome DeleteTags(const Model::DeleteTagsRequest& request) const;
 
  template <typename DeleteTagsRequestT = Model::DeleteTagsRequest>
  Model::DeleteTagsOutcomeCallable DeleteTagsCallable(const DeleteTagsRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::DeleteTags, request);
  }
 
  template <typename DeleteTagsRequestT = Model::DeleteTagsRequest>
  void DeleteTagsAsync(const DeleteTagsRequestT& request, const DeleteTagsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::DeleteTags, request, handler, context);
  }
 
  virtual Model::DeleteWarmPoolOutcome DeleteWarmPool(const Model::DeleteWarmPoolRequest& request) const;
 
  template <typename DeleteWarmPoolRequestT = Model::DeleteWarmPoolRequest>
  Model::DeleteWarmPoolOutcomeCallable DeleteWarmPoolCallable(const DeleteWarmPoolRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::DeleteWarmPool, request);
  }
 
  template <typename DeleteWarmPoolRequestT = Model::DeleteWarmPoolRequest>
  void DeleteWarmPoolAsync(const DeleteWarmPoolRequestT& request, const DeleteWarmPoolResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::DeleteWarmPool, request, handler, context);
  }
 
  virtual Model::DescribeAccountLimitsOutcome DescribeAccountLimits(const Model::DescribeAccountLimitsRequest& request = {}) const;
 
  template <typename DescribeAccountLimitsRequestT = Model::DescribeAccountLimitsRequest>
  Model::DescribeAccountLimitsOutcomeCallable DescribeAccountLimitsCallable(const DescribeAccountLimitsRequestT& request = {}) const {
    return SubmitCallable(&AutoScalingClient::DescribeAccountLimits, request);
  }
 
  template <typename DescribeAccountLimitsRequestT = Model::DescribeAccountLimitsRequest>
  void DescribeAccountLimitsAsync(const DescribeAccountLimitsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const DescribeAccountLimitsRequestT& request = {}) const {
    return SubmitAsync(&AutoScalingClient::DescribeAccountLimits, request, handler, context);
  }
 
  virtual Model::DescribeAdjustmentTypesOutcome DescribeAdjustmentTypes(const Model::DescribeAdjustmentTypesRequest& request = {}) const;
 
  template <typename DescribeAdjustmentTypesRequestT = Model::DescribeAdjustmentTypesRequest>
  Model::DescribeAdjustmentTypesOutcomeCallable DescribeAdjustmentTypesCallable(const DescribeAdjustmentTypesRequestT& request = {}) const {
    return SubmitCallable(&AutoScalingClient::DescribeAdjustmentTypes, request);
  }
 
  template <typename DescribeAdjustmentTypesRequestT = Model::DescribeAdjustmentTypesRequest>
  void DescribeAdjustmentTypesAsync(const DescribeAdjustmentTypesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const DescribeAdjustmentTypesRequestT& request = {}) const {
    return SubmitAsync(&AutoScalingClient::DescribeAdjustmentTypes, request, handler, context);
  }
 
  virtual Model::DescribeAutoScalingGroupsOutcome DescribeAutoScalingGroups(
      const Model::DescribeAutoScalingGroupsRequest& request = {}) const;
 
  template <typename DescribeAutoScalingGroupsRequestT = Model::DescribeAutoScalingGroupsRequest>
  Model::DescribeAutoScalingGroupsOutcomeCallable DescribeAutoScalingGroupsCallable(
      const DescribeAutoScalingGroupsRequestT& request = {}) const {
    return SubmitCallable(&AutoScalingClient::DescribeAutoScalingGroups, request);
  }
 
  template <typename DescribeAutoScalingGroupsRequestT = Model::DescribeAutoScalingGroupsRequest>
  void DescribeAutoScalingGroupsAsync(const DescribeAutoScalingGroupsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const DescribeAutoScalingGroupsRequestT& request = {}) const {
    return SubmitAsync(&AutoScalingClient::DescribeAutoScalingGroups, request, handler, context);
  }
 
  virtual Model::DescribeAutoScalingInstancesOutcome DescribeAutoScalingInstances(
      const Model::DescribeAutoScalingInstancesRequest& request = {}) const;
 
  template <typename DescribeAutoScalingInstancesRequestT = Model::DescribeAutoScalingInstancesRequest>
  Model::DescribeAutoScalingInstancesOutcomeCallable DescribeAutoScalingInstancesCallable(
      const DescribeAutoScalingInstancesRequestT& request = {}) const {
    return SubmitCallable(&AutoScalingClient::DescribeAutoScalingInstances, request);
  }
 
  template <typename DescribeAutoScalingInstancesRequestT = Model::DescribeAutoScalingInstancesRequest>
  void DescribeAutoScalingInstancesAsync(const DescribeAutoScalingInstancesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const DescribeAutoScalingInstancesRequestT& request = {}) const {
    return SubmitAsync(&AutoScalingClient::DescribeAutoScalingInstances, request, handler, context);
  }
 
  virtual Model::DescribeAutoScalingNotificationTypesOutcome DescribeAutoScalingNotificationTypes(
      const Model::DescribeAutoScalingNotificationTypesRequest& request = {}) const;
 
  template <typename DescribeAutoScalingNotificationTypesRequestT = Model::DescribeAutoScalingNotificationTypesRequest>
  Model::DescribeAutoScalingNotificationTypesOutcomeCallable DescribeAutoScalingNotificationTypesCallable(
      const DescribeAutoScalingNotificationTypesRequestT& request = {}) const {
    return SubmitCallable(&AutoScalingClient::DescribeAutoScalingNotificationTypes, request);
  }
 
  template <typename DescribeAutoScalingNotificationTypesRequestT = Model::DescribeAutoScalingNotificationTypesRequest>
  void DescribeAutoScalingNotificationTypesAsync(const DescribeAutoScalingNotificationTypesResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                 const DescribeAutoScalingNotificationTypesRequestT& request = {}) const {
    return SubmitAsync(&AutoScalingClient::DescribeAutoScalingNotificationTypes, request, handler, context);
  }
 
  virtual Model::DescribeInstanceRefreshesOutcome DescribeInstanceRefreshes(const Model::DescribeInstanceRefreshesRequest& request) const;
 
  template <typename DescribeInstanceRefreshesRequestT = Model::DescribeInstanceRefreshesRequest>
  Model::DescribeInstanceRefreshesOutcomeCallable DescribeInstanceRefreshesCallable(
      const DescribeInstanceRefreshesRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::DescribeInstanceRefreshes, request);
  }
 
  template <typename DescribeInstanceRefreshesRequestT = Model::DescribeInstanceRefreshesRequest>
  void DescribeInstanceRefreshesAsync(const DescribeInstanceRefreshesRequestT& request,
                                      const DescribeInstanceRefreshesResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::DescribeInstanceRefreshes, request, handler, context);
  }
 
  virtual Model::DescribeLaunchConfigurationsOutcome DescribeLaunchConfigurations(
      const Model::DescribeLaunchConfigurationsRequest& request = {}) const;
 
  template <typename DescribeLaunchConfigurationsRequestT = Model::DescribeLaunchConfigurationsRequest>
  Model::DescribeLaunchConfigurationsOutcomeCallable DescribeLaunchConfigurationsCallable(
      const DescribeLaunchConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&AutoScalingClient::DescribeLaunchConfigurations, request);
  }
 
  template <typename DescribeLaunchConfigurationsRequestT = Model::DescribeLaunchConfigurationsRequest>
  void DescribeLaunchConfigurationsAsync(const DescribeLaunchConfigurationsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const DescribeLaunchConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&AutoScalingClient::DescribeLaunchConfigurations, request, handler, context);
  }
 
  virtual Model::DescribeLifecycleHookTypesOutcome DescribeLifecycleHookTypes(
      const Model::DescribeLifecycleHookTypesRequest& request = {}) const;
 
  template <typename DescribeLifecycleHookTypesRequestT = Model::DescribeLifecycleHookTypesRequest>
  Model::DescribeLifecycleHookTypesOutcomeCallable DescribeLifecycleHookTypesCallable(
      const DescribeLifecycleHookTypesRequestT& request = {}) const {
    return SubmitCallable(&AutoScalingClient::DescribeLifecycleHookTypes, request);
  }
 
  template <typename DescribeLifecycleHookTypesRequestT = Model::DescribeLifecycleHookTypesRequest>
  void DescribeLifecycleHookTypesAsync(const DescribeLifecycleHookTypesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const DescribeLifecycleHookTypesRequestT& request = {}) const {
    return SubmitAsync(&AutoScalingClient::DescribeLifecycleHookTypes, request, handler, context);
  }
 
  virtual Model::DescribeLifecycleHooksOutcome DescribeLifecycleHooks(const Model::DescribeLifecycleHooksRequest& request) const;
 
  template <typename DescribeLifecycleHooksRequestT = Model::DescribeLifecycleHooksRequest>
  Model::DescribeLifecycleHooksOutcomeCallable DescribeLifecycleHooksCallable(const DescribeLifecycleHooksRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::DescribeLifecycleHooks, request);
  }
 
  template <typename DescribeLifecycleHooksRequestT = Model::DescribeLifecycleHooksRequest>
  void DescribeLifecycleHooksAsync(const DescribeLifecycleHooksRequestT& request,
                                   const DescribeLifecycleHooksResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::DescribeLifecycleHooks, request, handler, context);
  }
 
  virtual Model::DescribeLoadBalancerTargetGroupsOutcome DescribeLoadBalancerTargetGroups(
      const Model::DescribeLoadBalancerTargetGroupsRequest& request) const;
 
  template <typename DescribeLoadBalancerTargetGroupsRequestT = Model::DescribeLoadBalancerTargetGroupsRequest>
  Model::DescribeLoadBalancerTargetGroupsOutcomeCallable DescribeLoadBalancerTargetGroupsCallable(
      const DescribeLoadBalancerTargetGroupsRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::DescribeLoadBalancerTargetGroups, request);
  }
 
  template <typename DescribeLoadBalancerTargetGroupsRequestT = Model::DescribeLoadBalancerTargetGroupsRequest>
  void DescribeLoadBalancerTargetGroupsAsync(const DescribeLoadBalancerTargetGroupsRequestT& request,
                                             const DescribeLoadBalancerTargetGroupsResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::DescribeLoadBalancerTargetGroups, request, handler, context);
  }
 
  virtual Model::DescribeLoadBalancersOutcome DescribeLoadBalancers(const Model::DescribeLoadBalancersRequest& request) const;
 
  template <typename DescribeLoadBalancersRequestT = Model::DescribeLoadBalancersRequest>
  Model::DescribeLoadBalancersOutcomeCallable DescribeLoadBalancersCallable(const DescribeLoadBalancersRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::DescribeLoadBalancers, request);
  }
 
  template <typename DescribeLoadBalancersRequestT = Model::DescribeLoadBalancersRequest>
  void DescribeLoadBalancersAsync(const DescribeLoadBalancersRequestT& request, const DescribeLoadBalancersResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::DescribeLoadBalancers, request, handler, context);
  }
 
  virtual Model::DescribeMetricCollectionTypesOutcome DescribeMetricCollectionTypes(
      const Model::DescribeMetricCollectionTypesRequest& request = {}) const;
 
  template <typename DescribeMetricCollectionTypesRequestT = Model::DescribeMetricCollectionTypesRequest>
  Model::DescribeMetricCollectionTypesOutcomeCallable DescribeMetricCollectionTypesCallable(
      const DescribeMetricCollectionTypesRequestT& request = {}) const {
    return SubmitCallable(&AutoScalingClient::DescribeMetricCollectionTypes, request);
  }
 
  template <typename DescribeMetricCollectionTypesRequestT = Model::DescribeMetricCollectionTypesRequest>
  void DescribeMetricCollectionTypesAsync(const DescribeMetricCollectionTypesResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const DescribeMetricCollectionTypesRequestT& request = {}) const {
    return SubmitAsync(&AutoScalingClient::DescribeMetricCollectionTypes, request, handler, context);
  }
 
  virtual Model::DescribeNotificationConfigurationsOutcome DescribeNotificationConfigurations(
      const Model::DescribeNotificationConfigurationsRequest& request = {}) const;
 
  template <typename DescribeNotificationConfigurationsRequestT = Model::DescribeNotificationConfigurationsRequest>
  Model::DescribeNotificationConfigurationsOutcomeCallable DescribeNotificationConfigurationsCallable(
      const DescribeNotificationConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&AutoScalingClient::DescribeNotificationConfigurations, request);
  }
 
  template <typename DescribeNotificationConfigurationsRequestT = Model::DescribeNotificationConfigurationsRequest>
  void DescribeNotificationConfigurationsAsync(const DescribeNotificationConfigurationsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const DescribeNotificationConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&AutoScalingClient::DescribeNotificationConfigurations, request, handler, context);
  }
 
  virtual Model::DescribePoliciesOutcome DescribePolicies(const Model::DescribePoliciesRequest& request = {}) const;
 
  template <typename DescribePoliciesRequestT = Model::DescribePoliciesRequest>
  Model::DescribePoliciesOutcomeCallable DescribePoliciesCallable(const DescribePoliciesRequestT& request = {}) const {
    return SubmitCallable(&AutoScalingClient::DescribePolicies, request);
  }
 
  template <typename DescribePoliciesRequestT = Model::DescribePoliciesRequest>
  void DescribePoliciesAsync(const DescribePoliciesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const DescribePoliciesRequestT& request = {}) const {
    return SubmitAsync(&AutoScalingClient::DescribePolicies, request, handler, context);
  }
 
  virtual Model::DescribeScalingActivitiesOutcome DescribeScalingActivities(
      const Model::DescribeScalingActivitiesRequest& request = {}) const;
 
  template <typename DescribeScalingActivitiesRequestT = Model::DescribeScalingActivitiesRequest>
  Model::DescribeScalingActivitiesOutcomeCallable DescribeScalingActivitiesCallable(
      const DescribeScalingActivitiesRequestT& request = {}) const {
    return SubmitCallable(&AutoScalingClient::DescribeScalingActivities, request);
  }
 
  template <typename DescribeScalingActivitiesRequestT = Model::DescribeScalingActivitiesRequest>
  void DescribeScalingActivitiesAsync(const DescribeScalingActivitiesResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const DescribeScalingActivitiesRequestT& request = {}) const {
    return SubmitAsync(&AutoScalingClient::DescribeScalingActivities, request, handler, context);
  }
 
  virtual Model::DescribeScalingProcessTypesOutcome DescribeScalingProcessTypes(
      const Model::DescribeScalingProcessTypesRequest& request = {}) const;
 
  template <typename DescribeScalingProcessTypesRequestT = Model::DescribeScalingProcessTypesRequest>
  Model::DescribeScalingProcessTypesOutcomeCallable DescribeScalingProcessTypesCallable(
      const DescribeScalingProcessTypesRequestT& request = {}) const {
    return SubmitCallable(&AutoScalingClient::DescribeScalingProcessTypes, request);
  }
 
  template <typename DescribeScalingProcessTypesRequestT = Model::DescribeScalingProcessTypesRequest>
  void DescribeScalingProcessTypesAsync(const DescribeScalingProcessTypesResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const DescribeScalingProcessTypesRequestT& request = {}) const {
    return SubmitAsync(&AutoScalingClient::DescribeScalingProcessTypes, request, handler, context);
  }
 
  virtual Model::DescribeScheduledActionsOutcome DescribeScheduledActions(const Model::DescribeScheduledActionsRequest& request = {}) const;
 
  template <typename DescribeScheduledActionsRequestT = Model::DescribeScheduledActionsRequest>
  Model::DescribeScheduledActionsOutcomeCallable DescribeScheduledActionsCallable(
      const DescribeScheduledActionsRequestT& request = {}) const {
    return SubmitCallable(&AutoScalingClient::DescribeScheduledActions, request);
  }
 
  template <typename DescribeScheduledActionsRequestT = Model::DescribeScheduledActionsRequest>
  void DescribeScheduledActionsAsync(const DescribeScheduledActionsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const DescribeScheduledActionsRequestT& request = {}) const {
    return SubmitAsync(&AutoScalingClient::DescribeScheduledActions, request, handler, context);
  }
 
  virtual Model::DescribeTagsOutcome DescribeTags(const Model::DescribeTagsRequest& request = {}) const;
 
  template <typename DescribeTagsRequestT = Model::DescribeTagsRequest>
  Model::DescribeTagsOutcomeCallable DescribeTagsCallable(const DescribeTagsRequestT& request = {}) const {
    return SubmitCallable(&AutoScalingClient::DescribeTags, request);
  }
 
  template <typename DescribeTagsRequestT = Model::DescribeTagsRequest>
  void DescribeTagsAsync(const DescribeTagsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const DescribeTagsRequestT& request = {}) const {
    return SubmitAsync(&AutoScalingClient::DescribeTags, request, handler, context);
  }
 
  virtual Model::DescribeTerminationPolicyTypesOutcome DescribeTerminationPolicyTypes(
      const Model::DescribeTerminationPolicyTypesRequest& request = {}) const;
 
  template <typename DescribeTerminationPolicyTypesRequestT = Model::DescribeTerminationPolicyTypesRequest>
  Model::DescribeTerminationPolicyTypesOutcomeCallable DescribeTerminationPolicyTypesCallable(
      const DescribeTerminationPolicyTypesRequestT& request = {}) const {
    return SubmitCallable(&AutoScalingClient::DescribeTerminationPolicyTypes, request);
  }
 
  template <typename DescribeTerminationPolicyTypesRequestT = Model::DescribeTerminationPolicyTypesRequest>
  void DescribeTerminationPolicyTypesAsync(const DescribeTerminationPolicyTypesResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const DescribeTerminationPolicyTypesRequestT& request = {}) const {
    return SubmitAsync(&AutoScalingClient::DescribeTerminationPolicyTypes, request, handler, context);
  }
 
  virtual Model::DescribeTrafficSourcesOutcome DescribeTrafficSources(const Model::DescribeTrafficSourcesRequest& request) const;
 
  template <typename DescribeTrafficSourcesRequestT = Model::DescribeTrafficSourcesRequest>
  Model::DescribeTrafficSourcesOutcomeCallable DescribeTrafficSourcesCallable(const DescribeTrafficSourcesRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::DescribeTrafficSources, request);
  }
 
  template <typename DescribeTrafficSourcesRequestT = Model::DescribeTrafficSourcesRequest>
  void DescribeTrafficSourcesAsync(const DescribeTrafficSourcesRequestT& request,
                                   const DescribeTrafficSourcesResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::DescribeTrafficSources, request, handler, context);
  }
 
  virtual Model::DescribeWarmPoolOutcome DescribeWarmPool(const Model::DescribeWarmPoolRequest& request) const;
 
  template <typename DescribeWarmPoolRequestT = Model::DescribeWarmPoolRequest>
  Model::DescribeWarmPoolOutcomeCallable DescribeWarmPoolCallable(const DescribeWarmPoolRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::DescribeWarmPool, request);
  }
 
  template <typename DescribeWarmPoolRequestT = Model::DescribeWarmPoolRequest>
  void DescribeWarmPoolAsync(const DescribeWarmPoolRequestT& request, const DescribeWarmPoolResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::DescribeWarmPool, request, handler, context);
  }
 
  virtual Model::DetachInstancesOutcome DetachInstances(const Model::DetachInstancesRequest& request) const;
 
  template <typename DetachInstancesRequestT = Model::DetachInstancesRequest>
  Model::DetachInstancesOutcomeCallable DetachInstancesCallable(const DetachInstancesRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::DetachInstances, request);
  }
 
  template <typename DetachInstancesRequestT = Model::DetachInstancesRequest>
  void DetachInstancesAsync(const DetachInstancesRequestT& request, const DetachInstancesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::DetachInstances, request, handler, context);
  }
 
  virtual Model::DetachLoadBalancerTargetGroupsOutcome DetachLoadBalancerTargetGroups(
      const Model::DetachLoadBalancerTargetGroupsRequest& request) const;
 
  template <typename DetachLoadBalancerTargetGroupsRequestT = Model::DetachLoadBalancerTargetGroupsRequest>
  Model::DetachLoadBalancerTargetGroupsOutcomeCallable DetachLoadBalancerTargetGroupsCallable(
      const DetachLoadBalancerTargetGroupsRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::DetachLoadBalancerTargetGroups, request);
  }
 
  template <typename DetachLoadBalancerTargetGroupsRequestT = Model::DetachLoadBalancerTargetGroupsRequest>
  void DetachLoadBalancerTargetGroupsAsync(const DetachLoadBalancerTargetGroupsRequestT& request,
                                           const DetachLoadBalancerTargetGroupsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::DetachLoadBalancerTargetGroups, request, handler, context);
  }
 
  virtual Model::DetachLoadBalancersOutcome DetachLoadBalancers(const Model::DetachLoadBalancersRequest& request) const;
 
  template <typename DetachLoadBalancersRequestT = Model::DetachLoadBalancersRequest>
  Model::DetachLoadBalancersOutcomeCallable DetachLoadBalancersCallable(const DetachLoadBalancersRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::DetachLoadBalancers, request);
  }
 
  template <typename DetachLoadBalancersRequestT = Model::DetachLoadBalancersRequest>
  void DetachLoadBalancersAsync(const DetachLoadBalancersRequestT& request, const DetachLoadBalancersResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::DetachLoadBalancers, request, handler, context);
  }
 
  virtual Model::DetachTrafficSourcesOutcome DetachTrafficSources(const Model::DetachTrafficSourcesRequest& request) const;
 
  template <typename DetachTrafficSourcesRequestT = Model::DetachTrafficSourcesRequest>
  Model::DetachTrafficSourcesOutcomeCallable DetachTrafficSourcesCallable(const DetachTrafficSourcesRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::DetachTrafficSources, request);
  }
 
  template <typename DetachTrafficSourcesRequestT = Model::DetachTrafficSourcesRequest>
  void DetachTrafficSourcesAsync(const DetachTrafficSourcesRequestT& request, const DetachTrafficSourcesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::DetachTrafficSources, request, handler, context);
  }
 
  virtual Model::DisableMetricsCollectionOutcome DisableMetricsCollection(const Model::DisableMetricsCollectionRequest& request) const;
 
  template <typename DisableMetricsCollectionRequestT = Model::DisableMetricsCollectionRequest>
  Model::DisableMetricsCollectionOutcomeCallable DisableMetricsCollectionCallable(const DisableMetricsCollectionRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::DisableMetricsCollection, request);
  }
 
  template <typename DisableMetricsCollectionRequestT = Model::DisableMetricsCollectionRequest>
  void DisableMetricsCollectionAsync(const DisableMetricsCollectionRequestT& request,
                                     const DisableMetricsCollectionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::DisableMetricsCollection, request, handler, context);
  }
 
  virtual Model::EnableMetricsCollectionOutcome EnableMetricsCollection(const Model::EnableMetricsCollectionRequest& request) const;
 
  template <typename EnableMetricsCollectionRequestT = Model::EnableMetricsCollectionRequest>
  Model::EnableMetricsCollectionOutcomeCallable EnableMetricsCollectionCallable(const EnableMetricsCollectionRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::EnableMetricsCollection, request);
  }
 
  template <typename EnableMetricsCollectionRequestT = Model::EnableMetricsCollectionRequest>
  void EnableMetricsCollectionAsync(const EnableMetricsCollectionRequestT& request,
                                    const EnableMetricsCollectionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::EnableMetricsCollection, request, handler, context);
  }
 
  virtual Model::EnterStandbyOutcome EnterStandby(const Model::EnterStandbyRequest& request) const;
 
  template <typename EnterStandbyRequestT = Model::EnterStandbyRequest>
  Model::EnterStandbyOutcomeCallable EnterStandbyCallable(const EnterStandbyRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::EnterStandby, request);
  }
 
  template <typename EnterStandbyRequestT = Model::EnterStandbyRequest>
  void EnterStandbyAsync(const EnterStandbyRequestT& request, const EnterStandbyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::EnterStandby, request, handler, context);
  }
 
  virtual Model::ExecutePolicyOutcome ExecutePolicy(const Model::ExecutePolicyRequest& request) const;
 
  template <typename ExecutePolicyRequestT = Model::ExecutePolicyRequest>
  Model::ExecutePolicyOutcomeCallable ExecutePolicyCallable(const ExecutePolicyRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::ExecutePolicy, request);
  }
 
  template <typename ExecutePolicyRequestT = Model::ExecutePolicyRequest>
  void ExecutePolicyAsync(const ExecutePolicyRequestT& request, const ExecutePolicyResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::ExecutePolicy, request, handler, context);
  }
 
  virtual Model::ExitStandbyOutcome ExitStandby(const Model::ExitStandbyRequest& request) const;
 
  template <typename ExitStandbyRequestT = Model::ExitStandbyRequest>
  Model::ExitStandbyOutcomeCallable ExitStandbyCallable(const ExitStandbyRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::ExitStandby, request);
  }
 
  template <typename ExitStandbyRequestT = Model::ExitStandbyRequest>
  void ExitStandbyAsync(const ExitStandbyRequestT& request, const ExitStandbyResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::ExitStandby, request, handler, context);
  }
 
  virtual Model::GetPredictiveScalingForecastOutcome GetPredictiveScalingForecast(
      const Model::GetPredictiveScalingForecastRequest& request) const;
 
  template <typename GetPredictiveScalingForecastRequestT = Model::GetPredictiveScalingForecastRequest>
  Model::GetPredictiveScalingForecastOutcomeCallable GetPredictiveScalingForecastCallable(
      const GetPredictiveScalingForecastRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::GetPredictiveScalingForecast, request);
  }
 
  template <typename GetPredictiveScalingForecastRequestT = Model::GetPredictiveScalingForecastRequest>
  void GetPredictiveScalingForecastAsync(const GetPredictiveScalingForecastRequestT& request,
                                         const GetPredictiveScalingForecastResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::GetPredictiveScalingForecast, request, handler, context);
  }
 
  virtual Model::LaunchInstancesOutcome LaunchInstances(const Model::LaunchInstancesRequest& request) const;
 
  template <typename LaunchInstancesRequestT = Model::LaunchInstancesRequest>
  Model::LaunchInstancesOutcomeCallable LaunchInstancesCallable(const LaunchInstancesRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::LaunchInstances, request);
  }
 
  template <typename LaunchInstancesRequestT = Model::LaunchInstancesRequest>
  void LaunchInstancesAsync(const LaunchInstancesRequestT& request, const LaunchInstancesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::LaunchInstances, request, handler, context);
  }
 
  virtual Model::PutLifecycleHookOutcome PutLifecycleHook(const Model::PutLifecycleHookRequest& request) const;
 
  template <typename PutLifecycleHookRequestT = Model::PutLifecycleHookRequest>
  Model::PutLifecycleHookOutcomeCallable PutLifecycleHookCallable(const PutLifecycleHookRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::PutLifecycleHook, request);
  }
 
  template <typename PutLifecycleHookRequestT = Model::PutLifecycleHookRequest>
  void PutLifecycleHookAsync(const PutLifecycleHookRequestT& request, const PutLifecycleHookResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::PutLifecycleHook, request, handler, context);
  }
 
  virtual Model::PutNotificationConfigurationOutcome PutNotificationConfiguration(
      const Model::PutNotificationConfigurationRequest& request) const;
 
  template <typename PutNotificationConfigurationRequestT = Model::PutNotificationConfigurationRequest>
  Model::PutNotificationConfigurationOutcomeCallable PutNotificationConfigurationCallable(
      const PutNotificationConfigurationRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::PutNotificationConfiguration, request);
  }
 
  template <typename PutNotificationConfigurationRequestT = Model::PutNotificationConfigurationRequest>
  void PutNotificationConfigurationAsync(const PutNotificationConfigurationRequestT& request,
                                         const PutNotificationConfigurationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::PutNotificationConfiguration, request, handler, context);
  }
 
  virtual Model::PutScalingPolicyOutcome PutScalingPolicy(const Model::PutScalingPolicyRequest& request) const;
 
  template <typename PutScalingPolicyRequestT = Model::PutScalingPolicyRequest>
  Model::PutScalingPolicyOutcomeCallable PutScalingPolicyCallable(const PutScalingPolicyRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::PutScalingPolicy, request);
  }
 
  template <typename PutScalingPolicyRequestT = Model::PutScalingPolicyRequest>
  void PutScalingPolicyAsync(const PutScalingPolicyRequestT& request, const PutScalingPolicyResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::PutScalingPolicy, request, handler, context);
  }
 
  virtual Model::PutScheduledUpdateGroupActionOutcome PutScheduledUpdateGroupAction(
      const Model::PutScheduledUpdateGroupActionRequest& request) const;
 
  template <typename PutScheduledUpdateGroupActionRequestT = Model::PutScheduledUpdateGroupActionRequest>
  Model::PutScheduledUpdateGroupActionOutcomeCallable PutScheduledUpdateGroupActionCallable(
      const PutScheduledUpdateGroupActionRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::PutScheduledUpdateGroupAction, request);
  }
 
  template <typename PutScheduledUpdateGroupActionRequestT = Model::PutScheduledUpdateGroupActionRequest>
  void PutScheduledUpdateGroupActionAsync(const PutScheduledUpdateGroupActionRequestT& request,
                                          const PutScheduledUpdateGroupActionResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::PutScheduledUpdateGroupAction, request, handler, context);
  }
 
  virtual Model::PutWarmPoolOutcome PutWarmPool(const Model::PutWarmPoolRequest& request) const;
 
  template <typename PutWarmPoolRequestT = Model::PutWarmPoolRequest>
  Model::PutWarmPoolOutcomeCallable PutWarmPoolCallable(const PutWarmPoolRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::PutWarmPool, request);
  }
 
  template <typename PutWarmPoolRequestT = Model::PutWarmPoolRequest>
  void PutWarmPoolAsync(const PutWarmPoolRequestT& request, const PutWarmPoolResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::PutWarmPool, request, handler, context);
  }
 
  virtual Model::RecordLifecycleActionHeartbeatOutcome RecordLifecycleActionHeartbeat(
      const Model::RecordLifecycleActionHeartbeatRequest& request) const;
 
  template <typename RecordLifecycleActionHeartbeatRequestT = Model::RecordLifecycleActionHeartbeatRequest>
  Model::RecordLifecycleActionHeartbeatOutcomeCallable RecordLifecycleActionHeartbeatCallable(
      const RecordLifecycleActionHeartbeatRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::RecordLifecycleActionHeartbeat, request);
  }
 
  template <typename RecordLifecycleActionHeartbeatRequestT = Model::RecordLifecycleActionHeartbeatRequest>
  void RecordLifecycleActionHeartbeatAsync(const RecordLifecycleActionHeartbeatRequestT& request,
                                           const RecordLifecycleActionHeartbeatResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::RecordLifecycleActionHeartbeat, request, handler, context);
  }
 
  virtual Model::ResumeProcessesOutcome ResumeProcesses(const Model::ResumeProcessesRequest& request) const;
 
  template <typename ResumeProcessesRequestT = Model::ResumeProcessesRequest>
  Model::ResumeProcessesOutcomeCallable ResumeProcessesCallable(const ResumeProcessesRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::ResumeProcesses, request);
  }
 
  template <typename ResumeProcessesRequestT = Model::ResumeProcessesRequest>
  void ResumeProcessesAsync(const ResumeProcessesRequestT& request, const ResumeProcessesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::ResumeProcesses, request, handler, context);
  }
 
  virtual Model::RollbackInstanceRefreshOutcome RollbackInstanceRefresh(const Model::RollbackInstanceRefreshRequest& request) const;
 
  template <typename RollbackInstanceRefreshRequestT = Model::RollbackInstanceRefreshRequest>
  Model::RollbackInstanceRefreshOutcomeCallable RollbackInstanceRefreshCallable(const RollbackInstanceRefreshRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::RollbackInstanceRefresh, request);
  }
 
  template <typename RollbackInstanceRefreshRequestT = Model::RollbackInstanceRefreshRequest>
  void RollbackInstanceRefreshAsync(const RollbackInstanceRefreshRequestT& request,
                                    const RollbackInstanceRefreshResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::RollbackInstanceRefresh, request, handler, context);
  }
 
  virtual Model::SetDesiredCapacityOutcome SetDesiredCapacity(const Model::SetDesiredCapacityRequest& request) const;
 
  template <typename SetDesiredCapacityRequestT = Model::SetDesiredCapacityRequest>
  Model::SetDesiredCapacityOutcomeCallable SetDesiredCapacityCallable(const SetDesiredCapacityRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::SetDesiredCapacity, request);
  }
 
  template <typename SetDesiredCapacityRequestT = Model::SetDesiredCapacityRequest>
  void SetDesiredCapacityAsync(const SetDesiredCapacityRequestT& request, const SetDesiredCapacityResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::SetDesiredCapacity, request, handler, context);
  }
 
  virtual Model::SetInstanceHealthOutcome SetInstanceHealth(const Model::SetInstanceHealthRequest& request) const;
 
  template <typename SetInstanceHealthRequestT = Model::SetInstanceHealthRequest>
  Model::SetInstanceHealthOutcomeCallable SetInstanceHealthCallable(const SetInstanceHealthRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::SetInstanceHealth, request);
  }
 
  template <typename SetInstanceHealthRequestT = Model::SetInstanceHealthRequest>
  void SetInstanceHealthAsync(const SetInstanceHealthRequestT& request, const SetInstanceHealthResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::SetInstanceHealth, request, handler, context);
  }
 
  virtual Model::SetInstanceProtectionOutcome SetInstanceProtection(const Model::SetInstanceProtectionRequest& request) const;
 
  template <typename SetInstanceProtectionRequestT = Model::SetInstanceProtectionRequest>
  Model::SetInstanceProtectionOutcomeCallable SetInstanceProtectionCallable(const SetInstanceProtectionRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::SetInstanceProtection, request);
  }
 
  template <typename SetInstanceProtectionRequestT = Model::SetInstanceProtectionRequest>
  void SetInstanceProtectionAsync(const SetInstanceProtectionRequestT& request, const SetInstanceProtectionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::SetInstanceProtection, request, handler, context);
  }
 
  virtual Model::StartInstanceRefreshOutcome StartInstanceRefresh(const Model::StartInstanceRefreshRequest& request) const;
 
  template <typename StartInstanceRefreshRequestT = Model::StartInstanceRefreshRequest>
  Model::StartInstanceRefreshOutcomeCallable StartInstanceRefreshCallable(const StartInstanceRefreshRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::StartInstanceRefresh, request);
  }
 
  template <typename StartInstanceRefreshRequestT = Model::StartInstanceRefreshRequest>
  void StartInstanceRefreshAsync(const StartInstanceRefreshRequestT& request, const StartInstanceRefreshResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::StartInstanceRefresh, request, handler, context);
  }
 
  virtual Model::SuspendProcessesOutcome SuspendProcesses(const Model::SuspendProcessesRequest& request) const;
 
  template <typename SuspendProcessesRequestT = Model::SuspendProcessesRequest>
  Model::SuspendProcessesOutcomeCallable SuspendProcessesCallable(const SuspendProcessesRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::SuspendProcesses, request);
  }
 
  template <typename SuspendProcessesRequestT = Model::SuspendProcessesRequest>
  void SuspendProcessesAsync(const SuspendProcessesRequestT& request, const SuspendProcessesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::SuspendProcesses, request, handler, context);
  }
 
  virtual Model::TerminateInstanceInAutoScalingGroupOutcome TerminateInstanceInAutoScalingGroup(
      const Model::TerminateInstanceInAutoScalingGroupRequest& request) const;
 
  template <typename TerminateInstanceInAutoScalingGroupRequestT = Model::TerminateInstanceInAutoScalingGroupRequest>
  Model::TerminateInstanceInAutoScalingGroupOutcomeCallable TerminateInstanceInAutoScalingGroupCallable(
      const TerminateInstanceInAutoScalingGroupRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::TerminateInstanceInAutoScalingGroup, request);
  }
 
  template <typename TerminateInstanceInAutoScalingGroupRequestT = Model::TerminateInstanceInAutoScalingGroupRequest>
  void TerminateInstanceInAutoScalingGroupAsync(const TerminateInstanceInAutoScalingGroupRequestT& request,
                                                const TerminateInstanceInAutoScalingGroupResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::TerminateInstanceInAutoScalingGroup, request, handler, context);
  }
 
  virtual Model::UpdateAutoScalingGroupOutcome UpdateAutoScalingGroup(const Model::UpdateAutoScalingGroupRequest& request) const;
 
  template <typename UpdateAutoScalingGroupRequestT = Model::UpdateAutoScalingGroupRequest>
  Model::UpdateAutoScalingGroupOutcomeCallable UpdateAutoScalingGroupCallable(const UpdateAutoScalingGroupRequestT& request) const {
    return SubmitCallable(&AutoScalingClient::UpdateAutoScalingGroup, request);
  }
 
  template <typename UpdateAutoScalingGroupRequestT = Model::UpdateAutoScalingGroupRequest>
  void UpdateAutoScalingGroupAsync(const UpdateAutoScalingGroupRequestT& request,
                                   const UpdateAutoScalingGroupResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingClient::UpdateAutoScalingGroup, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<AutoScalingEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<AutoScalingClient>;
  void init(const AutoScalingClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, AutoScalingError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  AutoScalingClientConfiguration m_clientConfiguration;
  std::shared_ptr<AutoScalingEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace AutoScaling
}  // namespace Aws