AutoScalingClient.h

 
#pragma once
#include <aws/autoscaling/AutoScaling_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/autoscaling/AutoScalingServiceClientModel.h>
 
namespace Aws
{
namespace AutoScaling
{
  class AWS_AUTOSCALING_API AutoScalingClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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);
        }
 
 
        void OverrideEndpoint(const Aws::String& endpoint);
        std::shared_ptr<AutoScalingEndpointProviderBase>& accessEndpointProvider();
  private:
        friend class Aws::Client::ClientWithAsyncTemplateMethods<AutoScalingClient>;
        void init(const AutoScalingClientConfiguration& clientConfiguration);
 
        AutoScalingClientConfiguration m_clientConfiguration;
        std::shared_ptr<AutoScalingEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace AutoScaling
} // namespace Aws