Repository: kubernetes-sigs/cluster-api-provider-aws

Issue:
Migrate autoscaling package to AWS SDK v2
Update calls in the following packages and files. Note that this is not necessarily an exhaustive list.

* ./pkg/cloud/services/mock_services/autoscaling_interface_mock.go
* ./pkg/cloud/services/autoscaling
* ./pkg/cloud/services/autoscaling/autoscalinggroup.go
* ./pkg/cloud/services/autoscaling/mock_autoscalingiface
* ./pkg/cloud/services/autoscaling/mock_autoscalingiface/autoscalingapi_mock.go
* ./pkg/cloud/services/autoscaling/autoscalinggroup_test.go


Discussion:
@damdo: See examples on how to migrate here: https://github.com/kubernetes-sigs/cluster-api-provider-aws/pull/5389@alexander-demicev: /assign@alexander-demicev: I will work on it

Solution patch:
diff --git a/controlplane/rosa/controllers/rosacontrolplane_controller.go b/controlplane/rosa/controllers/rosacontrolplane_controller.go
index d01d40ec2..dc29d03eb 100644
--- a/controlplane/rosa/controllers/rosacontrolplane_controller.go
+++ b/controlplane/rosa/controllers/rosacontrolplane_controller.go
@@ -112,7 +112,7 @@ func (r *ROSAControlPlaneReconciler) SetupWithManager(ctx context.Context, mgr c
 		Build(r)
 
 	if err != nil {
-		return fmt.Errorf("failed setting up the AWSManagedControlPlane controller manager: %w", err)
+		return fmt.Errorf("failed setting up the ROSAControlPlane controller manager: %w", err)
 	}
 
 	if err = c.Watch(
diff --git a/go.mod b/go.mod
index 33121dc93..e250dd8b1 100644
--- a/go.mod
+++ b/go.mod
@@ -11,9 +11,11 @@ require (
 	github.com/aws/amazon-vpc-cni-k8s v1.15.5
 	github.com/aws/aws-lambda-go v1.41.0
 	github.com/aws/aws-sdk-go v1.55.5
-	github.com/aws/aws-sdk-go-v2 v1.30.3
+	github.com/aws/aws-sdk-go-v2 v1.36.3
 	github.com/aws/aws-sdk-go-v2/config v1.27.11
 	github.com/aws/aws-sdk-go-v2/credentials v1.17.11
+	github.com/aws/aws-sdk-go-v2/service/autoscaling v1.52.4
+	github.com/aws/aws-sdk-go-v2/service/iam v1.32.0
 	github.com/aws/aws-sdk-go-v2/service/s3 v1.53.1
 	github.com/aws/aws-sdk-go-v2/service/sts v1.28.6
 	github.com/aws/smithy-go v1.22.2
@@ -77,13 +79,12 @@ require (
 	github.com/asaskevich/govalidator v0.0.0-20200428143746-21a406dcc535 // indirect
 	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.2 // indirect
 	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.1 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.15 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.15 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.34 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.34 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.5 // indirect
 	github.com/aws/aws-sdk-go-v2/service/cloudformation v1.50.0 // indirect
 	github.com/aws/aws-sdk-go-v2/service/ec2 v1.159.0 // indirect
-	github.com/aws/aws-sdk-go-v2/service/iam v1.32.0 // indirect
 	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.2 // indirect
 	github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.3.7 // indirect
 	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.7 // indirect
diff --git a/go.sum b/go.sum
index 7a48e0f90..4853821ff 100644
--- a/go.sum
+++ b/go.sum
@@ -44,8 +44,8 @@ github.com/aws/aws-lambda-go v1.41.0 h1:l/5fyVb6Ud9uYd411xdHZzSf2n86TakxzpvIoz7l
 github.com/aws/aws-lambda-go v1.41.0/go.mod h1:jwFe2KmMsHmffA1X2R09hH6lFzJQxzI8qK17ewzbQMM=
 github.com/aws/aws-sdk-go v1.55.5 h1:KKUZBfBoyqy5d3swXyiC7Q76ic40rYcbqH7qjh59kzU=
 github.com/aws/aws-sdk-go v1.55.5/go.mod h1:eRwEWoyTWFMVYVQzKMNHWP5/RV4xIUGMQfXQHfHkpNU=
-github.com/aws/aws-sdk-go-v2 v1.30.3 h1:jUeBtG0Ih+ZIFH0F4UkmL9w3cSpaMv9tYYDbzILP8dY=
-github.com/aws/aws-sdk-go-v2 v1.30.3/go.mod h1:nIQjQVp5sfpQcTc9mPSr1B0PaWK5ByX9MOoDadSN4lc=
+github.com/aws/aws-sdk-go-v2 v1.36.3 h1:mJoei2CxPutQVxaATCzDUjcZEjVRdpsiiXi2o38yqWM=
+github.com/aws/aws-sdk-go-v2 v1.36.3/go.mod h1:LLXuLpgzEbD766Z5ECcRmi8AzSwfZItDtmABVkRLGzg=
 github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.2 h1:x6xsQXGSmW6frevwDA+vi/wqhp1ct18mVXYN08/93to=
 github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.2/go.mod h1:lPprDr1e6cJdyYeGXnRaJoP4Md+cDBvi2eOj00BlGmg=
 github.com/aws/aws-sdk-go-v2/config v1.27.11 h1:f47rANd2LQEYHda2ddSCKYId18/8BhSRM4BULGmfgNA=
@@ -54,14 +54,16 @@ github.com/aws/aws-sdk-go-v2/credentials v1.17.11 h1:YuIB1dJNf1Re822rriUOTxopaHH
 github.com/aws/aws-sdk-go-v2/credentials v1.17.11/go.mod h1:AQtFPsDH9bI2O+71anW6EKL+NcD7LG3dpKGMV4SShgo=
 github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.1 h1:FVJ0r5XTHSmIHJV6KuDmdYhEpvlHpiSd38RQWhut5J4=
 github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.1/go.mod h1:zusuAeqezXzAB24LGuzuekqMAEgWkVYukBec3kr3jUg=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.15 h1:SoNJ4RlFEQEbtDcCEt+QG56MY4fm4W8rYirAmq+/DdU=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.15/go.mod h1:U9ke74k1n2bf+RIgoX1SXFed1HLs51OgUSs+Ph0KJP8=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.15 h1:C6WHdGnTDIYETAm5iErQUiVNsclNx9qbJVPIt03B6bI=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.15/go.mod h1:ZQLZqhcu+JhSrA9/NXRm8SkDvsycE+JkV3WGY41e+IM=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.34 h1:ZK5jHhnrioRkUNOc+hOgQKlUL5JeC3S6JgLxtQ+Rm0Q=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.34/go.mod h1:p4VfIceZokChbA9FzMbRGz5OV+lekcVtHlPKEO0gSZY=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.34 h1:SZwFm17ZUNNg5Np0ioo/gq8Mn6u9w19Mri8DnJ15Jf0=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.34/go.mod h1:dFZsC0BLo346mvKQLWmoJxT+Sjp+qcVR1tRVHQGOH9Q=
 github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0 h1:hT8rVHwugYE2lEfdFE0QWVo81lF7jMrYJVDWI+f+VxU=
 github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0/go.mod h1:8tu/lYfQfFe6IGnaOdrpVgEL2IrrDOf6/m9RQum4NkY=
 github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.5 h1:81KE7vaZzrl7yHBYHVEzYB8sypz11NMOZ40YlWvPxsU=
 github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.5/go.mod h1:LIt2rg7Mcgn09Ygbdh/RdIm0rQ+3BNkbP1gyVMFtRK0=
+github.com/aws/aws-sdk-go-v2/service/autoscaling v1.52.4 h1:vzLD0FyNU4uxf2QE5UDG0jSEitiJXbVEUwf2Sk3usF4=
+github.com/aws/aws-sdk-go-v2/service/autoscaling v1.52.4/go.mod h1:CDqMoc3KRdZJ8qziW96J35lKH01Wq3B2aihtHj2JbRs=
 github.com/aws/aws-sdk-go-v2/service/cloudformation v1.50.0 h1:Ap5tOJfeAH1hO2UQc3X3uMlwP7uryFeZXMvZCXIlLSE=
 github.com/aws/aws-sdk-go-v2/service/cloudformation v1.50.0/go.mod h1:/v2KYdCW4BaHKayenaWEXOOdxItIwEA3oU0XzuQY3F0=
 github.com/aws/aws-sdk-go-v2/service/ec2 v1.159.0 h1:DmmVmiLPlcntOcjWMRwDPMNx/wi2kAVrf2ZmSN5gkAg=
diff --git a/pkg/cloud/converters/tags.go b/pkg/cloud/converters/tags.go
index c46c412d7..79461038d 100644
--- a/pkg/cloud/converters/tags.go
+++ b/pkg/cloud/converters/tags.go
@@ -18,9 +18,10 @@ package converters
 
 import (
 	"sort"
+	"strings"
 
+	autoscalingtypes "github.com/aws/aws-sdk-go-v2/service/autoscaling/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/autoscaling"
 	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/aws/aws-sdk-go/service/elb"
 	"github.com/aws/aws-sdk-go/service/elbv2"
@@ -58,12 +59,14 @@ func MapToTags(src infrav1.Tags) []*ec2.Tag {
 	tags := make([]*ec2.Tag, 0, len(src))
 
 	for k, v := range src {
-		tag := &ec2.Tag{
-			Key:   aws.String(k),
-			Value: aws.String(v),
-		}
+		if !strings.HasPrefix(k, "aws:") {
+			tag := &ec2.Tag{
+				Key:   aws.String(k),
+				Value: aws.String(v),
+			}
 
-		tags = append(tags, tag)
+			tags = append(tags, tag)
+		}
 	}
 
 	// Sort so that unit tests can expect a stable order
@@ -190,7 +193,7 @@ func MapToIAMTags(src infrav1.Tags) []*iam.Tag {
 }
 
 // ASGTagsToMap converts a []*autoscaling.TagDescription into a infrav1.Tags.
-func ASGTagsToMap(src []*autoscaling.TagDescription) infrav1.Tags {
+func ASGTagsToMap(src []autoscalingtypes.TagDescription) infrav1.Tags {
 	tags := make(infrav1.Tags, len(src))
 
 	for _, t := range src {
diff --git a/pkg/cloud/scope/clients.go b/pkg/cloud/scope/clients.go
index 8b8e03f4d..105b59032 100644
--- a/pkg/cloud/scope/clients.go
+++ b/pkg/cloud/scope/clients.go
@@ -17,12 +17,11 @@ limitations under the License.
 package scope
 
 import (
+	"github.com/aws/aws-sdk-go-v2/service/autoscaling"
 	"github.com/aws/aws-sdk-go-v2/service/s3"
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/autoscaling"
-	"github.com/aws/aws-sdk-go/service/autoscaling/autoscalingiface"
 	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
 	"github.com/aws/aws-sdk-go/service/eks"
@@ -58,13 +57,21 @@ import (
 )
 
 // NewASGClient creates a new ASG API client for a given session.
-func NewASGClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) autoscalingiface.AutoScalingAPI {
-	asgClient := autoscaling.New(session.Session(), aws.NewConfig().WithLogLevel(awslogs.GetAWSLogLevel(logger.GetLogger())).WithLogger(awslogs.NewWrapLogr(logger.GetLogger())))
-	asgClient.Handlers.Build.PushFrontNamed(getUserAgentHandler())
-	asgClient.Handlers.CompleteAttempt.PushFront(awsmetrics.CaptureRequestMetrics(scopeUser.ControllerName()))
-	asgClient.Handlers.Complete.PushBack(recordAWSPermissionsIssue(target))
+func NewASGClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) *autoscaling.Client {
+	cfg := session.SessionV2()
+
+	autoscalingOpts := []func(*autoscaling.Options){
+		func(o *autoscaling.Options) {
+			o.Logger = logger.GetAWSLogger()
+			o.ClientLogMode = awslogs.GetAWSLogLevelV2(logger.GetLogger())
+		},
+		autoscaling.WithAPIOptions(
+			awsmetricsv2.WithMiddlewares(scopeUser.ControllerName(), target),
+			awsmetricsv2.WithCAPAUserAgentMiddleware(),
+		),
+	}
 
-	return asgClient
+	return autoscaling.NewFromConfig(cfg, autoscalingOpts...)
 }
 
 // NewEC2Client creates a new EC2 API client for a given session.
@@ -238,7 +245,7 @@ func getUserAgentHandler() request.NamedHandler {
 
 // AWSClients contains all the aws clients used by the scopes.
 type AWSClients struct {
-	ASG             autoscalingiface.AutoScalingAPI
+	ASG             autoscaling.Client
 	EC2             ec2iface.EC2API
 	ELB             elbiface.ELBAPI
 	SecretsManager  secretsmanageriface.SecretsManagerAPI
diff --git a/pkg/cloud/services/autoscaling/autoscalinggroup.go b/pkg/cloud/services/autoscaling/autoscalinggroup.go
index 3108dbfbc..57f900bfa 100644
--- a/pkg/cloud/services/autoscaling/autoscalinggroup.go
+++ b/pkg/cloud/services/autoscaling/autoscalinggroup.go
@@ -22,9 +22,11 @@ import (
 	"fmt"
 	"sort"
 	"strings"
+	"time"
 
+	"github.com/aws/aws-sdk-go-v2/service/autoscaling"
+	autoscalingtypes "github.com/aws/aws-sdk-go-v2/service/autoscaling/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/autoscaling"
 	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/pkg/errors"
 	corev1 "k8s.io/api/core/v1"
@@ -36,18 +38,19 @@ import (
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/converters"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/record"
+	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/utils"
 	"sigs.k8s.io/cluster-api/util/annotations"
 )
 
 // SDKToAutoScalingGroup converts an AWS EC2 SDK AutoScalingGroup to the CAPA AutoScalingGroup type.
-func (s *Service) SDKToAutoScalingGroup(v *autoscaling.Group) (*expinfrav1.AutoScalingGroup, error) {
+func (s *Service) SDKToAutoScalingGroup(v *autoscalingtypes.AutoScalingGroup) (*expinfrav1.AutoScalingGroup, error) {
 	i := &expinfrav1.AutoScalingGroup{
 		ID:   aws.StringValue(v.AutoScalingGroupARN),
 		Name: aws.StringValue(v.AutoScalingGroupName),
 		// TODO(rudoi): this is just terrible
-		DesiredCapacity:   aws.Int32(int32(aws.Int64Value(v.DesiredCapacity))), //#nosec G115
-		MaxSize:           int32(aws.Int64Value(v.MaxSize)),                    //#nosec G115
-		MinSize:           int32(aws.Int64Value(v.MinSize)),                    //#nosec G115
+		DesiredCapacity:   v.DesiredCapacity,
+		MaxSize:           aws.Int32Value(v.MaxSize), //#nosec G115
+		MinSize:           aws.Int32Value(v.MaxSize), //#nosec G115
 		CapacityRebalance: aws.BoolValue(v.CapacityRebalance),
 		// TODO: determine what additional values go here and what else should be in the struct
 	}
@@ -59,8 +62,8 @@ func (s *Service) SDKToAutoScalingGroup(v *autoscaling.Group) (*expinfrav1.AutoS
 	if v.MixedInstancesPolicy != nil {
 		i.MixedInstancesPolicy = &expinfrav1.MixedInstancesPolicy{
 			InstancesDistribution: &expinfrav1.InstancesDistribution{
-				OnDemandBaseCapacity:                v.MixedInstancesPolicy.InstancesDistribution.OnDemandBaseCapacity,
-				OnDemandPercentageAboveBaseCapacity: v.MixedInstancesPolicy.InstancesDistribution.OnDemandPercentageAboveBaseCapacity,
+				OnDemandBaseCapacity:                utils.ToInt64Pointer(v.MixedInstancesPolicy.InstancesDistribution.OnDemandBaseCapacity),
+				OnDemandPercentageAboveBaseCapacity: utils.ToInt64Pointer(v.MixedInstancesPolicy.InstancesDistribution.OnDemandPercentageAboveBaseCapacity),
 			},
 		}
 
@@ -105,7 +108,7 @@ func (s *Service) SDKToAutoScalingGroup(v *autoscaling.Group) (*expinfrav1.AutoS
 		for _, autoscalingInstance := range v.Instances {
 			tmp := &infrav1.Instance{
 				ID:               aws.StringValue(autoscalingInstance.InstanceId),
-				State:            infrav1.InstanceState(*autoscalingInstance.LifecycleState),
+				State:            infrav1.InstanceState(autoscalingInstance.LifecycleState),
 				AvailabilityZone: *autoscalingInstance.AvailabilityZone,
 			}
 			i.Instances = append(i.Instances, *tmp)
@@ -133,10 +136,10 @@ func (s *Service) ASGIfExists(name *string) (*expinfrav1.AutoScalingGroup, error
 	s.scope.Info("Looking for asg by name", "name", *name)
 
 	input := &autoscaling.DescribeAutoScalingGroupsInput{
-		AutoScalingGroupNames: []*string{name},
+		AutoScalingGroupNames: []string{*name},
 	}
 
-	out, err := s.ASGClient.DescribeAutoScalingGroupsWithContext(context.TODO(), input)
+	out, err := s.ASGClient.DescribeAutoScalingGroups(context.TODO(), input)
 	switch {
 	case awserrors.IsNotFound(err):
 		return nil, nil
@@ -147,7 +150,7 @@ func (s *Service) ASGIfExists(name *string) (*expinfrav1.AutoScalingGroup, error
 		record.Eventf(s.scope.InfraCluster(), corev1.EventTypeNormal, expinfrav1.ASGNotFoundReason, "Unable to find ASG matching %q", *name)
 		return nil, nil
 	}
-	return s.SDKToAutoScalingGroup(out.AutoScalingGroups[0])
+	return s.SDKToAutoScalingGroup(&out.AutoScalingGroups[0])
 }
 
 // GetASGByName returns the existing ASG or nothing if it doesn't exist.
@@ -189,23 +192,23 @@ func (s *Service) CreateASG(machinePoolScope *scope.MachinePoolScope) (*expinfra
 
 	input := &autoscaling.CreateAutoScalingGroupInput{
 		AutoScalingGroupName:           aws.String(name),
-		MaxSize:                        aws.Int64(int64(machinePoolScope.AWSMachinePool.Spec.MaxSize)),
-		MinSize:                        aws.Int64(int64(machinePoolScope.AWSMachinePool.Spec.MinSize)),
+		MaxSize:                        aws.Int32(machinePoolScope.AWSMachinePool.Spec.MaxSize),
+		MinSize:                        aws.Int32(machinePoolScope.AWSMachinePool.Spec.MinSize),
 		VPCZoneIdentifier:              aws.String(strings.Join(subnets, ", ")),
-		DefaultCooldown:                aws.Int64(int64(machinePoolScope.AWSMachinePool.Spec.DefaultCoolDown.Duration.Seconds())),
-		DefaultInstanceWarmup:          aws.Int64(int64(machinePoolScope.AWSMachinePool.Spec.DefaultInstanceWarmup.Duration.Seconds())),
+		DefaultCooldown:                aws.Int32(int32(machinePoolScope.AWSMachinePool.Spec.DefaultCoolDown.Duration.Seconds())),
+		DefaultInstanceWarmup:          aws.Int32(int32(machinePoolScope.AWSMachinePool.Spec.DefaultInstanceWarmup.Duration.Seconds())),
 		CapacityRebalance:              aws.Bool(machinePoolScope.AWSMachinePool.Spec.CapacityRebalance),
 		LifecycleHookSpecificationList: getLifecycleHookSpecificationList(machinePoolScope.GetLifecycleHooks()),
 	}
 
 	if desiredCapacity != nil {
-		input.DesiredCapacity = aws.Int64(int64(aws.Int32Value(desiredCapacity)))
+		input.DesiredCapacity = aws.Int32(*desiredCapacity)
 	}
 
 	if machinePoolScope.AWSMachinePool.Spec.MixedInstancesPolicy != nil {
 		input.MixedInstancesPolicy = createSDKMixedInstancesPolicy(name, machinePoolScope.AWSMachinePool.Spec.MixedInstancesPolicy)
 	} else {
-		input.LaunchTemplate = &autoscaling.LaunchTemplateSpecification{
+		input.LaunchTemplate = &autoscalingtypes.LaunchTemplateSpecification{
 			LaunchTemplateId: aws.String(machinePoolScope.AWSMachinePool.Status.LaunchTemplateID),
 			Version:          aws.String(expinfrav1.LaunchTemplateLatestVersion),
 		}
@@ -219,7 +222,7 @@ func (s *Service) CreateASG(machinePoolScope *scope.MachinePoolScope) (*expinfra
 		Additional:  additionalTags,
 	}))
 
-	if _, err := s.ASGClient.CreateAutoScalingGroupWithContext(context.TODO(), input); err != nil {
+	if _, err := s.ASGClient.CreateAutoScalingGroup(context.TODO(), input); err != nil {
 		s.scope.Error(err, "unable to create AutoScalingGroup")
 		return nil, errors.Wrap(err, "failed to create autoscaling group")
 	}
@@ -238,10 +241,12 @@ func (s *Service) DeleteASGAndWait(name string) error {
 	s.scope.Debug("Waiting for ASG to be deleted", "name", name)
 
 	input := &autoscaling.DescribeAutoScalingGroupsInput{
-		AutoScalingGroupNames: aws.StringSlice([]string{name}),
+		AutoScalingGroupNames: []string{name},
 	}
 
-	if err := s.ASGClient.WaitUntilGroupNotExistsWithContext(context.TODO(), input); err != nil {
+	waiter := autoscaling.NewGroupNotExistsWaiter(s.ASGClient)
+
+	if err := waiter.Wait(context.TODO(), input, 15*time.Minute); err != nil {
 		return errors.Wrapf(err, "failed to wait for ASG %q deletion", name)
 	}
 
@@ -257,7 +262,7 @@ func (s *Service) DeleteASG(name string) error {
 		ForceDelete:          aws.Bool(true),
 	}
 
-	if _, err := s.ASGClient.DeleteAutoScalingGroupWithContext(context.TODO(), input); err != nil {
+	if _, err := s.ASGClient.DeleteAutoScalingGroup(context.TODO(), input); err != nil {
 		return errors.Wrapf(err, "failed to delete ASG %q", name)
 	}
 
@@ -274,26 +279,26 @@ func (s *Service) UpdateASG(machinePoolScope *scope.MachinePoolScope) error {
 
 	input := &autoscaling.UpdateAutoScalingGroupInput{
 		AutoScalingGroupName: aws.String(machinePoolScope.Name()), // TODO: define dynamically - borrow logic from ec2
-		MaxSize:              aws.Int64(int64(machinePoolScope.AWSMachinePool.Spec.MaxSize)),
-		MinSize:              aws.Int64(int64(machinePoolScope.AWSMachinePool.Spec.MinSize)),
+		MaxSize:              aws.Int32(machinePoolScope.AWSMachinePool.Spec.MaxSize),
+		MinSize:              aws.Int32(machinePoolScope.AWSMachinePool.Spec.MinSize),
 		VPCZoneIdentifier:    aws.String(strings.Join(subnetIDs, ",")),
 		CapacityRebalance:    aws.Bool(machinePoolScope.AWSMachinePool.Spec.CapacityRebalance),
 	}
 
 	if machinePoolScope.MachinePool.Spec.Replicas != nil && !annotations.ReplicasManagedByExternalAutoscaler(machinePoolScope.MachinePool) {
-		input.DesiredCapacity = aws.Int64(int64(*machinePoolScope.MachinePool.Spec.Replicas))
+		input.DesiredCapacity = aws.Int32(*machinePoolScope.MachinePool.Spec.Replicas)
 	}
 
 	if machinePoolScope.AWSMachinePool.Spec.MixedInstancesPolicy != nil {
 		input.MixedInstancesPolicy = createSDKMixedInstancesPolicy(machinePoolScope.Name(), machinePoolScope.AWSMachinePool.Spec.MixedInstancesPolicy)
 	} else {
-		input.LaunchTemplate = &autoscaling.LaunchTemplateSpecification{
+		input.LaunchTemplate = &autoscalingtypes.LaunchTemplateSpecification{
 			LaunchTemplateId: aws.String(machinePoolScope.AWSMachinePool.Status.LaunchTemplateID),
 			Version:          aws.String(expinfrav1.LaunchTemplateLatestVersion),
 		}
 	}
 
-	if _, err := s.ASGClient.UpdateAutoScalingGroupWithContext(context.TODO(), input); err != nil {
+	if _, err := s.ASGClient.UpdateAutoScalingGroup(context.TODO(), input); err != nil {
 		return errors.Wrapf(err, "failed to update ASG %q", machinePoolScope.Name())
 	}
 
@@ -303,16 +308,16 @@ func (s *Service) UpdateASG(machinePoolScope *scope.MachinePoolScope) error {
 // CanStartASGInstanceRefresh will start an ASG instance with refresh.
 func (s *Service) CanStartASGInstanceRefresh(scope *scope.MachinePoolScope) (bool, error) {
 	describeInput := &autoscaling.DescribeInstanceRefreshesInput{AutoScalingGroupName: aws.String(scope.Name())}
-	refreshes, err := s.ASGClient.DescribeInstanceRefreshesWithContext(context.TODO(), describeInput)
+	refreshes, err := s.ASGClient.DescribeInstanceRefreshes(context.TODO(), describeInput)
 	if err != nil {
 		return false, err
 	}
 	hasUnfinishedRefresh := false
 	if len(refreshes.InstanceRefreshes) != 0 {
 		for i := range refreshes.InstanceRefreshes {
-			if *refreshes.InstanceRefreshes[i].Status == autoscaling.InstanceRefreshStatusInProgress ||
-				*refreshes.InstanceRefreshes[i].Status == autoscaling.InstanceRefreshStatusPending ||
-				*refreshes.InstanceRefreshes[i].Status == autoscaling.InstanceRefreshStatusCancelling {
+			if refreshes.InstanceRefreshes[i].Status == autoscalingtypes.InstanceRefreshStatusInProgress ||
+				refreshes.InstanceRefreshes[i].Status == autoscalingtypes.InstanceRefreshStatusPending ||
+				refreshes.InstanceRefreshes[i].Status == autoscalingtypes.InstanceRefreshStatusCancelling {
 				hasUnfinishedRefresh = true
 			}
 		}
@@ -325,44 +330,44 @@ func (s *Service) CanStartASGInstanceRefresh(scope *scope.MachinePoolScope) (boo
 
 // StartASGInstanceRefresh will start an ASG instance with refresh.
 func (s *Service) StartASGInstanceRefresh(scope *scope.MachinePoolScope) error {
-	strategy := ptr.To[string](autoscaling.RefreshStrategyRolling)
-	var minHealthyPercentage, maxHealthyPercentage, instanceWarmup *int64
+	strategy := ptr.To(autoscalingtypes.RefreshStrategyRolling)
+	var minHealthyPercentage, maxHealthyPercentage, instanceWarmup *int32
 	if scope.AWSMachinePool.Spec.RefreshPreferences != nil {
 		if scope.AWSMachinePool.Spec.RefreshPreferences.Strategy != nil {
-			strategy = scope.AWSMachinePool.Spec.RefreshPreferences.Strategy
+			strategy = ptr.To(autoscalingtypes.RefreshStrategy(*scope.AWSMachinePool.Spec.RefreshPreferences.Strategy))
 		}
 		if scope.AWSMachinePool.Spec.RefreshPreferences.InstanceWarmup != nil {
-			instanceWarmup = scope.AWSMachinePool.Spec.RefreshPreferences.InstanceWarmup
+			instanceWarmup = utils.ToInt32Pointer(scope.AWSMachinePool.Spec.RefreshPreferences.InstanceWarmup)
 		}
 		if scope.AWSMachinePool.Spec.RefreshPreferences.MinHealthyPercentage != nil {
-			minHealthyPercentage = scope.AWSMachinePool.Spec.RefreshPreferences.MinHealthyPercentage
+			minHealthyPercentage = utils.ToInt32Pointer(scope.AWSMachinePool.Spec.RefreshPreferences.MinHealthyPercentage)
 		}
 		if scope.AWSMachinePool.Spec.RefreshPreferences.MaxHealthyPercentage != nil {
-			maxHealthyPercentage = scope.AWSMachinePool.Spec.RefreshPreferences.MaxHealthyPercentage
+			maxHealthyPercentage = utils.ToInt32Pointer(scope.AWSMachinePool.Spec.RefreshPreferences.MaxHealthyPercentage)
 		}
 	}
 
 	input := &autoscaling.StartInstanceRefreshInput{
 		AutoScalingGroupName: aws.String(scope.Name()),
-		Strategy:             strategy,
-		Preferences: &autoscaling.RefreshPreferences{
+		Strategy:             *strategy,
+		Preferences: &autoscalingtypes.RefreshPreferences{
 			InstanceWarmup:       instanceWarmup,
 			MinHealthyPercentage: minHealthyPercentage,
 			MaxHealthyPercentage: maxHealthyPercentage,
 		},
 	}
 
-	if _, err := s.ASGClient.StartInstanceRefreshWithContext(context.TODO(), input); err != nil {
+	if _, err := s.ASGClient.StartInstanceRefresh(context.TODO(), input); err != nil {
 		return errors.Wrapf(err, "failed to start ASG instance refresh %q", scope.Name())
 	}
 
 	return nil
 }
 
-func createSDKMixedInstancesPolicy(name string, i *expinfrav1.MixedInstancesPolicy) *autoscaling.MixedInstancesPolicy {
-	mixedInstancesPolicy := &autoscaling.MixedInstancesPolicy{
-		LaunchTemplate: &autoscaling.LaunchTemplate{
-			LaunchTemplateSpecification: &autoscaling.LaunchTemplateSpecification{
+func createSDKMixedInstancesPolicy(name string, i *expinfrav1.MixedInstancesPolicy) *autoscalingtypes.MixedInstancesPolicy {
+	mixedInstancesPolicy := &autoscalingtypes.MixedInstancesPolicy{
+		LaunchTemplate: &autoscalingtypes.LaunchTemplate{
+			LaunchTemplateSpecification: &autoscalingtypes.LaunchTemplateSpecification{
 				LaunchTemplateName: aws.String(name),
 				Version:            aws.String(expinfrav1.LaunchTemplateLatestVersion),
 			},
@@ -370,16 +375,16 @@ func createSDKMixedInstancesPolicy(name string, i *expinfrav1.MixedInstancesPoli
 	}
 
 	if i.InstancesDistribution != nil {
-		mixedInstancesPolicy.InstancesDistribution = &autoscaling.InstancesDistribution{
+		mixedInstancesPolicy.InstancesDistribution = &autoscalingtypes.InstancesDistribution{
 			OnDemandAllocationStrategy:          aws.String(string(i.InstancesDistribution.OnDemandAllocationStrategy)),
-			OnDemandBaseCapacity:                i.InstancesDistribution.OnDemandBaseCapacity,
-			OnDemandPercentageAboveBaseCapacity: i.InstancesDistribution.OnDemandPercentageAboveBaseCapacity,
+			OnDemandBaseCapacity:                utils.ToInt32Pointer(i.InstancesDistribution.OnDemandBaseCapacity),
+			OnDemandPercentageAboveBaseCapacity: utils.ToInt32Pointer(i.InstancesDistribution.OnDemandPercentageAboveBaseCapacity),
 			SpotAllocationStrategy:              aws.String(string(i.InstancesDistribution.SpotAllocationStrategy)),
 		}
 	}
 
 	for _, override := range i.Overrides {
-		mixedInstancesPolicy.LaunchTemplate.Overrides = append(mixedInstancesPolicy.LaunchTemplate.Overrides, &autoscaling.LaunchTemplateOverrides{
+		mixedInstancesPolicy.LaunchTemplate.Overrides = append(mixedInstancesPolicy.LaunchTemplate.Overrides, autoscalingtypes.LaunchTemplateOverrides{
 			InstanceType: aws.String(override.InstanceType),
 		})
 	}
@@ -388,13 +393,13 @@ func createSDKMixedInstancesPolicy(name string, i *expinfrav1.MixedInstancesPoli
 }
 
 // BuildTagsFromMap takes a map of keys and values and returns them as autoscaling group tags.
-func BuildTagsFromMap(asgName string, inTags map[string]string) []*autoscaling.Tag {
+func BuildTagsFromMap(asgName string, inTags map[string]string) []autoscalingtypes.Tag {
 	if inTags == nil {
 		return nil
 	}
-	tags := make([]*autoscaling.Tag, 0)
+	tags := make([]autoscalingtypes.Tag, 0)
 	for k, v := range inTags {
-		tags = append(tags, &autoscaling.Tag{
+		tags = append(tags, autoscalingtypes.Tag{
 			Key:   aws.String(k),
 			Value: aws.String(v),
 			// We set the instance tags in the LaunchTemplate, disabling propagation to prevent the two
@@ -427,7 +432,7 @@ func (s *Service) UpdateResourceTags(resourceID *string, create, remove map[stri
 
 		createOrUpdateTagsInput.Tags = mapToTags(create, resourceID)
 
-		if _, err := s.ASGClient.CreateOrUpdateTagsWithContext(context.TODO(), createOrUpdateTagsInput); err != nil {
+		if _, err := s.ASGClient.CreateOrUpdateTags(context.TODO(), createOrUpdateTagsInput); err != nil {
 			return errors.Wrapf(err, "failed to update tags on AutoScalingGroup %q", *resourceID)
 		}
 	}
@@ -445,7 +450,7 @@ func (s *Service) UpdateResourceTags(resourceID *string, create, remove map[stri
 		}
 
 		// Delete tags in AWS.
-		if _, err := s.ASGClient.DeleteTagsWithContext(context.TODO(), input); err != nil {
+		if _, err := s.ASGClient.DeleteTags(context.TODO(), input); err != nil {
 			return errors.Wrapf(err, "failed to delete tags on AutoScalingGroup %q: %v", *resourceID, remove)
 		}
 	}
@@ -455,11 +460,11 @@ func (s *Service) UpdateResourceTags(resourceID *string, create, remove map[stri
 
 // SuspendProcesses suspends the processes for an autoscaling group.
 func (s *Service) SuspendProcesses(name string, processes []string) error {
-	input := autoscaling.ScalingProcessQuery{
+	input := autoscaling.SuspendProcessesInput{
 		AutoScalingGroupName: aws.String(name),
-		ScalingProcesses:     aws.StringSlice(processes),
+		ScalingProcesses:     processes,
 	}
-	if _, err := s.ASGClient.SuspendProcessesWithContext(context.TODO(), &input); err != nil {
+	if _, err := s.ASGClient.SuspendProcesses(context.TODO(), &input); err != nil {
 		return errors.Wrapf(err, "failed to suspend processes for AutoScalingGroup: %q", name)
 	}
 	return nil
@@ -467,20 +472,20 @@ func (s *Service) SuspendProcesses(name string, processes []string) error {
 
 // ResumeProcesses resumes the processes for an autoscaling group.
 func (s *Service) ResumeProcesses(name string, processes []string) error {
-	input := autoscaling.ScalingProcessQuery{
+	input := autoscaling.ResumeProcessesInput{
 		AutoScalingGroupName: aws.String(name),
-		ScalingProcesses:     aws.StringSlice(processes),
+		ScalingProcesses:     processes,
 	}
-	if _, err := s.ASGClient.ResumeProcessesWithContext(context.TODO(), &input); err != nil {
+	if _, err := s.ASGClient.ResumeProcesses(context.TODO(), &input); err != nil {
 		return errors.Wrapf(err, "failed to resume processes for AutoScalingGroup: %q", name)
 	}
 	return nil
 }
 
-func mapToTags(input map[string]string, resourceID *string) []*autoscaling.Tag {
-	tags := make([]*autoscaling.Tag, 0)
+func mapToTags(input map[string]string, resourceID *string) []autoscalingtypes.Tag {
+	tags := make([]autoscalingtypes.Tag, 0)
 	for k, v := range input {
-		tags = append(tags, &autoscaling.Tag{
+		tags = append(tags, autoscalingtypes.Tag{
 			Key:               aws.String(k),
 			PropagateAtLaunch: aws.Bool(false),
 			ResourceId:        resourceID,
diff --git a/pkg/cloud/services/autoscaling/lifecyclehook.go b/pkg/cloud/services/autoscaling/lifecyclehook.go
index 3559a799c..9f153fe0f 100644
--- a/pkg/cloud/services/autoscaling/lifecyclehook.go
+++ b/pkg/cloud/services/autoscaling/lifecyclehook.go
@@ -20,8 +20,9 @@ import (
 	"context"
 	"time"
 
+	"github.com/aws/aws-sdk-go-v2/service/autoscaling"
+	autoscalingtypes "github.com/aws/aws-sdk-go-v2/service/autoscaling/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/autoscaling"
 	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/utils/ptr"
@@ -39,7 +40,7 @@ func (s *Service) DescribeLifecycleHooks(asgName string) ([]*expinfrav1.AWSLifec
 		AutoScalingGroupName: ptr.To(asgName),
 	}
 
-	out, err := s.ASGClient.DescribeLifecycleHooksWithContext(context.TODO(), input)
+	out, err := s.ASGClient.DescribeLifecycleHooks(context.TODO(), input)
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed to describe lifecycle hooks for AutoScalingGroup: %q", asgName)
 	}
@@ -68,7 +69,7 @@ func getPutLifecycleHookInput(asgName string, hook *expinfrav1.AWSLifecycleHook)
 	// settings are reconciled to the desired state on update. Using AWS default values here.
 	ret.DefaultResult = ptr.To(ptr.Deref(hook.DefaultResult, expinfrav1.LifecycleHookDefaultResultAbandon).String())
 	timeoutSeconds := ptr.Deref(hook.HeartbeatTimeout, metav1.Duration{Duration: 3600 * time.Second}).Duration.Seconds()
-	ret.HeartbeatTimeout = aws.Int64(int64(timeoutSeconds))
+	ret.HeartbeatTimeout = aws.Int32(int32(timeoutSeconds))
 
 	return
 }
@@ -77,7 +78,7 @@ func getPutLifecycleHookInput(asgName string, hook *expinfrav1.AWSLifecycleHook)
 func (s *Service) CreateLifecycleHook(ctx context.Context, asgName string, hook *expinfrav1.AWSLifecycleHook) error {
 	input := getPutLifecycleHookInput(asgName, hook)
 
-	if _, err := s.ASGClient.PutLifecycleHookWithContext(ctx, input); err != nil {
+	if _, err := s.ASGClient.PutLifecycleHook(ctx, input); err != nil {
 		return errors.Wrapf(err, "failed to create lifecycle hook %q for AutoScalingGroup: %q", hook.Name, asgName)
 	}
 
@@ -88,7 +89,7 @@ func (s *Service) CreateLifecycleHook(ctx context.Context, asgName string, hook
 func (s *Service) UpdateLifecycleHook(ctx context.Context, asgName string, hook *expinfrav1.AWSLifecycleHook) error {
 	input := getPutLifecycleHookInput(asgName, hook)
 
-	if _, err := s.ASGClient.PutLifecycleHookWithContext(ctx, input); err != nil {
+	if _, err := s.ASGClient.PutLifecycleHook(ctx, input); err != nil {
 		return errors.Wrapf(err, "failed to update lifecycle hook %q for AutoScalingGroup: %q", hook.Name, asgName)
 	}
 
@@ -102,7 +103,7 @@ func (s *Service) DeleteLifecycleHook(ctx context.Context, asgName string, hook
 		LifecycleHookName:    ptr.To(hook.Name),
 	}
 
-	if _, err := s.ASGClient.DeleteLifecycleHookWithContext(ctx, input); err != nil {
+	if _, err := s.ASGClient.DeleteLifecycleHook(ctx, input); err != nil {
 		return errors.Wrapf(err, "failed to delete lifecycle hook %q for AutoScalingGroup: %q", hook.Name, asgName)
 	}
 
@@ -110,7 +111,7 @@ func (s *Service) DeleteLifecycleHook(ctx context.Context, asgName string, hook
 }
 
 // SDKToLifecycleHook converts an AWS SDK LifecycleHook to the CAPA lifecycle hook type.
-func (s *Service) SDKToLifecycleHook(hook *autoscaling.LifecycleHook) *expinfrav1.AWSLifecycleHook {
+func (s *Service) SDKToLifecycleHook(hook autoscalingtypes.LifecycleHook) *expinfrav1.AWSLifecycleHook {
 	timeoutDuration := time.Duration(*hook.HeartbeatTimeout) * time.Second
 	metav1Duration := metav1.Duration{Duration: timeoutDuration}
 	defaultResult := expinfrav1.LifecycleHookDefaultResult(*hook.DefaultResult)
@@ -127,9 +128,9 @@ func (s *Service) SDKToLifecycleHook(hook *autoscaling.LifecycleHook) *expinfrav
 	}
 }
 
-func getLifecycleHookSpecificationList(lifecycleHooks []expinfrav1.AWSLifecycleHook) (ret []*autoscaling.LifecycleHookSpecification) {
+func getLifecycleHookSpecificationList(lifecycleHooks []expinfrav1.AWSLifecycleHook) (ret []autoscalingtypes.LifecycleHookSpecification) {
 	for _, hook := range lifecycleHooks {
-		spec := &autoscaling.LifecycleHookSpecification{
+		spec := autoscalingtypes.LifecycleHookSpecification{
 			LifecycleHookName:   ptr.To(hook.Name),
 			LifecycleTransition: ptr.To(hook.LifecycleTransition.String()),
 
@@ -146,7 +147,7 @@ func getLifecycleHookSpecificationList(lifecycleHooks []expinfrav1.AWSLifecycleH
 
 		if hook.HeartbeatTimeout != nil {
 			timeoutSeconds := hook.HeartbeatTimeout.Duration.Seconds()
-			spec.HeartbeatTimeout = aws.Int64(int64(timeoutSeconds))
+			spec.HeartbeatTimeout = aws.Int32(int32(timeoutSeconds))
 		}
 
 		ret = append(ret, spec)
diff --git a/pkg/cloud/services/autoscaling/mock_autoscalingiface/autoscaling_mock.go b/pkg/cloud/services/autoscaling/mock_autoscalingiface/autoscaling_mock.go
new file mode 100644
index 000000000..2f03a558d
--- /dev/null
+++ b/pkg/cloud/services/autoscaling/mock_autoscalingiface/autoscaling_mock.go
@@ -0,0 +1,312 @@
+/*
+Copyright The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by MockGen. DO NOT EDIT.
+// Source: sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/autoscaling (interfaces: AutoScalingAPI)
+
+// Package mock_autoscalingiface is a generated GoMock package.
+package mock_autoscalingiface
+
+import (
+	context "context"
+	reflect "reflect"
+
+	autoscaling "github.com/aws/aws-sdk-go-v2/service/autoscaling"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockAutoScalingAPI is a mock of AutoScalingAPI interface.
+type MockAutoScalingAPI struct {
+	ctrl     *gomock.Controller
+	recorder *MockAutoScalingAPIMockRecorder
+}
+
+// MockAutoScalingAPIMockRecorder is the mock recorder for MockAutoScalingAPI.
+type MockAutoScalingAPIMockRecorder struct {
+	mock *MockAutoScalingAPI
+}
+
+// NewMockAutoScalingAPI creates a new mock instance.
+func NewMockAutoScalingAPI(ctrl *gomock.Controller) *MockAutoScalingAPI {
+	mock := &MockAutoScalingAPI{ctrl: ctrl}
+	mock.recorder = &MockAutoScalingAPIMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockAutoScalingAPI) EXPECT() *MockAutoScalingAPIMockRecorder {
+	return m.recorder
+}
+
+// CreateAutoScalingGroup mocks base method.
+func (m *MockAutoScalingAPI) CreateAutoScalingGroup(arg0 context.Context, arg1 *autoscaling.CreateAutoScalingGroupInput, arg2 ...func(*autoscaling.Options)) (*autoscaling.CreateAutoScalingGroupOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateAutoScalingGroup", varargs...)
+	ret0, _ := ret[0].(*autoscaling.CreateAutoScalingGroupOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateAutoScalingGroup indicates an expected call of CreateAutoScalingGroup.
+func (mr *MockAutoScalingAPIMockRecorder) CreateAutoScalingGroup(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAutoScalingGroup", reflect.TypeOf((*MockAutoScalingAPI)(nil).CreateAutoScalingGroup), varargs...)
+}
+
+// CreateOrUpdateTags mocks base method.
+func (m *MockAutoScalingAPI) CreateOrUpdateTags(arg0 context.Context, arg1 *autoscaling.CreateOrUpdateTagsInput, arg2 ...func(*autoscaling.Options)) (*autoscaling.CreateOrUpdateTagsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateOrUpdateTags", varargs...)
+	ret0, _ := ret[0].(*autoscaling.CreateOrUpdateTagsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateOrUpdateTags indicates an expected call of CreateOrUpdateTags.
+func (mr *MockAutoScalingAPIMockRecorder) CreateOrUpdateTags(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateTags", reflect.TypeOf((*MockAutoScalingAPI)(nil).CreateOrUpdateTags), varargs...)
+}
+
+// DeleteAutoScalingGroup mocks base method.
+func (m *MockAutoScalingAPI) DeleteAutoScalingGroup(arg0 context.Context, arg1 *autoscaling.DeleteAutoScalingGroupInput, arg2 ...func(*autoscaling.Options)) (*autoscaling.DeleteAutoScalingGroupOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteAutoScalingGroup", varargs...)
+	ret0, _ := ret[0].(*autoscaling.DeleteAutoScalingGroupOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteAutoScalingGroup indicates an expected call of DeleteAutoScalingGroup.
+func (mr *MockAutoScalingAPIMockRecorder) DeleteAutoScalingGroup(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAutoScalingGroup", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteAutoScalingGroup), varargs...)
+}
+
+// DeleteLifecycleHook mocks base method.
+func (m *MockAutoScalingAPI) DeleteLifecycleHook(arg0 context.Context, arg1 *autoscaling.DeleteLifecycleHookInput, arg2 ...func(*autoscaling.Options)) (*autoscaling.DeleteLifecycleHookOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteLifecycleHook", varargs...)
+	ret0, _ := ret[0].(*autoscaling.DeleteLifecycleHookOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteLifecycleHook indicates an expected call of DeleteLifecycleHook.
+func (mr *MockAutoScalingAPIMockRecorder) DeleteLifecycleHook(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLifecycleHook", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteLifecycleHook), varargs...)
+}
+
+// DeleteTags mocks base method.
+func (m *MockAutoScalingAPI) DeleteTags(arg0 context.Context, arg1 *autoscaling.DeleteTagsInput, arg2 ...func(*autoscaling.Options)) (*autoscaling.DeleteTagsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteTags", varargs...)
+	ret0, _ := ret[0].(*autoscaling.DeleteTagsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteTags indicates an expected call of DeleteTags.
+func (mr *MockAutoScalingAPIMockRecorder) DeleteTags(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTags", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteTags), varargs...)
+}
+
+// DescribeAutoScalingGroups mocks base method.
+func (m *MockAutoScalingAPI) DescribeAutoScalingGroups(arg0 context.Context, arg1 *autoscaling.DescribeAutoScalingGroupsInput, arg2 ...func(*autoscaling.Options)) (*autoscaling.DescribeAutoScalingGroupsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeAutoScalingGroups", varargs...)
+	ret0, _ := ret[0].(*autoscaling.DescribeAutoScalingGroupsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeAutoScalingGroups indicates an expected call of DescribeAutoScalingGroups.
+func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingGroups(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingGroups", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingGroups), varargs...)
+}
+
+// DescribeInstanceRefreshes mocks base method.
+func (m *MockAutoScalingAPI) DescribeInstanceRefreshes(arg0 context.Context, arg1 *autoscaling.DescribeInstanceRefreshesInput, arg2 ...func(*autoscaling.Options)) (*autoscaling.DescribeInstanceRefreshesOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeInstanceRefreshes", varargs...)
+	ret0, _ := ret[0].(*autoscaling.DescribeInstanceRefreshesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeInstanceRefreshes indicates an expected call of DescribeInstanceRefreshes.
+func (mr *MockAutoScalingAPIMockRecorder) DescribeInstanceRefreshes(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceRefreshes", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeInstanceRefreshes), varargs...)
+}
+
+// DescribeLifecycleHooks mocks base method.
+func (m *MockAutoScalingAPI) DescribeLifecycleHooks(arg0 context.Context, arg1 *autoscaling.DescribeLifecycleHooksInput, arg2 ...func(*autoscaling.Options)) (*autoscaling.DescribeLifecycleHooksOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeLifecycleHooks", varargs...)
+	ret0, _ := ret[0].(*autoscaling.DescribeLifecycleHooksOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeLifecycleHooks indicates an expected call of DescribeLifecycleHooks.
+func (mr *MockAutoScalingAPIMockRecorder) DescribeLifecycleHooks(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLifecycleHooks", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLifecycleHooks), varargs...)
+}
+
+// PutLifecycleHook mocks base method.
+func (m *MockAutoScalingAPI) PutLifecycleHook(arg0 context.Context, arg1 *autoscaling.PutLifecycleHookInput, arg2 ...func(*autoscaling.Options)) (*autoscaling.PutLifecycleHookOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PutLifecycleHook", varargs...)
+	ret0, _ := ret[0].(*autoscaling.PutLifecycleHookOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PutLifecycleHook indicates an expected call of PutLifecycleHook.
+func (mr *MockAutoScalingAPIMockRecorder) PutLifecycleHook(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutLifecycleHook", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutLifecycleHook), varargs...)
+}
+
+// ResumeProcesses mocks base method.
+func (m *MockAutoScalingAPI) ResumeProcesses(arg0 context.Context, arg1 *autoscaling.ResumeProcessesInput, arg2 ...func(*autoscaling.Options)) (*autoscaling.ResumeProcessesOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ResumeProcesses", varargs...)
+	ret0, _ := ret[0].(*autoscaling.ResumeProcessesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ResumeProcesses indicates an expected call of ResumeProcesses.
+func (mr *MockAutoScalingAPIMockRecorder) ResumeProcesses(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeProcesses", reflect.TypeOf((*MockAutoScalingAPI)(nil).ResumeProcesses), varargs...)
+}
+
+// StartInstanceRefresh mocks base method.
+func (m *MockAutoScalingAPI) StartInstanceRefresh(arg0 context.Context, arg1 *autoscaling.StartInstanceRefreshInput, arg2 ...func(*autoscaling.Options)) (*autoscaling.StartInstanceRefreshOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "StartInstanceRefresh", varargs...)
+	ret0, _ := ret[0].(*autoscaling.StartInstanceRefreshOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// StartInstanceRefresh indicates an expected call of StartInstanceRefresh.
+func (mr *MockAutoScalingAPIMockRecorder) StartInstanceRefresh(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstanceRefresh", reflect.TypeOf((*MockAutoScalingAPI)(nil).StartInstanceRefresh), varargs...)
+}
+
+// SuspendProcesses mocks base method.
+func (m *MockAutoScalingAPI) SuspendProcesses(arg0 context.Context, arg1 *autoscaling.SuspendProcessesInput, arg2 ...func(*autoscaling.Options)) (*autoscaling.SuspendProcessesOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SuspendProcesses", varargs...)
+	ret0, _ := ret[0].(*autoscaling.SuspendProcessesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SuspendProcesses indicates an expected call of SuspendProcesses.
+func (mr *MockAutoScalingAPIMockRecorder) SuspendProcesses(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuspendProcesses", reflect.TypeOf((*MockAutoScalingAPI)(nil).SuspendProcesses), varargs...)
+}
+
+// UpdateAutoScalingGroup mocks base method.
+func (m *MockAutoScalingAPI) UpdateAutoScalingGroup(arg0 context.Context, arg1 *autoscaling.UpdateAutoScalingGroupInput, arg2 ...func(*autoscaling.Options)) (*autoscaling.UpdateAutoScalingGroupOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UpdateAutoScalingGroup", varargs...)
+	ret0, _ := ret[0].(*autoscaling.UpdateAutoScalingGroupOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateAutoScalingGroup indicates an expected call of UpdateAutoScalingGroup.
+func (mr *MockAutoScalingAPIMockRecorder) UpdateAutoScalingGroup(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAutoScalingGroup", reflect.TypeOf((*MockAutoScalingAPI)(nil).UpdateAutoScalingGroup), varargs...)
+}
diff --git a/pkg/cloud/services/autoscaling/mock_autoscalingiface/autoscalingapi_mock.go b/pkg/cloud/services/autoscaling/mock_autoscalingiface/autoscalingapi_mock.go
deleted file mode 100644
index 58e83111b..000000000
--- a/pkg/cloud/services/autoscaling/mock_autoscalingiface/autoscalingapi_mock.go
+++ /dev/null
@@ -1,3831 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/aws/aws-sdk-go/service/autoscaling/autoscalingiface (interfaces: AutoScalingAPI)
-
-// Package mock_autoscalingiface is a generated GoMock package.
-package mock_autoscalingiface
-
-import (
-	context "context"
-	reflect "reflect"
-
-	request "github.com/aws/aws-sdk-go/aws/request"
-	autoscaling "github.com/aws/aws-sdk-go/service/autoscaling"
-	gomock "github.com/golang/mock/gomock"
-)
-
-// MockAutoScalingAPI is a mock of AutoScalingAPI interface.
-type MockAutoScalingAPI struct {
-	ctrl     *gomock.Controller
-	recorder *MockAutoScalingAPIMockRecorder
-}
-
-// MockAutoScalingAPIMockRecorder is the mock recorder for MockAutoScalingAPI.
-type MockAutoScalingAPIMockRecorder struct {
-	mock *MockAutoScalingAPI
-}
-
-// NewMockAutoScalingAPI creates a new mock instance.
-func NewMockAutoScalingAPI(ctrl *gomock.Controller) *MockAutoScalingAPI {
-	mock := &MockAutoScalingAPI{ctrl: ctrl}
-	mock.recorder = &MockAutoScalingAPIMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockAutoScalingAPI) EXPECT() *MockAutoScalingAPIMockRecorder {
-	return m.recorder
-}
-
-// AttachInstances mocks base method.
-func (m *MockAutoScalingAPI) AttachInstances(arg0 *autoscaling.AttachInstancesInput) (*autoscaling.AttachInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AttachInstances", arg0)
-	ret0, _ := ret[0].(*autoscaling.AttachInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AttachInstances indicates an expected call of AttachInstances.
-func (mr *MockAutoScalingAPIMockRecorder) AttachInstances(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachInstances", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachInstances), arg0)
-}
-
-// AttachInstancesRequest mocks base method.
-func (m *MockAutoScalingAPI) AttachInstancesRequest(arg0 *autoscaling.AttachInstancesInput) (*request.Request, *autoscaling.AttachInstancesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AttachInstancesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.AttachInstancesOutput)
-	return ret0, ret1
-}
-
-// AttachInstancesRequest indicates an expected call of AttachInstancesRequest.
-func (mr *MockAutoScalingAPIMockRecorder) AttachInstancesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachInstancesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachInstancesRequest), arg0)
-}
-
-// AttachInstancesWithContext mocks base method.
-func (m *MockAutoScalingAPI) AttachInstancesWithContext(arg0 context.Context, arg1 *autoscaling.AttachInstancesInput, arg2 ...request.Option) (*autoscaling.AttachInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "AttachInstancesWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.AttachInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AttachInstancesWithContext indicates an expected call of AttachInstancesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) AttachInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachInstancesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachInstancesWithContext), varargs...)
-}
-
-// AttachLoadBalancerTargetGroups mocks base method.
-func (m *MockAutoScalingAPI) AttachLoadBalancerTargetGroups(arg0 *autoscaling.AttachLoadBalancerTargetGroupsInput) (*autoscaling.AttachLoadBalancerTargetGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AttachLoadBalancerTargetGroups", arg0)
-	ret0, _ := ret[0].(*autoscaling.AttachLoadBalancerTargetGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AttachLoadBalancerTargetGroups indicates an expected call of AttachLoadBalancerTargetGroups.
-func (mr *MockAutoScalingAPIMockRecorder) AttachLoadBalancerTargetGroups(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachLoadBalancerTargetGroups", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachLoadBalancerTargetGroups), arg0)
-}
-
-// AttachLoadBalancerTargetGroupsRequest mocks base method.
-func (m *MockAutoScalingAPI) AttachLoadBalancerTargetGroupsRequest(arg0 *autoscaling.AttachLoadBalancerTargetGroupsInput) (*request.Request, *autoscaling.AttachLoadBalancerTargetGroupsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AttachLoadBalancerTargetGroupsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.AttachLoadBalancerTargetGroupsOutput)
-	return ret0, ret1
-}
-
-// AttachLoadBalancerTargetGroupsRequest indicates an expected call of AttachLoadBalancerTargetGroupsRequest.
-func (mr *MockAutoScalingAPIMockRecorder) AttachLoadBalancerTargetGroupsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachLoadBalancerTargetGroupsRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachLoadBalancerTargetGroupsRequest), arg0)
-}
-
-// AttachLoadBalancerTargetGroupsWithContext mocks base method.
-func (m *MockAutoScalingAPI) AttachLoadBalancerTargetGroupsWithContext(arg0 context.Context, arg1 *autoscaling.AttachLoadBalancerTargetGroupsInput, arg2 ...request.Option) (*autoscaling.AttachLoadBalancerTargetGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "AttachLoadBalancerTargetGroupsWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.AttachLoadBalancerTargetGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AttachLoadBalancerTargetGroupsWithContext indicates an expected call of AttachLoadBalancerTargetGroupsWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) AttachLoadBalancerTargetGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachLoadBalancerTargetGroupsWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachLoadBalancerTargetGroupsWithContext), varargs...)
-}
-
-// AttachLoadBalancers mocks base method.
-func (m *MockAutoScalingAPI) AttachLoadBalancers(arg0 *autoscaling.AttachLoadBalancersInput) (*autoscaling.AttachLoadBalancersOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AttachLoadBalancers", arg0)
-	ret0, _ := ret[0].(*autoscaling.AttachLoadBalancersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AttachLoadBalancers indicates an expected call of AttachLoadBalancers.
-func (mr *MockAutoScalingAPIMockRecorder) AttachLoadBalancers(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachLoadBalancers", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachLoadBalancers), arg0)
-}
-
-// AttachLoadBalancersRequest mocks base method.
-func (m *MockAutoScalingAPI) AttachLoadBalancersRequest(arg0 *autoscaling.AttachLoadBalancersInput) (*request.Request, *autoscaling.AttachLoadBalancersOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AttachLoadBalancersRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.AttachLoadBalancersOutput)
-	return ret0, ret1
-}
-
-// AttachLoadBalancersRequest indicates an expected call of AttachLoadBalancersRequest.
-func (mr *MockAutoScalingAPIMockRecorder) AttachLoadBalancersRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachLoadBalancersRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachLoadBalancersRequest), arg0)
-}
-
-// AttachLoadBalancersWithContext mocks base method.
-func (m *MockAutoScalingAPI) AttachLoadBalancersWithContext(arg0 context.Context, arg1 *autoscaling.AttachLoadBalancersInput, arg2 ...request.Option) (*autoscaling.AttachLoadBalancersOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "AttachLoadBalancersWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.AttachLoadBalancersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AttachLoadBalancersWithContext indicates an expected call of AttachLoadBalancersWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) AttachLoadBalancersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachLoadBalancersWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachLoadBalancersWithContext), varargs...)
-}
-
-// AttachTrafficSources mocks base method.
-func (m *MockAutoScalingAPI) AttachTrafficSources(arg0 *autoscaling.AttachTrafficSourcesInput) (*autoscaling.AttachTrafficSourcesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AttachTrafficSources", arg0)
-	ret0, _ := ret[0].(*autoscaling.AttachTrafficSourcesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AttachTrafficSources indicates an expected call of AttachTrafficSources.
-func (mr *MockAutoScalingAPIMockRecorder) AttachTrafficSources(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachTrafficSources", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachTrafficSources), arg0)
-}
-
-// AttachTrafficSourcesRequest mocks base method.
-func (m *MockAutoScalingAPI) AttachTrafficSourcesRequest(arg0 *autoscaling.AttachTrafficSourcesInput) (*request.Request, *autoscaling.AttachTrafficSourcesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AttachTrafficSourcesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.AttachTrafficSourcesOutput)
-	return ret0, ret1
-}
-
-// AttachTrafficSourcesRequest indicates an expected call of AttachTrafficSourcesRequest.
-func (mr *MockAutoScalingAPIMockRecorder) AttachTrafficSourcesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachTrafficSourcesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachTrafficSourcesRequest), arg0)
-}
-
-// AttachTrafficSourcesWithContext mocks base method.
-func (m *MockAutoScalingAPI) AttachTrafficSourcesWithContext(arg0 context.Context, arg1 *autoscaling.AttachTrafficSourcesInput, arg2 ...request.Option) (*autoscaling.AttachTrafficSourcesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "AttachTrafficSourcesWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.AttachTrafficSourcesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AttachTrafficSourcesWithContext indicates an expected call of AttachTrafficSourcesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) AttachTrafficSourcesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachTrafficSourcesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachTrafficSourcesWithContext), varargs...)
-}
-
-// BatchDeleteScheduledAction mocks base method.
-func (m *MockAutoScalingAPI) BatchDeleteScheduledAction(arg0 *autoscaling.BatchDeleteScheduledActionInput) (*autoscaling.BatchDeleteScheduledActionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "BatchDeleteScheduledAction", arg0)
-	ret0, _ := ret[0].(*autoscaling.BatchDeleteScheduledActionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// BatchDeleteScheduledAction indicates an expected call of BatchDeleteScheduledAction.
-func (mr *MockAutoScalingAPIMockRecorder) BatchDeleteScheduledAction(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDeleteScheduledAction", reflect.TypeOf((*MockAutoScalingAPI)(nil).BatchDeleteScheduledAction), arg0)
-}
-
-// BatchDeleteScheduledActionRequest mocks base method.
-func (m *MockAutoScalingAPI) BatchDeleteScheduledActionRequest(arg0 *autoscaling.BatchDeleteScheduledActionInput) (*request.Request, *autoscaling.BatchDeleteScheduledActionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "BatchDeleteScheduledActionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.BatchDeleteScheduledActionOutput)
-	return ret0, ret1
-}
-
-// BatchDeleteScheduledActionRequest indicates an expected call of BatchDeleteScheduledActionRequest.
-func (mr *MockAutoScalingAPIMockRecorder) BatchDeleteScheduledActionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDeleteScheduledActionRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).BatchDeleteScheduledActionRequest), arg0)
-}
-
-// BatchDeleteScheduledActionWithContext mocks base method.
-func (m *MockAutoScalingAPI) BatchDeleteScheduledActionWithContext(arg0 context.Context, arg1 *autoscaling.BatchDeleteScheduledActionInput, arg2 ...request.Option) (*autoscaling.BatchDeleteScheduledActionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "BatchDeleteScheduledActionWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.BatchDeleteScheduledActionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// BatchDeleteScheduledActionWithContext indicates an expected call of BatchDeleteScheduledActionWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) BatchDeleteScheduledActionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDeleteScheduledActionWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).BatchDeleteScheduledActionWithContext), varargs...)
-}
-
-// BatchPutScheduledUpdateGroupAction mocks base method.
-func (m *MockAutoScalingAPI) BatchPutScheduledUpdateGroupAction(arg0 *autoscaling.BatchPutScheduledUpdateGroupActionInput) (*autoscaling.BatchPutScheduledUpdateGroupActionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "BatchPutScheduledUpdateGroupAction", arg0)
-	ret0, _ := ret[0].(*autoscaling.BatchPutScheduledUpdateGroupActionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// BatchPutScheduledUpdateGroupAction indicates an expected call of BatchPutScheduledUpdateGroupAction.
-func (mr *MockAutoScalingAPIMockRecorder) BatchPutScheduledUpdateGroupAction(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchPutScheduledUpdateGroupAction", reflect.TypeOf((*MockAutoScalingAPI)(nil).BatchPutScheduledUpdateGroupAction), arg0)
-}
-
-// BatchPutScheduledUpdateGroupActionRequest mocks base method.
-func (m *MockAutoScalingAPI) BatchPutScheduledUpdateGroupActionRequest(arg0 *autoscaling.BatchPutScheduledUpdateGroupActionInput) (*request.Request, *autoscaling.BatchPutScheduledUpdateGroupActionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "BatchPutScheduledUpdateGroupActionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.BatchPutScheduledUpdateGroupActionOutput)
-	return ret0, ret1
-}
-
-// BatchPutScheduledUpdateGroupActionRequest indicates an expected call of BatchPutScheduledUpdateGroupActionRequest.
-func (mr *MockAutoScalingAPIMockRecorder) BatchPutScheduledUpdateGroupActionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchPutScheduledUpdateGroupActionRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).BatchPutScheduledUpdateGroupActionRequest), arg0)
-}
-
-// BatchPutScheduledUpdateGroupActionWithContext mocks base method.
-func (m *MockAutoScalingAPI) BatchPutScheduledUpdateGroupActionWithContext(arg0 context.Context, arg1 *autoscaling.BatchPutScheduledUpdateGroupActionInput, arg2 ...request.Option) (*autoscaling.BatchPutScheduledUpdateGroupActionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "BatchPutScheduledUpdateGroupActionWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.BatchPutScheduledUpdateGroupActionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// BatchPutScheduledUpdateGroupActionWithContext indicates an expected call of BatchPutScheduledUpdateGroupActionWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) BatchPutScheduledUpdateGroupActionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchPutScheduledUpdateGroupActionWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).BatchPutScheduledUpdateGroupActionWithContext), varargs...)
-}
-
-// CancelInstanceRefresh mocks base method.
-func (m *MockAutoScalingAPI) CancelInstanceRefresh(arg0 *autoscaling.CancelInstanceRefreshInput) (*autoscaling.CancelInstanceRefreshOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelInstanceRefresh", arg0)
-	ret0, _ := ret[0].(*autoscaling.CancelInstanceRefreshOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelInstanceRefresh indicates an expected call of CancelInstanceRefresh.
-func (mr *MockAutoScalingAPIMockRecorder) CancelInstanceRefresh(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelInstanceRefresh", reflect.TypeOf((*MockAutoScalingAPI)(nil).CancelInstanceRefresh), arg0)
-}
-
-// CancelInstanceRefreshRequest mocks base method.
-func (m *MockAutoScalingAPI) CancelInstanceRefreshRequest(arg0 *autoscaling.CancelInstanceRefreshInput) (*request.Request, *autoscaling.CancelInstanceRefreshOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelInstanceRefreshRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.CancelInstanceRefreshOutput)
-	return ret0, ret1
-}
-
-// CancelInstanceRefreshRequest indicates an expected call of CancelInstanceRefreshRequest.
-func (mr *MockAutoScalingAPIMockRecorder) CancelInstanceRefreshRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelInstanceRefreshRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).CancelInstanceRefreshRequest), arg0)
-}
-
-// CancelInstanceRefreshWithContext mocks base method.
-func (m *MockAutoScalingAPI) CancelInstanceRefreshWithContext(arg0 context.Context, arg1 *autoscaling.CancelInstanceRefreshInput, arg2 ...request.Option) (*autoscaling.CancelInstanceRefreshOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CancelInstanceRefreshWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.CancelInstanceRefreshOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelInstanceRefreshWithContext indicates an expected call of CancelInstanceRefreshWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) CancelInstanceRefreshWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelInstanceRefreshWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).CancelInstanceRefreshWithContext), varargs...)
-}
-
-// CompleteLifecycleAction mocks base method.
-func (m *MockAutoScalingAPI) CompleteLifecycleAction(arg0 *autoscaling.CompleteLifecycleActionInput) (*autoscaling.CompleteLifecycleActionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CompleteLifecycleAction", arg0)
-	ret0, _ := ret[0].(*autoscaling.CompleteLifecycleActionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CompleteLifecycleAction indicates an expected call of CompleteLifecycleAction.
-func (mr *MockAutoScalingAPIMockRecorder) CompleteLifecycleAction(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteLifecycleAction", reflect.TypeOf((*MockAutoScalingAPI)(nil).CompleteLifecycleAction), arg0)
-}
-
-// CompleteLifecycleActionRequest mocks base method.
-func (m *MockAutoScalingAPI) CompleteLifecycleActionRequest(arg0 *autoscaling.CompleteLifecycleActionInput) (*request.Request, *autoscaling.CompleteLifecycleActionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CompleteLifecycleActionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.CompleteLifecycleActionOutput)
-	return ret0, ret1
-}
-
-// CompleteLifecycleActionRequest indicates an expected call of CompleteLifecycleActionRequest.
-func (mr *MockAutoScalingAPIMockRecorder) CompleteLifecycleActionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteLifecycleActionRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).CompleteLifecycleActionRequest), arg0)
-}
-
-// CompleteLifecycleActionWithContext mocks base method.
-func (m *MockAutoScalingAPI) CompleteLifecycleActionWithContext(arg0 context.Context, arg1 *autoscaling.CompleteLifecycleActionInput, arg2 ...request.Option) (*autoscaling.CompleteLifecycleActionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CompleteLifecycleActionWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.CompleteLifecycleActionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CompleteLifecycleActionWithContext indicates an expected call of CompleteLifecycleActionWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) CompleteLifecycleActionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteLifecycleActionWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).CompleteLifecycleActionWithContext), varargs...)
-}
-
-// CreateAutoScalingGroup mocks base method.
-func (m *MockAutoScalingAPI) CreateAutoScalingGroup(arg0 *autoscaling.CreateAutoScalingGroupInput) (*autoscaling.CreateAutoScalingGroupOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateAutoScalingGroup", arg0)
-	ret0, _ := ret[0].(*autoscaling.CreateAutoScalingGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateAutoScalingGroup indicates an expected call of CreateAutoScalingGroup.
-func (mr *MockAutoScalingAPIMockRecorder) CreateAutoScalingGroup(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAutoScalingGroup", reflect.TypeOf((*MockAutoScalingAPI)(nil).CreateAutoScalingGroup), arg0)
-}
-
-// CreateAutoScalingGroupRequest mocks base method.
-func (m *MockAutoScalingAPI) CreateAutoScalingGroupRequest(arg0 *autoscaling.CreateAutoScalingGroupInput) (*request.Request, *autoscaling.CreateAutoScalingGroupOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateAutoScalingGroupRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.CreateAutoScalingGroupOutput)
-	return ret0, ret1
-}
-
-// CreateAutoScalingGroupRequest indicates an expected call of CreateAutoScalingGroupRequest.
-func (mr *MockAutoScalingAPIMockRecorder) CreateAutoScalingGroupRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAutoScalingGroupRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).CreateAutoScalingGroupRequest), arg0)
-}
-
-// CreateAutoScalingGroupWithContext mocks base method.
-func (m *MockAutoScalingAPI) CreateAutoScalingGroupWithContext(arg0 context.Context, arg1 *autoscaling.CreateAutoScalingGroupInput, arg2 ...request.Option) (*autoscaling.CreateAutoScalingGroupOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateAutoScalingGroupWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.CreateAutoScalingGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateAutoScalingGroupWithContext indicates an expected call of CreateAutoScalingGroupWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) CreateAutoScalingGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAutoScalingGroupWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).CreateAutoScalingGroupWithContext), varargs...)
-}
-
-// CreateLaunchConfiguration mocks base method.
-func (m *MockAutoScalingAPI) CreateLaunchConfiguration(arg0 *autoscaling.CreateLaunchConfigurationInput) (*autoscaling.CreateLaunchConfigurationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLaunchConfiguration", arg0)
-	ret0, _ := ret[0].(*autoscaling.CreateLaunchConfigurationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateLaunchConfiguration indicates an expected call of CreateLaunchConfiguration.
-func (mr *MockAutoScalingAPIMockRecorder) CreateLaunchConfiguration(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchConfiguration", reflect.TypeOf((*MockAutoScalingAPI)(nil).CreateLaunchConfiguration), arg0)
-}
-
-// CreateLaunchConfigurationRequest mocks base method.
-func (m *MockAutoScalingAPI) CreateLaunchConfigurationRequest(arg0 *autoscaling.CreateLaunchConfigurationInput) (*request.Request, *autoscaling.CreateLaunchConfigurationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLaunchConfigurationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.CreateLaunchConfigurationOutput)
-	return ret0, ret1
-}
-
-// CreateLaunchConfigurationRequest indicates an expected call of CreateLaunchConfigurationRequest.
-func (mr *MockAutoScalingAPIMockRecorder) CreateLaunchConfigurationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchConfigurationRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).CreateLaunchConfigurationRequest), arg0)
-}
-
-// CreateLaunchConfigurationWithContext mocks base method.
-func (m *MockAutoScalingAPI) CreateLaunchConfigurationWithContext(arg0 context.Context, arg1 *autoscaling.CreateLaunchConfigurationInput, arg2 ...request.Option) (*autoscaling.CreateLaunchConfigurationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateLaunchConfigurationWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.CreateLaunchConfigurationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateLaunchConfigurationWithContext indicates an expected call of CreateLaunchConfigurationWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) CreateLaunchConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchConfigurationWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).CreateLaunchConfigurationWithContext), varargs...)
-}
-
-// CreateOrUpdateTags mocks base method.
-func (m *MockAutoScalingAPI) CreateOrUpdateTags(arg0 *autoscaling.CreateOrUpdateTagsInput) (*autoscaling.CreateOrUpdateTagsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateOrUpdateTags", arg0)
-	ret0, _ := ret[0].(*autoscaling.CreateOrUpdateTagsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateOrUpdateTags indicates an expected call of CreateOrUpdateTags.
-func (mr *MockAutoScalingAPIMockRecorder) CreateOrUpdateTags(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateTags", reflect.TypeOf((*MockAutoScalingAPI)(nil).CreateOrUpdateTags), arg0)
-}
-
-// CreateOrUpdateTagsRequest mocks base method.
-func (m *MockAutoScalingAPI) CreateOrUpdateTagsRequest(arg0 *autoscaling.CreateOrUpdateTagsInput) (*request.Request, *autoscaling.CreateOrUpdateTagsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateOrUpdateTagsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.CreateOrUpdateTagsOutput)
-	return ret0, ret1
-}
-
-// CreateOrUpdateTagsRequest indicates an expected call of CreateOrUpdateTagsRequest.
-func (mr *MockAutoScalingAPIMockRecorder) CreateOrUpdateTagsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateTagsRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).CreateOrUpdateTagsRequest), arg0)
-}
-
-// CreateOrUpdateTagsWithContext mocks base method.
-func (m *MockAutoScalingAPI) CreateOrUpdateTagsWithContext(arg0 context.Context, arg1 *autoscaling.CreateOrUpdateTagsInput, arg2 ...request.Option) (*autoscaling.CreateOrUpdateTagsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateOrUpdateTagsWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.CreateOrUpdateTagsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateOrUpdateTagsWithContext indicates an expected call of CreateOrUpdateTagsWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) CreateOrUpdateTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateTagsWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).CreateOrUpdateTagsWithContext), varargs...)
-}
-
-// DeleteAutoScalingGroup mocks base method.
-func (m *MockAutoScalingAPI) DeleteAutoScalingGroup(arg0 *autoscaling.DeleteAutoScalingGroupInput) (*autoscaling.DeleteAutoScalingGroupOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteAutoScalingGroup", arg0)
-	ret0, _ := ret[0].(*autoscaling.DeleteAutoScalingGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteAutoScalingGroup indicates an expected call of DeleteAutoScalingGroup.
-func (mr *MockAutoScalingAPIMockRecorder) DeleteAutoScalingGroup(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAutoScalingGroup", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteAutoScalingGroup), arg0)
-}
-
-// DeleteAutoScalingGroupRequest mocks base method.
-func (m *MockAutoScalingAPI) DeleteAutoScalingGroupRequest(arg0 *autoscaling.DeleteAutoScalingGroupInput) (*request.Request, *autoscaling.DeleteAutoScalingGroupOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteAutoScalingGroupRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DeleteAutoScalingGroupOutput)
-	return ret0, ret1
-}
-
-// DeleteAutoScalingGroupRequest indicates an expected call of DeleteAutoScalingGroupRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DeleteAutoScalingGroupRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAutoScalingGroupRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteAutoScalingGroupRequest), arg0)
-}
-
-// DeleteAutoScalingGroupWithContext mocks base method.
-func (m *MockAutoScalingAPI) DeleteAutoScalingGroupWithContext(arg0 context.Context, arg1 *autoscaling.DeleteAutoScalingGroupInput, arg2 ...request.Option) (*autoscaling.DeleteAutoScalingGroupOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteAutoScalingGroupWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DeleteAutoScalingGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteAutoScalingGroupWithContext indicates an expected call of DeleteAutoScalingGroupWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DeleteAutoScalingGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAutoScalingGroupWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteAutoScalingGroupWithContext), varargs...)
-}
-
-// DeleteLaunchConfiguration mocks base method.
-func (m *MockAutoScalingAPI) DeleteLaunchConfiguration(arg0 *autoscaling.DeleteLaunchConfigurationInput) (*autoscaling.DeleteLaunchConfigurationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLaunchConfiguration", arg0)
-	ret0, _ := ret[0].(*autoscaling.DeleteLaunchConfigurationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteLaunchConfiguration indicates an expected call of DeleteLaunchConfiguration.
-func (mr *MockAutoScalingAPIMockRecorder) DeleteLaunchConfiguration(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchConfiguration", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteLaunchConfiguration), arg0)
-}
-
-// DeleteLaunchConfigurationRequest mocks base method.
-func (m *MockAutoScalingAPI) DeleteLaunchConfigurationRequest(arg0 *autoscaling.DeleteLaunchConfigurationInput) (*request.Request, *autoscaling.DeleteLaunchConfigurationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLaunchConfigurationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DeleteLaunchConfigurationOutput)
-	return ret0, ret1
-}
-
-// DeleteLaunchConfigurationRequest indicates an expected call of DeleteLaunchConfigurationRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DeleteLaunchConfigurationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchConfigurationRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteLaunchConfigurationRequest), arg0)
-}
-
-// DeleteLaunchConfigurationWithContext mocks base method.
-func (m *MockAutoScalingAPI) DeleteLaunchConfigurationWithContext(arg0 context.Context, arg1 *autoscaling.DeleteLaunchConfigurationInput, arg2 ...request.Option) (*autoscaling.DeleteLaunchConfigurationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteLaunchConfigurationWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DeleteLaunchConfigurationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteLaunchConfigurationWithContext indicates an expected call of DeleteLaunchConfigurationWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DeleteLaunchConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchConfigurationWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteLaunchConfigurationWithContext), varargs...)
-}
-
-// DeleteLifecycleHook mocks base method.
-func (m *MockAutoScalingAPI) DeleteLifecycleHook(arg0 *autoscaling.DeleteLifecycleHookInput) (*autoscaling.DeleteLifecycleHookOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLifecycleHook", arg0)
-	ret0, _ := ret[0].(*autoscaling.DeleteLifecycleHookOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteLifecycleHook indicates an expected call of DeleteLifecycleHook.
-func (mr *MockAutoScalingAPIMockRecorder) DeleteLifecycleHook(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLifecycleHook", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteLifecycleHook), arg0)
-}
-
-// DeleteLifecycleHookRequest mocks base method.
-func (m *MockAutoScalingAPI) DeleteLifecycleHookRequest(arg0 *autoscaling.DeleteLifecycleHookInput) (*request.Request, *autoscaling.DeleteLifecycleHookOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLifecycleHookRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DeleteLifecycleHookOutput)
-	return ret0, ret1
-}
-
-// DeleteLifecycleHookRequest indicates an expected call of DeleteLifecycleHookRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DeleteLifecycleHookRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLifecycleHookRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteLifecycleHookRequest), arg0)
-}
-
-// DeleteLifecycleHookWithContext mocks base method.
-func (m *MockAutoScalingAPI) DeleteLifecycleHookWithContext(arg0 context.Context, arg1 *autoscaling.DeleteLifecycleHookInput, arg2 ...request.Option) (*autoscaling.DeleteLifecycleHookOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteLifecycleHookWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DeleteLifecycleHookOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteLifecycleHookWithContext indicates an expected call of DeleteLifecycleHookWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DeleteLifecycleHookWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLifecycleHookWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteLifecycleHookWithContext), varargs...)
-}
-
-// DeleteNotificationConfiguration mocks base method.
-func (m *MockAutoScalingAPI) DeleteNotificationConfiguration(arg0 *autoscaling.DeleteNotificationConfigurationInput) (*autoscaling.DeleteNotificationConfigurationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteNotificationConfiguration", arg0)
-	ret0, _ := ret[0].(*autoscaling.DeleteNotificationConfigurationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteNotificationConfiguration indicates an expected call of DeleteNotificationConfiguration.
-func (mr *MockAutoScalingAPIMockRecorder) DeleteNotificationConfiguration(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNotificationConfiguration", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteNotificationConfiguration), arg0)
-}
-
-// DeleteNotificationConfigurationRequest mocks base method.
-func (m *MockAutoScalingAPI) DeleteNotificationConfigurationRequest(arg0 *autoscaling.DeleteNotificationConfigurationInput) (*request.Request, *autoscaling.DeleteNotificationConfigurationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteNotificationConfigurationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DeleteNotificationConfigurationOutput)
-	return ret0, ret1
-}
-
-// DeleteNotificationConfigurationRequest indicates an expected call of DeleteNotificationConfigurationRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DeleteNotificationConfigurationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNotificationConfigurationRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteNotificationConfigurationRequest), arg0)
-}
-
-// DeleteNotificationConfigurationWithContext mocks base method.
-func (m *MockAutoScalingAPI) DeleteNotificationConfigurationWithContext(arg0 context.Context, arg1 *autoscaling.DeleteNotificationConfigurationInput, arg2 ...request.Option) (*autoscaling.DeleteNotificationConfigurationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteNotificationConfigurationWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DeleteNotificationConfigurationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteNotificationConfigurationWithContext indicates an expected call of DeleteNotificationConfigurationWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DeleteNotificationConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNotificationConfigurationWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteNotificationConfigurationWithContext), varargs...)
-}
-
-// DeletePolicy mocks base method.
-func (m *MockAutoScalingAPI) DeletePolicy(arg0 *autoscaling.DeletePolicyInput) (*autoscaling.DeletePolicyOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeletePolicy", arg0)
-	ret0, _ := ret[0].(*autoscaling.DeletePolicyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeletePolicy indicates an expected call of DeletePolicy.
-func (mr *MockAutoScalingAPIMockRecorder) DeletePolicy(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePolicy", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeletePolicy), arg0)
-}
-
-// DeletePolicyRequest mocks base method.
-func (m *MockAutoScalingAPI) DeletePolicyRequest(arg0 *autoscaling.DeletePolicyInput) (*request.Request, *autoscaling.DeletePolicyOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeletePolicyRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DeletePolicyOutput)
-	return ret0, ret1
-}
-
-// DeletePolicyRequest indicates an expected call of DeletePolicyRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DeletePolicyRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePolicyRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeletePolicyRequest), arg0)
-}
-
-// DeletePolicyWithContext mocks base method.
-func (m *MockAutoScalingAPI) DeletePolicyWithContext(arg0 context.Context, arg1 *autoscaling.DeletePolicyInput, arg2 ...request.Option) (*autoscaling.DeletePolicyOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeletePolicyWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DeletePolicyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeletePolicyWithContext indicates an expected call of DeletePolicyWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DeletePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePolicyWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeletePolicyWithContext), varargs...)
-}
-
-// DeleteScheduledAction mocks base method.
-func (m *MockAutoScalingAPI) DeleteScheduledAction(arg0 *autoscaling.DeleteScheduledActionInput) (*autoscaling.DeleteScheduledActionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteScheduledAction", arg0)
-	ret0, _ := ret[0].(*autoscaling.DeleteScheduledActionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteScheduledAction indicates an expected call of DeleteScheduledAction.
-func (mr *MockAutoScalingAPIMockRecorder) DeleteScheduledAction(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteScheduledAction", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteScheduledAction), arg0)
-}
-
-// DeleteScheduledActionRequest mocks base method.
-func (m *MockAutoScalingAPI) DeleteScheduledActionRequest(arg0 *autoscaling.DeleteScheduledActionInput) (*request.Request, *autoscaling.DeleteScheduledActionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteScheduledActionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DeleteScheduledActionOutput)
-	return ret0, ret1
-}
-
-// DeleteScheduledActionRequest indicates an expected call of DeleteScheduledActionRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DeleteScheduledActionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteScheduledActionRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteScheduledActionRequest), arg0)
-}
-
-// DeleteScheduledActionWithContext mocks base method.
-func (m *MockAutoScalingAPI) DeleteScheduledActionWithContext(arg0 context.Context, arg1 *autoscaling.DeleteScheduledActionInput, arg2 ...request.Option) (*autoscaling.DeleteScheduledActionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteScheduledActionWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DeleteScheduledActionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteScheduledActionWithContext indicates an expected call of DeleteScheduledActionWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DeleteScheduledActionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteScheduledActionWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteScheduledActionWithContext), varargs...)
-}
-
-// DeleteTags mocks base method.
-func (m *MockAutoScalingAPI) DeleteTags(arg0 *autoscaling.DeleteTagsInput) (*autoscaling.DeleteTagsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTags", arg0)
-	ret0, _ := ret[0].(*autoscaling.DeleteTagsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTags indicates an expected call of DeleteTags.
-func (mr *MockAutoScalingAPIMockRecorder) DeleteTags(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTags", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteTags), arg0)
-}
-
-// DeleteTagsRequest mocks base method.
-func (m *MockAutoScalingAPI) DeleteTagsRequest(arg0 *autoscaling.DeleteTagsInput) (*request.Request, *autoscaling.DeleteTagsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTagsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DeleteTagsOutput)
-	return ret0, ret1
-}
-
-// DeleteTagsRequest indicates an expected call of DeleteTagsRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DeleteTagsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTagsRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteTagsRequest), arg0)
-}
-
-// DeleteTagsWithContext mocks base method.
-func (m *MockAutoScalingAPI) DeleteTagsWithContext(arg0 context.Context, arg1 *autoscaling.DeleteTagsInput, arg2 ...request.Option) (*autoscaling.DeleteTagsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteTagsWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DeleteTagsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTagsWithContext indicates an expected call of DeleteTagsWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DeleteTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTagsWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteTagsWithContext), varargs...)
-}
-
-// DeleteWarmPool mocks base method.
-func (m *MockAutoScalingAPI) DeleteWarmPool(arg0 *autoscaling.DeleteWarmPoolInput) (*autoscaling.DeleteWarmPoolOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteWarmPool", arg0)
-	ret0, _ := ret[0].(*autoscaling.DeleteWarmPoolOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteWarmPool indicates an expected call of DeleteWarmPool.
-func (mr *MockAutoScalingAPIMockRecorder) DeleteWarmPool(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWarmPool", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteWarmPool), arg0)
-}
-
-// DeleteWarmPoolRequest mocks base method.
-func (m *MockAutoScalingAPI) DeleteWarmPoolRequest(arg0 *autoscaling.DeleteWarmPoolInput) (*request.Request, *autoscaling.DeleteWarmPoolOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteWarmPoolRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DeleteWarmPoolOutput)
-	return ret0, ret1
-}
-
-// DeleteWarmPoolRequest indicates an expected call of DeleteWarmPoolRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DeleteWarmPoolRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWarmPoolRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteWarmPoolRequest), arg0)
-}
-
-// DeleteWarmPoolWithContext mocks base method.
-func (m *MockAutoScalingAPI) DeleteWarmPoolWithContext(arg0 context.Context, arg1 *autoscaling.DeleteWarmPoolInput, arg2 ...request.Option) (*autoscaling.DeleteWarmPoolOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteWarmPoolWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DeleteWarmPoolOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteWarmPoolWithContext indicates an expected call of DeleteWarmPoolWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DeleteWarmPoolWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWarmPoolWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteWarmPoolWithContext), varargs...)
-}
-
-// DescribeAccountLimits mocks base method.
-func (m *MockAutoScalingAPI) DescribeAccountLimits(arg0 *autoscaling.DescribeAccountLimitsInput) (*autoscaling.DescribeAccountLimitsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAccountLimits", arg0)
-	ret0, _ := ret[0].(*autoscaling.DescribeAccountLimitsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAccountLimits indicates an expected call of DescribeAccountLimits.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeAccountLimits(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimits", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAccountLimits), arg0)
-}
-
-// DescribeAccountLimitsRequest mocks base method.
-func (m *MockAutoScalingAPI) DescribeAccountLimitsRequest(arg0 *autoscaling.DescribeAccountLimitsInput) (*request.Request, *autoscaling.DescribeAccountLimitsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAccountLimitsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DescribeAccountLimitsOutput)
-	return ret0, ret1
-}
-
-// DescribeAccountLimitsRequest indicates an expected call of DescribeAccountLimitsRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeAccountLimitsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimitsRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAccountLimitsRequest), arg0)
-}
-
-// DescribeAccountLimitsWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeAccountLimitsWithContext(arg0 context.Context, arg1 *autoscaling.DescribeAccountLimitsInput, arg2 ...request.Option) (*autoscaling.DescribeAccountLimitsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeAccountLimitsWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DescribeAccountLimitsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAccountLimitsWithContext indicates an expected call of DescribeAccountLimitsWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeAccountLimitsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimitsWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAccountLimitsWithContext), varargs...)
-}
-
-// DescribeAdjustmentTypes mocks base method.
-func (m *MockAutoScalingAPI) DescribeAdjustmentTypes(arg0 *autoscaling.DescribeAdjustmentTypesInput) (*autoscaling.DescribeAdjustmentTypesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAdjustmentTypes", arg0)
-	ret0, _ := ret[0].(*autoscaling.DescribeAdjustmentTypesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAdjustmentTypes indicates an expected call of DescribeAdjustmentTypes.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeAdjustmentTypes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAdjustmentTypes", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAdjustmentTypes), arg0)
-}
-
-// DescribeAdjustmentTypesRequest mocks base method.
-func (m *MockAutoScalingAPI) DescribeAdjustmentTypesRequest(arg0 *autoscaling.DescribeAdjustmentTypesInput) (*request.Request, *autoscaling.DescribeAdjustmentTypesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAdjustmentTypesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DescribeAdjustmentTypesOutput)
-	return ret0, ret1
-}
-
-// DescribeAdjustmentTypesRequest indicates an expected call of DescribeAdjustmentTypesRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeAdjustmentTypesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAdjustmentTypesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAdjustmentTypesRequest), arg0)
-}
-
-// DescribeAdjustmentTypesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeAdjustmentTypesWithContext(arg0 context.Context, arg1 *autoscaling.DescribeAdjustmentTypesInput, arg2 ...request.Option) (*autoscaling.DescribeAdjustmentTypesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeAdjustmentTypesWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DescribeAdjustmentTypesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAdjustmentTypesWithContext indicates an expected call of DescribeAdjustmentTypesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeAdjustmentTypesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAdjustmentTypesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAdjustmentTypesWithContext), varargs...)
-}
-
-// DescribeAutoScalingGroups mocks base method.
-func (m *MockAutoScalingAPI) DescribeAutoScalingGroups(arg0 *autoscaling.DescribeAutoScalingGroupsInput) (*autoscaling.DescribeAutoScalingGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAutoScalingGroups", arg0)
-	ret0, _ := ret[0].(*autoscaling.DescribeAutoScalingGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAutoScalingGroups indicates an expected call of DescribeAutoScalingGroups.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingGroups(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingGroups", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingGroups), arg0)
-}
-
-// DescribeAutoScalingGroupsPages mocks base method.
-func (m *MockAutoScalingAPI) DescribeAutoScalingGroupsPages(arg0 *autoscaling.DescribeAutoScalingGroupsInput, arg1 func(*autoscaling.DescribeAutoScalingGroupsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAutoScalingGroupsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeAutoScalingGroupsPages indicates an expected call of DescribeAutoScalingGroupsPages.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingGroupsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingGroupsPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingGroupsPages), arg0, arg1)
-}
-
-// DescribeAutoScalingGroupsPagesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeAutoScalingGroupsPagesWithContext(arg0 context.Context, arg1 *autoscaling.DescribeAutoScalingGroupsInput, arg2 func(*autoscaling.DescribeAutoScalingGroupsOutput, bool) bool, arg3 ...request.Option) error {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1, arg2}
-	for _, a := range arg3 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeAutoScalingGroupsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeAutoScalingGroupsPagesWithContext indicates an expected call of DescribeAutoScalingGroupsPagesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingGroupsPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingGroupsPagesWithContext), varargs...)
-}
-
-// DescribeAutoScalingGroupsRequest mocks base method.
-func (m *MockAutoScalingAPI) DescribeAutoScalingGroupsRequest(arg0 *autoscaling.DescribeAutoScalingGroupsInput) (*request.Request, *autoscaling.DescribeAutoScalingGroupsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAutoScalingGroupsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DescribeAutoScalingGroupsOutput)
-	return ret0, ret1
-}
-
-// DescribeAutoScalingGroupsRequest indicates an expected call of DescribeAutoScalingGroupsRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingGroupsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingGroupsRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingGroupsRequest), arg0)
-}
-
-// DescribeAutoScalingGroupsWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeAutoScalingGroupsWithContext(arg0 context.Context, arg1 *autoscaling.DescribeAutoScalingGroupsInput, arg2 ...request.Option) (*autoscaling.DescribeAutoScalingGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeAutoScalingGroupsWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DescribeAutoScalingGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAutoScalingGroupsWithContext indicates an expected call of DescribeAutoScalingGroupsWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingGroupsWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingGroupsWithContext), varargs...)
-}
-
-// DescribeAutoScalingInstances mocks base method.
-func (m *MockAutoScalingAPI) DescribeAutoScalingInstances(arg0 *autoscaling.DescribeAutoScalingInstancesInput) (*autoscaling.DescribeAutoScalingInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAutoScalingInstances", arg0)
-	ret0, _ := ret[0].(*autoscaling.DescribeAutoScalingInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAutoScalingInstances indicates an expected call of DescribeAutoScalingInstances.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingInstances(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingInstances", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingInstances), arg0)
-}
-
-// DescribeAutoScalingInstancesPages mocks base method.
-func (m *MockAutoScalingAPI) DescribeAutoScalingInstancesPages(arg0 *autoscaling.DescribeAutoScalingInstancesInput, arg1 func(*autoscaling.DescribeAutoScalingInstancesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAutoScalingInstancesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeAutoScalingInstancesPages indicates an expected call of DescribeAutoScalingInstancesPages.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingInstancesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingInstancesPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingInstancesPages), arg0, arg1)
-}
-
-// DescribeAutoScalingInstancesPagesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeAutoScalingInstancesPagesWithContext(arg0 context.Context, arg1 *autoscaling.DescribeAutoScalingInstancesInput, arg2 func(*autoscaling.DescribeAutoScalingInstancesOutput, bool) bool, arg3 ...request.Option) error {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1, arg2}
-	for _, a := range arg3 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeAutoScalingInstancesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeAutoScalingInstancesPagesWithContext indicates an expected call of DescribeAutoScalingInstancesPagesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingInstancesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingInstancesPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingInstancesPagesWithContext), varargs...)
-}
-
-// DescribeAutoScalingInstancesRequest mocks base method.
-func (m *MockAutoScalingAPI) DescribeAutoScalingInstancesRequest(arg0 *autoscaling.DescribeAutoScalingInstancesInput) (*request.Request, *autoscaling.DescribeAutoScalingInstancesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAutoScalingInstancesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DescribeAutoScalingInstancesOutput)
-	return ret0, ret1
-}
-
-// DescribeAutoScalingInstancesRequest indicates an expected call of DescribeAutoScalingInstancesRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingInstancesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingInstancesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingInstancesRequest), arg0)
-}
-
-// DescribeAutoScalingInstancesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeAutoScalingInstancesWithContext(arg0 context.Context, arg1 *autoscaling.DescribeAutoScalingInstancesInput, arg2 ...request.Option) (*autoscaling.DescribeAutoScalingInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeAutoScalingInstancesWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DescribeAutoScalingInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAutoScalingInstancesWithContext indicates an expected call of DescribeAutoScalingInstancesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingInstancesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingInstancesWithContext), varargs...)
-}
-
-// DescribeAutoScalingNotificationTypes mocks base method.
-func (m *MockAutoScalingAPI) DescribeAutoScalingNotificationTypes(arg0 *autoscaling.DescribeAutoScalingNotificationTypesInput) (*autoscaling.DescribeAutoScalingNotificationTypesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAutoScalingNotificationTypes", arg0)
-	ret0, _ := ret[0].(*autoscaling.DescribeAutoScalingNotificationTypesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAutoScalingNotificationTypes indicates an expected call of DescribeAutoScalingNotificationTypes.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingNotificationTypes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingNotificationTypes", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingNotificationTypes), arg0)
-}
-
-// DescribeAutoScalingNotificationTypesRequest mocks base method.
-func (m *MockAutoScalingAPI) DescribeAutoScalingNotificationTypesRequest(arg0 *autoscaling.DescribeAutoScalingNotificationTypesInput) (*request.Request, *autoscaling.DescribeAutoScalingNotificationTypesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAutoScalingNotificationTypesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DescribeAutoScalingNotificationTypesOutput)
-	return ret0, ret1
-}
-
-// DescribeAutoScalingNotificationTypesRequest indicates an expected call of DescribeAutoScalingNotificationTypesRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingNotificationTypesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingNotificationTypesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingNotificationTypesRequest), arg0)
-}
-
-// DescribeAutoScalingNotificationTypesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeAutoScalingNotificationTypesWithContext(arg0 context.Context, arg1 *autoscaling.DescribeAutoScalingNotificationTypesInput, arg2 ...request.Option) (*autoscaling.DescribeAutoScalingNotificationTypesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeAutoScalingNotificationTypesWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DescribeAutoScalingNotificationTypesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAutoScalingNotificationTypesWithContext indicates an expected call of DescribeAutoScalingNotificationTypesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingNotificationTypesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingNotificationTypesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingNotificationTypesWithContext), varargs...)
-}
-
-// DescribeInstanceRefreshes mocks base method.
-func (m *MockAutoScalingAPI) DescribeInstanceRefreshes(arg0 *autoscaling.DescribeInstanceRefreshesInput) (*autoscaling.DescribeInstanceRefreshesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceRefreshes", arg0)
-	ret0, _ := ret[0].(*autoscaling.DescribeInstanceRefreshesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstanceRefreshes indicates an expected call of DescribeInstanceRefreshes.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeInstanceRefreshes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceRefreshes", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeInstanceRefreshes), arg0)
-}
-
-// DescribeInstanceRefreshesPages mocks base method.
-func (m *MockAutoScalingAPI) DescribeInstanceRefreshesPages(arg0 *autoscaling.DescribeInstanceRefreshesInput, arg1 func(*autoscaling.DescribeInstanceRefreshesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceRefreshesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeInstanceRefreshesPages indicates an expected call of DescribeInstanceRefreshesPages.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeInstanceRefreshesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceRefreshesPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeInstanceRefreshesPages), arg0, arg1)
-}
-
-// DescribeInstanceRefreshesPagesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeInstanceRefreshesPagesWithContext(arg0 context.Context, arg1 *autoscaling.DescribeInstanceRefreshesInput, arg2 func(*autoscaling.DescribeInstanceRefreshesOutput, bool) bool, arg3 ...request.Option) error {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1, arg2}
-	for _, a := range arg3 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeInstanceRefreshesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeInstanceRefreshesPagesWithContext indicates an expected call of DescribeInstanceRefreshesPagesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeInstanceRefreshesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceRefreshesPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeInstanceRefreshesPagesWithContext), varargs...)
-}
-
-// DescribeInstanceRefreshesRequest mocks base method.
-func (m *MockAutoScalingAPI) DescribeInstanceRefreshesRequest(arg0 *autoscaling.DescribeInstanceRefreshesInput) (*request.Request, *autoscaling.DescribeInstanceRefreshesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceRefreshesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DescribeInstanceRefreshesOutput)
-	return ret0, ret1
-}
-
-// DescribeInstanceRefreshesRequest indicates an expected call of DescribeInstanceRefreshesRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeInstanceRefreshesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceRefreshesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeInstanceRefreshesRequest), arg0)
-}
-
-// DescribeInstanceRefreshesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeInstanceRefreshesWithContext(arg0 context.Context, arg1 *autoscaling.DescribeInstanceRefreshesInput, arg2 ...request.Option) (*autoscaling.DescribeInstanceRefreshesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeInstanceRefreshesWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DescribeInstanceRefreshesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstanceRefreshesWithContext indicates an expected call of DescribeInstanceRefreshesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeInstanceRefreshesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceRefreshesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeInstanceRefreshesWithContext), varargs...)
-}
-
-// DescribeLaunchConfigurations mocks base method.
-func (m *MockAutoScalingAPI) DescribeLaunchConfigurations(arg0 *autoscaling.DescribeLaunchConfigurationsInput) (*autoscaling.DescribeLaunchConfigurationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLaunchConfigurations", arg0)
-	ret0, _ := ret[0].(*autoscaling.DescribeLaunchConfigurationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLaunchConfigurations indicates an expected call of DescribeLaunchConfigurations.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeLaunchConfigurations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchConfigurations", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLaunchConfigurations), arg0)
-}
-
-// DescribeLaunchConfigurationsPages mocks base method.
-func (m *MockAutoScalingAPI) DescribeLaunchConfigurationsPages(arg0 *autoscaling.DescribeLaunchConfigurationsInput, arg1 func(*autoscaling.DescribeLaunchConfigurationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLaunchConfigurationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeLaunchConfigurationsPages indicates an expected call of DescribeLaunchConfigurationsPages.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeLaunchConfigurationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchConfigurationsPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLaunchConfigurationsPages), arg0, arg1)
-}
-
-// DescribeLaunchConfigurationsPagesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeLaunchConfigurationsPagesWithContext(arg0 context.Context, arg1 *autoscaling.DescribeLaunchConfigurationsInput, arg2 func(*autoscaling.DescribeLaunchConfigurationsOutput, bool) bool, arg3 ...request.Option) error {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1, arg2}
-	for _, a := range arg3 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeLaunchConfigurationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeLaunchConfigurationsPagesWithContext indicates an expected call of DescribeLaunchConfigurationsPagesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeLaunchConfigurationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchConfigurationsPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLaunchConfigurationsPagesWithContext), varargs...)
-}
-
-// DescribeLaunchConfigurationsRequest mocks base method.
-func (m *MockAutoScalingAPI) DescribeLaunchConfigurationsRequest(arg0 *autoscaling.DescribeLaunchConfigurationsInput) (*request.Request, *autoscaling.DescribeLaunchConfigurationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLaunchConfigurationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DescribeLaunchConfigurationsOutput)
-	return ret0, ret1
-}
-
-// DescribeLaunchConfigurationsRequest indicates an expected call of DescribeLaunchConfigurationsRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeLaunchConfigurationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchConfigurationsRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLaunchConfigurationsRequest), arg0)
-}
-
-// DescribeLaunchConfigurationsWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeLaunchConfigurationsWithContext(arg0 context.Context, arg1 *autoscaling.DescribeLaunchConfigurationsInput, arg2 ...request.Option) (*autoscaling.DescribeLaunchConfigurationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeLaunchConfigurationsWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DescribeLaunchConfigurationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLaunchConfigurationsWithContext indicates an expected call of DescribeLaunchConfigurationsWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeLaunchConfigurationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchConfigurationsWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLaunchConfigurationsWithContext), varargs...)
-}
-
-// DescribeLifecycleHookTypes mocks base method.
-func (m *MockAutoScalingAPI) DescribeLifecycleHookTypes(arg0 *autoscaling.DescribeLifecycleHookTypesInput) (*autoscaling.DescribeLifecycleHookTypesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLifecycleHookTypes", arg0)
-	ret0, _ := ret[0].(*autoscaling.DescribeLifecycleHookTypesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLifecycleHookTypes indicates an expected call of DescribeLifecycleHookTypes.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeLifecycleHookTypes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLifecycleHookTypes", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLifecycleHookTypes), arg0)
-}
-
-// DescribeLifecycleHookTypesRequest mocks base method.
-func (m *MockAutoScalingAPI) DescribeLifecycleHookTypesRequest(arg0 *autoscaling.DescribeLifecycleHookTypesInput) (*request.Request, *autoscaling.DescribeLifecycleHookTypesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLifecycleHookTypesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DescribeLifecycleHookTypesOutput)
-	return ret0, ret1
-}
-
-// DescribeLifecycleHookTypesRequest indicates an expected call of DescribeLifecycleHookTypesRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeLifecycleHookTypesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLifecycleHookTypesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLifecycleHookTypesRequest), arg0)
-}
-
-// DescribeLifecycleHookTypesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeLifecycleHookTypesWithContext(arg0 context.Context, arg1 *autoscaling.DescribeLifecycleHookTypesInput, arg2 ...request.Option) (*autoscaling.DescribeLifecycleHookTypesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeLifecycleHookTypesWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DescribeLifecycleHookTypesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLifecycleHookTypesWithContext indicates an expected call of DescribeLifecycleHookTypesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeLifecycleHookTypesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLifecycleHookTypesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLifecycleHookTypesWithContext), varargs...)
-}
-
-// DescribeLifecycleHooks mocks base method.
-func (m *MockAutoScalingAPI) DescribeLifecycleHooks(arg0 *autoscaling.DescribeLifecycleHooksInput) (*autoscaling.DescribeLifecycleHooksOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLifecycleHooks", arg0)
-	ret0, _ := ret[0].(*autoscaling.DescribeLifecycleHooksOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLifecycleHooks indicates an expected call of DescribeLifecycleHooks.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeLifecycleHooks(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLifecycleHooks", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLifecycleHooks), arg0)
-}
-
-// DescribeLifecycleHooksRequest mocks base method.
-func (m *MockAutoScalingAPI) DescribeLifecycleHooksRequest(arg0 *autoscaling.DescribeLifecycleHooksInput) (*request.Request, *autoscaling.DescribeLifecycleHooksOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLifecycleHooksRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DescribeLifecycleHooksOutput)
-	return ret0, ret1
-}
-
-// DescribeLifecycleHooksRequest indicates an expected call of DescribeLifecycleHooksRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeLifecycleHooksRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLifecycleHooksRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLifecycleHooksRequest), arg0)
-}
-
-// DescribeLifecycleHooksWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeLifecycleHooksWithContext(arg0 context.Context, arg1 *autoscaling.DescribeLifecycleHooksInput, arg2 ...request.Option) (*autoscaling.DescribeLifecycleHooksOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeLifecycleHooksWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DescribeLifecycleHooksOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLifecycleHooksWithContext indicates an expected call of DescribeLifecycleHooksWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeLifecycleHooksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLifecycleHooksWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLifecycleHooksWithContext), varargs...)
-}
-
-// DescribeLoadBalancerTargetGroups mocks base method.
-func (m *MockAutoScalingAPI) DescribeLoadBalancerTargetGroups(arg0 *autoscaling.DescribeLoadBalancerTargetGroupsInput) (*autoscaling.DescribeLoadBalancerTargetGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLoadBalancerTargetGroups", arg0)
-	ret0, _ := ret[0].(*autoscaling.DescribeLoadBalancerTargetGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancerTargetGroups indicates an expected call of DescribeLoadBalancerTargetGroups.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeLoadBalancerTargetGroups(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerTargetGroups", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLoadBalancerTargetGroups), arg0)
-}
-
-// DescribeLoadBalancerTargetGroupsPages mocks base method.
-func (m *MockAutoScalingAPI) DescribeLoadBalancerTargetGroupsPages(arg0 *autoscaling.DescribeLoadBalancerTargetGroupsInput, arg1 func(*autoscaling.DescribeLoadBalancerTargetGroupsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLoadBalancerTargetGroupsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeLoadBalancerTargetGroupsPages indicates an expected call of DescribeLoadBalancerTargetGroupsPages.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeLoadBalancerTargetGroupsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerTargetGroupsPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLoadBalancerTargetGroupsPages), arg0, arg1)
-}
-
-// DescribeLoadBalancerTargetGroupsPagesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeLoadBalancerTargetGroupsPagesWithContext(arg0 context.Context, arg1 *autoscaling.DescribeLoadBalancerTargetGroupsInput, arg2 func(*autoscaling.DescribeLoadBalancerTargetGroupsOutput, bool) bool, arg3 ...request.Option) error {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1, arg2}
-	for _, a := range arg3 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeLoadBalancerTargetGroupsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeLoadBalancerTargetGroupsPagesWithContext indicates an expected call of DescribeLoadBalancerTargetGroupsPagesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeLoadBalancerTargetGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerTargetGroupsPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLoadBalancerTargetGroupsPagesWithContext), varargs...)
-}
-
-// DescribeLoadBalancerTargetGroupsRequest mocks base method.
-func (m *MockAutoScalingAPI) DescribeLoadBalancerTargetGroupsRequest(arg0 *autoscaling.DescribeLoadBalancerTargetGroupsInput) (*request.Request, *autoscaling.DescribeLoadBalancerTargetGroupsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLoadBalancerTargetGroupsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DescribeLoadBalancerTargetGroupsOutput)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancerTargetGroupsRequest indicates an expected call of DescribeLoadBalancerTargetGroupsRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeLoadBalancerTargetGroupsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerTargetGroupsRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLoadBalancerTargetGroupsRequest), arg0)
-}
-
-// DescribeLoadBalancerTargetGroupsWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeLoadBalancerTargetGroupsWithContext(arg0 context.Context, arg1 *autoscaling.DescribeLoadBalancerTargetGroupsInput, arg2 ...request.Option) (*autoscaling.DescribeLoadBalancerTargetGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeLoadBalancerTargetGroupsWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DescribeLoadBalancerTargetGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancerTargetGroupsWithContext indicates an expected call of DescribeLoadBalancerTargetGroupsWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeLoadBalancerTargetGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerTargetGroupsWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLoadBalancerTargetGroupsWithContext), varargs...)
-}
-
-// DescribeLoadBalancers mocks base method.
-func (m *MockAutoScalingAPI) DescribeLoadBalancers(arg0 *autoscaling.DescribeLoadBalancersInput) (*autoscaling.DescribeLoadBalancersOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLoadBalancers", arg0)
-	ret0, _ := ret[0].(*autoscaling.DescribeLoadBalancersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancers indicates an expected call of DescribeLoadBalancers.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeLoadBalancers(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancers", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLoadBalancers), arg0)
-}
-
-// DescribeLoadBalancersPages mocks base method.
-func (m *MockAutoScalingAPI) DescribeLoadBalancersPages(arg0 *autoscaling.DescribeLoadBalancersInput, arg1 func(*autoscaling.DescribeLoadBalancersOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLoadBalancersPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeLoadBalancersPages indicates an expected call of DescribeLoadBalancersPages.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeLoadBalancersPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLoadBalancersPages), arg0, arg1)
-}
-
-// DescribeLoadBalancersPagesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeLoadBalancersPagesWithContext(arg0 context.Context, arg1 *autoscaling.DescribeLoadBalancersInput, arg2 func(*autoscaling.DescribeLoadBalancersOutput, bool) bool, arg3 ...request.Option) error {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1, arg2}
-	for _, a := range arg3 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeLoadBalancersPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeLoadBalancersPagesWithContext indicates an expected call of DescribeLoadBalancersPagesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeLoadBalancersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLoadBalancersPagesWithContext), varargs...)
-}
-
-// DescribeLoadBalancersRequest mocks base method.
-func (m *MockAutoScalingAPI) DescribeLoadBalancersRequest(arg0 *autoscaling.DescribeLoadBalancersInput) (*request.Request, *autoscaling.DescribeLoadBalancersOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLoadBalancersRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DescribeLoadBalancersOutput)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancersRequest indicates an expected call of DescribeLoadBalancersRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeLoadBalancersRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLoadBalancersRequest), arg0)
-}
-
-// DescribeLoadBalancersWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeLoadBalancersWithContext(arg0 context.Context, arg1 *autoscaling.DescribeLoadBalancersInput, arg2 ...request.Option) (*autoscaling.DescribeLoadBalancersOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeLoadBalancersWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DescribeLoadBalancersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancersWithContext indicates an expected call of DescribeLoadBalancersWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeLoadBalancersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLoadBalancersWithContext), varargs...)
-}
-
-// DescribeMetricCollectionTypes mocks base method.
-func (m *MockAutoScalingAPI) DescribeMetricCollectionTypes(arg0 *autoscaling.DescribeMetricCollectionTypesInput) (*autoscaling.DescribeMetricCollectionTypesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeMetricCollectionTypes", arg0)
-	ret0, _ := ret[0].(*autoscaling.DescribeMetricCollectionTypesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeMetricCollectionTypes indicates an expected call of DescribeMetricCollectionTypes.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeMetricCollectionTypes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMetricCollectionTypes", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeMetricCollectionTypes), arg0)
-}
-
-// DescribeMetricCollectionTypesRequest mocks base method.
-func (m *MockAutoScalingAPI) DescribeMetricCollectionTypesRequest(arg0 *autoscaling.DescribeMetricCollectionTypesInput) (*request.Request, *autoscaling.DescribeMetricCollectionTypesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeMetricCollectionTypesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DescribeMetricCollectionTypesOutput)
-	return ret0, ret1
-}
-
-// DescribeMetricCollectionTypesRequest indicates an expected call of DescribeMetricCollectionTypesRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeMetricCollectionTypesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMetricCollectionTypesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeMetricCollectionTypesRequest), arg0)
-}
-
-// DescribeMetricCollectionTypesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeMetricCollectionTypesWithContext(arg0 context.Context, arg1 *autoscaling.DescribeMetricCollectionTypesInput, arg2 ...request.Option) (*autoscaling.DescribeMetricCollectionTypesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeMetricCollectionTypesWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DescribeMetricCollectionTypesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeMetricCollectionTypesWithContext indicates an expected call of DescribeMetricCollectionTypesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeMetricCollectionTypesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMetricCollectionTypesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeMetricCollectionTypesWithContext), varargs...)
-}
-
-// DescribeNotificationConfigurations mocks base method.
-func (m *MockAutoScalingAPI) DescribeNotificationConfigurations(arg0 *autoscaling.DescribeNotificationConfigurationsInput) (*autoscaling.DescribeNotificationConfigurationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNotificationConfigurations", arg0)
-	ret0, _ := ret[0].(*autoscaling.DescribeNotificationConfigurationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeNotificationConfigurations indicates an expected call of DescribeNotificationConfigurations.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeNotificationConfigurations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNotificationConfigurations", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeNotificationConfigurations), arg0)
-}
-
-// DescribeNotificationConfigurationsPages mocks base method.
-func (m *MockAutoScalingAPI) DescribeNotificationConfigurationsPages(arg0 *autoscaling.DescribeNotificationConfigurationsInput, arg1 func(*autoscaling.DescribeNotificationConfigurationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNotificationConfigurationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeNotificationConfigurationsPages indicates an expected call of DescribeNotificationConfigurationsPages.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeNotificationConfigurationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNotificationConfigurationsPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeNotificationConfigurationsPages), arg0, arg1)
-}
-
-// DescribeNotificationConfigurationsPagesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeNotificationConfigurationsPagesWithContext(arg0 context.Context, arg1 *autoscaling.DescribeNotificationConfigurationsInput, arg2 func(*autoscaling.DescribeNotificationConfigurationsOutput, bool) bool, arg3 ...request.Option) error {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1, arg2}
-	for _, a := range arg3 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeNotificationConfigurationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeNotificationConfigurationsPagesWithContext indicates an expected call of DescribeNotificationConfigurationsPagesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeNotificationConfigurationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNotificationConfigurationsPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeNotificationConfigurationsPagesWithContext), varargs...)
-}
-
-// DescribeNotificationConfigurationsRequest mocks base method.
-func (m *MockAutoScalingAPI) DescribeNotificationConfigurationsRequest(arg0 *autoscaling.DescribeNotificationConfigurationsInput) (*request.Request, *autoscaling.DescribeNotificationConfigurationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNotificationConfigurationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DescribeNotificationConfigurationsOutput)
-	return ret0, ret1
-}
-
-// DescribeNotificationConfigurationsRequest indicates an expected call of DescribeNotificationConfigurationsRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeNotificationConfigurationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNotificationConfigurationsRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeNotificationConfigurationsRequest), arg0)
-}
-
-// DescribeNotificationConfigurationsWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeNotificationConfigurationsWithContext(arg0 context.Context, arg1 *autoscaling.DescribeNotificationConfigurationsInput, arg2 ...request.Option) (*autoscaling.DescribeNotificationConfigurationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeNotificationConfigurationsWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DescribeNotificationConfigurationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeNotificationConfigurationsWithContext indicates an expected call of DescribeNotificationConfigurationsWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeNotificationConfigurationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNotificationConfigurationsWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeNotificationConfigurationsWithContext), varargs...)
-}
-
-// DescribePolicies mocks base method.
-func (m *MockAutoScalingAPI) DescribePolicies(arg0 *autoscaling.DescribePoliciesInput) (*autoscaling.DescribePoliciesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribePolicies", arg0)
-	ret0, _ := ret[0].(*autoscaling.DescribePoliciesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribePolicies indicates an expected call of DescribePolicies.
-func (mr *MockAutoScalingAPIMockRecorder) DescribePolicies(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePolicies", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribePolicies), arg0)
-}
-
-// DescribePoliciesPages mocks base method.
-func (m *MockAutoScalingAPI) DescribePoliciesPages(arg0 *autoscaling.DescribePoliciesInput, arg1 func(*autoscaling.DescribePoliciesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribePoliciesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribePoliciesPages indicates an expected call of DescribePoliciesPages.
-func (mr *MockAutoScalingAPIMockRecorder) DescribePoliciesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePoliciesPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribePoliciesPages), arg0, arg1)
-}
-
-// DescribePoliciesPagesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribePoliciesPagesWithContext(arg0 context.Context, arg1 *autoscaling.DescribePoliciesInput, arg2 func(*autoscaling.DescribePoliciesOutput, bool) bool, arg3 ...request.Option) error {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1, arg2}
-	for _, a := range arg3 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribePoliciesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribePoliciesPagesWithContext indicates an expected call of DescribePoliciesPagesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribePoliciesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePoliciesPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribePoliciesPagesWithContext), varargs...)
-}
-
-// DescribePoliciesRequest mocks base method.
-func (m *MockAutoScalingAPI) DescribePoliciesRequest(arg0 *autoscaling.DescribePoliciesInput) (*request.Request, *autoscaling.DescribePoliciesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribePoliciesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DescribePoliciesOutput)
-	return ret0, ret1
-}
-
-// DescribePoliciesRequest indicates an expected call of DescribePoliciesRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DescribePoliciesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePoliciesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribePoliciesRequest), arg0)
-}
-
-// DescribePoliciesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribePoliciesWithContext(arg0 context.Context, arg1 *autoscaling.DescribePoliciesInput, arg2 ...request.Option) (*autoscaling.DescribePoliciesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribePoliciesWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DescribePoliciesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribePoliciesWithContext indicates an expected call of DescribePoliciesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribePoliciesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePoliciesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribePoliciesWithContext), varargs...)
-}
-
-// DescribeScalingActivities mocks base method.
-func (m *MockAutoScalingAPI) DescribeScalingActivities(arg0 *autoscaling.DescribeScalingActivitiesInput) (*autoscaling.DescribeScalingActivitiesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeScalingActivities", arg0)
-	ret0, _ := ret[0].(*autoscaling.DescribeScalingActivitiesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeScalingActivities indicates an expected call of DescribeScalingActivities.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeScalingActivities(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScalingActivities", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScalingActivities), arg0)
-}
-
-// DescribeScalingActivitiesPages mocks base method.
-func (m *MockAutoScalingAPI) DescribeScalingActivitiesPages(arg0 *autoscaling.DescribeScalingActivitiesInput, arg1 func(*autoscaling.DescribeScalingActivitiesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeScalingActivitiesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeScalingActivitiesPages indicates an expected call of DescribeScalingActivitiesPages.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeScalingActivitiesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScalingActivitiesPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScalingActivitiesPages), arg0, arg1)
-}
-
-// DescribeScalingActivitiesPagesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeScalingActivitiesPagesWithContext(arg0 context.Context, arg1 *autoscaling.DescribeScalingActivitiesInput, arg2 func(*autoscaling.DescribeScalingActivitiesOutput, bool) bool, arg3 ...request.Option) error {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1, arg2}
-	for _, a := range arg3 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeScalingActivitiesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeScalingActivitiesPagesWithContext indicates an expected call of DescribeScalingActivitiesPagesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeScalingActivitiesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScalingActivitiesPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScalingActivitiesPagesWithContext), varargs...)
-}
-
-// DescribeScalingActivitiesRequest mocks base method.
-func (m *MockAutoScalingAPI) DescribeScalingActivitiesRequest(arg0 *autoscaling.DescribeScalingActivitiesInput) (*request.Request, *autoscaling.DescribeScalingActivitiesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeScalingActivitiesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DescribeScalingActivitiesOutput)
-	return ret0, ret1
-}
-
-// DescribeScalingActivitiesRequest indicates an expected call of DescribeScalingActivitiesRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeScalingActivitiesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScalingActivitiesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScalingActivitiesRequest), arg0)
-}
-
-// DescribeScalingActivitiesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeScalingActivitiesWithContext(arg0 context.Context, arg1 *autoscaling.DescribeScalingActivitiesInput, arg2 ...request.Option) (*autoscaling.DescribeScalingActivitiesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeScalingActivitiesWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DescribeScalingActivitiesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeScalingActivitiesWithContext indicates an expected call of DescribeScalingActivitiesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeScalingActivitiesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScalingActivitiesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScalingActivitiesWithContext), varargs...)
-}
-
-// DescribeScalingProcessTypes mocks base method.
-func (m *MockAutoScalingAPI) DescribeScalingProcessTypes(arg0 *autoscaling.DescribeScalingProcessTypesInput) (*autoscaling.DescribeScalingProcessTypesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeScalingProcessTypes", arg0)
-	ret0, _ := ret[0].(*autoscaling.DescribeScalingProcessTypesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeScalingProcessTypes indicates an expected call of DescribeScalingProcessTypes.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeScalingProcessTypes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScalingProcessTypes", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScalingProcessTypes), arg0)
-}
-
-// DescribeScalingProcessTypesRequest mocks base method.
-func (m *MockAutoScalingAPI) DescribeScalingProcessTypesRequest(arg0 *autoscaling.DescribeScalingProcessTypesInput) (*request.Request, *autoscaling.DescribeScalingProcessTypesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeScalingProcessTypesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DescribeScalingProcessTypesOutput)
-	return ret0, ret1
-}
-
-// DescribeScalingProcessTypesRequest indicates an expected call of DescribeScalingProcessTypesRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeScalingProcessTypesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScalingProcessTypesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScalingProcessTypesRequest), arg0)
-}
-
-// DescribeScalingProcessTypesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeScalingProcessTypesWithContext(arg0 context.Context, arg1 *autoscaling.DescribeScalingProcessTypesInput, arg2 ...request.Option) (*autoscaling.DescribeScalingProcessTypesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeScalingProcessTypesWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DescribeScalingProcessTypesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeScalingProcessTypesWithContext indicates an expected call of DescribeScalingProcessTypesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeScalingProcessTypesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScalingProcessTypesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScalingProcessTypesWithContext), varargs...)
-}
-
-// DescribeScheduledActions mocks base method.
-func (m *MockAutoScalingAPI) DescribeScheduledActions(arg0 *autoscaling.DescribeScheduledActionsInput) (*autoscaling.DescribeScheduledActionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeScheduledActions", arg0)
-	ret0, _ := ret[0].(*autoscaling.DescribeScheduledActionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeScheduledActions indicates an expected call of DescribeScheduledActions.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeScheduledActions(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledActions", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScheduledActions), arg0)
-}
-
-// DescribeScheduledActionsPages mocks base method.
-func (m *MockAutoScalingAPI) DescribeScheduledActionsPages(arg0 *autoscaling.DescribeScheduledActionsInput, arg1 func(*autoscaling.DescribeScheduledActionsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeScheduledActionsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeScheduledActionsPages indicates an expected call of DescribeScheduledActionsPages.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeScheduledActionsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledActionsPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScheduledActionsPages), arg0, arg1)
-}
-
-// DescribeScheduledActionsPagesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeScheduledActionsPagesWithContext(arg0 context.Context, arg1 *autoscaling.DescribeScheduledActionsInput, arg2 func(*autoscaling.DescribeScheduledActionsOutput, bool) bool, arg3 ...request.Option) error {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1, arg2}
-	for _, a := range arg3 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeScheduledActionsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeScheduledActionsPagesWithContext indicates an expected call of DescribeScheduledActionsPagesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeScheduledActionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledActionsPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScheduledActionsPagesWithContext), varargs...)
-}
-
-// DescribeScheduledActionsRequest mocks base method.
-func (m *MockAutoScalingAPI) DescribeScheduledActionsRequest(arg0 *autoscaling.DescribeScheduledActionsInput) (*request.Request, *autoscaling.DescribeScheduledActionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeScheduledActionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DescribeScheduledActionsOutput)
-	return ret0, ret1
-}
-
-// DescribeScheduledActionsRequest indicates an expected call of DescribeScheduledActionsRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeScheduledActionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledActionsRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScheduledActionsRequest), arg0)
-}
-
-// DescribeScheduledActionsWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeScheduledActionsWithContext(arg0 context.Context, arg1 *autoscaling.DescribeScheduledActionsInput, arg2 ...request.Option) (*autoscaling.DescribeScheduledActionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeScheduledActionsWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DescribeScheduledActionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeScheduledActionsWithContext indicates an expected call of DescribeScheduledActionsWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeScheduledActionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledActionsWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScheduledActionsWithContext), varargs...)
-}
-
-// DescribeTags mocks base method.
-func (m *MockAutoScalingAPI) DescribeTags(arg0 *autoscaling.DescribeTagsInput) (*autoscaling.DescribeTagsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTags", arg0)
-	ret0, _ := ret[0].(*autoscaling.DescribeTagsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTags indicates an expected call of DescribeTags.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeTags(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTags", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTags), arg0)
-}
-
-// DescribeTagsPages mocks base method.
-func (m *MockAutoScalingAPI) DescribeTagsPages(arg0 *autoscaling.DescribeTagsInput, arg1 func(*autoscaling.DescribeTagsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTagsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTagsPages indicates an expected call of DescribeTagsPages.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeTagsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTagsPages), arg0, arg1)
-}
-
-// DescribeTagsPagesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeTagsPagesWithContext(arg0 context.Context, arg1 *autoscaling.DescribeTagsInput, arg2 func(*autoscaling.DescribeTagsOutput, bool) bool, arg3 ...request.Option) error {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1, arg2}
-	for _, a := range arg3 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTagsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTagsPagesWithContext indicates an expected call of DescribeTagsPagesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeTagsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTagsPagesWithContext), varargs...)
-}
-
-// DescribeTagsRequest mocks base method.
-func (m *MockAutoScalingAPI) DescribeTagsRequest(arg0 *autoscaling.DescribeTagsInput) (*request.Request, *autoscaling.DescribeTagsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTagsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DescribeTagsOutput)
-	return ret0, ret1
-}
-
-// DescribeTagsRequest indicates an expected call of DescribeTagsRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeTagsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTagsRequest), arg0)
-}
-
-// DescribeTagsWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeTagsWithContext(arg0 context.Context, arg1 *autoscaling.DescribeTagsInput, arg2 ...request.Option) (*autoscaling.DescribeTagsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTagsWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DescribeTagsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTagsWithContext indicates an expected call of DescribeTagsWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTagsWithContext), varargs...)
-}
-
-// DescribeTerminationPolicyTypes mocks base method.
-func (m *MockAutoScalingAPI) DescribeTerminationPolicyTypes(arg0 *autoscaling.DescribeTerminationPolicyTypesInput) (*autoscaling.DescribeTerminationPolicyTypesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTerminationPolicyTypes", arg0)
-	ret0, _ := ret[0].(*autoscaling.DescribeTerminationPolicyTypesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTerminationPolicyTypes indicates an expected call of DescribeTerminationPolicyTypes.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeTerminationPolicyTypes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTerminationPolicyTypes", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTerminationPolicyTypes), arg0)
-}
-
-// DescribeTerminationPolicyTypesRequest mocks base method.
-func (m *MockAutoScalingAPI) DescribeTerminationPolicyTypesRequest(arg0 *autoscaling.DescribeTerminationPolicyTypesInput) (*request.Request, *autoscaling.DescribeTerminationPolicyTypesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTerminationPolicyTypesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DescribeTerminationPolicyTypesOutput)
-	return ret0, ret1
-}
-
-// DescribeTerminationPolicyTypesRequest indicates an expected call of DescribeTerminationPolicyTypesRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeTerminationPolicyTypesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTerminationPolicyTypesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTerminationPolicyTypesRequest), arg0)
-}
-
-// DescribeTerminationPolicyTypesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeTerminationPolicyTypesWithContext(arg0 context.Context, arg1 *autoscaling.DescribeTerminationPolicyTypesInput, arg2 ...request.Option) (*autoscaling.DescribeTerminationPolicyTypesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTerminationPolicyTypesWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DescribeTerminationPolicyTypesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTerminationPolicyTypesWithContext indicates an expected call of DescribeTerminationPolicyTypesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeTerminationPolicyTypesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTerminationPolicyTypesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTerminationPolicyTypesWithContext), varargs...)
-}
-
-// DescribeTrafficSources mocks base method.
-func (m *MockAutoScalingAPI) DescribeTrafficSources(arg0 *autoscaling.DescribeTrafficSourcesInput) (*autoscaling.DescribeTrafficSourcesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrafficSources", arg0)
-	ret0, _ := ret[0].(*autoscaling.DescribeTrafficSourcesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTrafficSources indicates an expected call of DescribeTrafficSources.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeTrafficSources(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficSources", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTrafficSources), arg0)
-}
-
-// DescribeTrafficSourcesPages mocks base method.
-func (m *MockAutoScalingAPI) DescribeTrafficSourcesPages(arg0 *autoscaling.DescribeTrafficSourcesInput, arg1 func(*autoscaling.DescribeTrafficSourcesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrafficSourcesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTrafficSourcesPages indicates an expected call of DescribeTrafficSourcesPages.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeTrafficSourcesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficSourcesPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTrafficSourcesPages), arg0, arg1)
-}
-
-// DescribeTrafficSourcesPagesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeTrafficSourcesPagesWithContext(arg0 context.Context, arg1 *autoscaling.DescribeTrafficSourcesInput, arg2 func(*autoscaling.DescribeTrafficSourcesOutput, bool) bool, arg3 ...request.Option) error {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1, arg2}
-	for _, a := range arg3 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTrafficSourcesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTrafficSourcesPagesWithContext indicates an expected call of DescribeTrafficSourcesPagesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeTrafficSourcesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficSourcesPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTrafficSourcesPagesWithContext), varargs...)
-}
-
-// DescribeTrafficSourcesRequest mocks base method.
-func (m *MockAutoScalingAPI) DescribeTrafficSourcesRequest(arg0 *autoscaling.DescribeTrafficSourcesInput) (*request.Request, *autoscaling.DescribeTrafficSourcesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrafficSourcesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DescribeTrafficSourcesOutput)
-	return ret0, ret1
-}
-
-// DescribeTrafficSourcesRequest indicates an expected call of DescribeTrafficSourcesRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeTrafficSourcesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficSourcesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTrafficSourcesRequest), arg0)
-}
-
-// DescribeTrafficSourcesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeTrafficSourcesWithContext(arg0 context.Context, arg1 *autoscaling.DescribeTrafficSourcesInput, arg2 ...request.Option) (*autoscaling.DescribeTrafficSourcesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTrafficSourcesWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DescribeTrafficSourcesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTrafficSourcesWithContext indicates an expected call of DescribeTrafficSourcesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeTrafficSourcesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficSourcesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTrafficSourcesWithContext), varargs...)
-}
-
-// DescribeWarmPool mocks base method.
-func (m *MockAutoScalingAPI) DescribeWarmPool(arg0 *autoscaling.DescribeWarmPoolInput) (*autoscaling.DescribeWarmPoolOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeWarmPool", arg0)
-	ret0, _ := ret[0].(*autoscaling.DescribeWarmPoolOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeWarmPool indicates an expected call of DescribeWarmPool.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeWarmPool(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeWarmPool", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeWarmPool), arg0)
-}
-
-// DescribeWarmPoolPages mocks base method.
-func (m *MockAutoScalingAPI) DescribeWarmPoolPages(arg0 *autoscaling.DescribeWarmPoolInput, arg1 func(*autoscaling.DescribeWarmPoolOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeWarmPoolPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeWarmPoolPages indicates an expected call of DescribeWarmPoolPages.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeWarmPoolPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeWarmPoolPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeWarmPoolPages), arg0, arg1)
-}
-
-// DescribeWarmPoolPagesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeWarmPoolPagesWithContext(arg0 context.Context, arg1 *autoscaling.DescribeWarmPoolInput, arg2 func(*autoscaling.DescribeWarmPoolOutput, bool) bool, arg3 ...request.Option) error {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1, arg2}
-	for _, a := range arg3 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeWarmPoolPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeWarmPoolPagesWithContext indicates an expected call of DescribeWarmPoolPagesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeWarmPoolPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeWarmPoolPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeWarmPoolPagesWithContext), varargs...)
-}
-
-// DescribeWarmPoolRequest mocks base method.
-func (m *MockAutoScalingAPI) DescribeWarmPoolRequest(arg0 *autoscaling.DescribeWarmPoolInput) (*request.Request, *autoscaling.DescribeWarmPoolOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeWarmPoolRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DescribeWarmPoolOutput)
-	return ret0, ret1
-}
-
-// DescribeWarmPoolRequest indicates an expected call of DescribeWarmPoolRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeWarmPoolRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeWarmPoolRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeWarmPoolRequest), arg0)
-}
-
-// DescribeWarmPoolWithContext mocks base method.
-func (m *MockAutoScalingAPI) DescribeWarmPoolWithContext(arg0 context.Context, arg1 *autoscaling.DescribeWarmPoolInput, arg2 ...request.Option) (*autoscaling.DescribeWarmPoolOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeWarmPoolWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DescribeWarmPoolOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeWarmPoolWithContext indicates an expected call of DescribeWarmPoolWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DescribeWarmPoolWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeWarmPoolWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeWarmPoolWithContext), varargs...)
-}
-
-// DetachInstances mocks base method.
-func (m *MockAutoScalingAPI) DetachInstances(arg0 *autoscaling.DetachInstancesInput) (*autoscaling.DetachInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DetachInstances", arg0)
-	ret0, _ := ret[0].(*autoscaling.DetachInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DetachInstances indicates an expected call of DetachInstances.
-func (mr *MockAutoScalingAPIMockRecorder) DetachInstances(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachInstances", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachInstances), arg0)
-}
-
-// DetachInstancesRequest mocks base method.
-func (m *MockAutoScalingAPI) DetachInstancesRequest(arg0 *autoscaling.DetachInstancesInput) (*request.Request, *autoscaling.DetachInstancesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DetachInstancesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DetachInstancesOutput)
-	return ret0, ret1
-}
-
-// DetachInstancesRequest indicates an expected call of DetachInstancesRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DetachInstancesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachInstancesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachInstancesRequest), arg0)
-}
-
-// DetachInstancesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DetachInstancesWithContext(arg0 context.Context, arg1 *autoscaling.DetachInstancesInput, arg2 ...request.Option) (*autoscaling.DetachInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DetachInstancesWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DetachInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DetachInstancesWithContext indicates an expected call of DetachInstancesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DetachInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachInstancesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachInstancesWithContext), varargs...)
-}
-
-// DetachLoadBalancerTargetGroups mocks base method.
-func (m *MockAutoScalingAPI) DetachLoadBalancerTargetGroups(arg0 *autoscaling.DetachLoadBalancerTargetGroupsInput) (*autoscaling.DetachLoadBalancerTargetGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DetachLoadBalancerTargetGroups", arg0)
-	ret0, _ := ret[0].(*autoscaling.DetachLoadBalancerTargetGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DetachLoadBalancerTargetGroups indicates an expected call of DetachLoadBalancerTargetGroups.
-func (mr *MockAutoScalingAPIMockRecorder) DetachLoadBalancerTargetGroups(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachLoadBalancerTargetGroups", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachLoadBalancerTargetGroups), arg0)
-}
-
-// DetachLoadBalancerTargetGroupsRequest mocks base method.
-func (m *MockAutoScalingAPI) DetachLoadBalancerTargetGroupsRequest(arg0 *autoscaling.DetachLoadBalancerTargetGroupsInput) (*request.Request, *autoscaling.DetachLoadBalancerTargetGroupsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DetachLoadBalancerTargetGroupsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DetachLoadBalancerTargetGroupsOutput)
-	return ret0, ret1
-}
-
-// DetachLoadBalancerTargetGroupsRequest indicates an expected call of DetachLoadBalancerTargetGroupsRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DetachLoadBalancerTargetGroupsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachLoadBalancerTargetGroupsRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachLoadBalancerTargetGroupsRequest), arg0)
-}
-
-// DetachLoadBalancerTargetGroupsWithContext mocks base method.
-func (m *MockAutoScalingAPI) DetachLoadBalancerTargetGroupsWithContext(arg0 context.Context, arg1 *autoscaling.DetachLoadBalancerTargetGroupsInput, arg2 ...request.Option) (*autoscaling.DetachLoadBalancerTargetGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DetachLoadBalancerTargetGroupsWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DetachLoadBalancerTargetGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DetachLoadBalancerTargetGroupsWithContext indicates an expected call of DetachLoadBalancerTargetGroupsWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DetachLoadBalancerTargetGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachLoadBalancerTargetGroupsWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachLoadBalancerTargetGroupsWithContext), varargs...)
-}
-
-// DetachLoadBalancers mocks base method.
-func (m *MockAutoScalingAPI) DetachLoadBalancers(arg0 *autoscaling.DetachLoadBalancersInput) (*autoscaling.DetachLoadBalancersOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DetachLoadBalancers", arg0)
-	ret0, _ := ret[0].(*autoscaling.DetachLoadBalancersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DetachLoadBalancers indicates an expected call of DetachLoadBalancers.
-func (mr *MockAutoScalingAPIMockRecorder) DetachLoadBalancers(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachLoadBalancers", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachLoadBalancers), arg0)
-}
-
-// DetachLoadBalancersRequest mocks base method.
-func (m *MockAutoScalingAPI) DetachLoadBalancersRequest(arg0 *autoscaling.DetachLoadBalancersInput) (*request.Request, *autoscaling.DetachLoadBalancersOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DetachLoadBalancersRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DetachLoadBalancersOutput)
-	return ret0, ret1
-}
-
-// DetachLoadBalancersRequest indicates an expected call of DetachLoadBalancersRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DetachLoadBalancersRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachLoadBalancersRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachLoadBalancersRequest), arg0)
-}
-
-// DetachLoadBalancersWithContext mocks base method.
-func (m *MockAutoScalingAPI) DetachLoadBalancersWithContext(arg0 context.Context, arg1 *autoscaling.DetachLoadBalancersInput, arg2 ...request.Option) (*autoscaling.DetachLoadBalancersOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DetachLoadBalancersWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DetachLoadBalancersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DetachLoadBalancersWithContext indicates an expected call of DetachLoadBalancersWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DetachLoadBalancersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachLoadBalancersWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachLoadBalancersWithContext), varargs...)
-}
-
-// DetachTrafficSources mocks base method.
-func (m *MockAutoScalingAPI) DetachTrafficSources(arg0 *autoscaling.DetachTrafficSourcesInput) (*autoscaling.DetachTrafficSourcesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DetachTrafficSources", arg0)
-	ret0, _ := ret[0].(*autoscaling.DetachTrafficSourcesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DetachTrafficSources indicates an expected call of DetachTrafficSources.
-func (mr *MockAutoScalingAPIMockRecorder) DetachTrafficSources(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachTrafficSources", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachTrafficSources), arg0)
-}
-
-// DetachTrafficSourcesRequest mocks base method.
-func (m *MockAutoScalingAPI) DetachTrafficSourcesRequest(arg0 *autoscaling.DetachTrafficSourcesInput) (*request.Request, *autoscaling.DetachTrafficSourcesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DetachTrafficSourcesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DetachTrafficSourcesOutput)
-	return ret0, ret1
-}
-
-// DetachTrafficSourcesRequest indicates an expected call of DetachTrafficSourcesRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DetachTrafficSourcesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachTrafficSourcesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachTrafficSourcesRequest), arg0)
-}
-
-// DetachTrafficSourcesWithContext mocks base method.
-func (m *MockAutoScalingAPI) DetachTrafficSourcesWithContext(arg0 context.Context, arg1 *autoscaling.DetachTrafficSourcesInput, arg2 ...request.Option) (*autoscaling.DetachTrafficSourcesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DetachTrafficSourcesWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DetachTrafficSourcesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DetachTrafficSourcesWithContext indicates an expected call of DetachTrafficSourcesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DetachTrafficSourcesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachTrafficSourcesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachTrafficSourcesWithContext), varargs...)
-}
-
-// DisableMetricsCollection mocks base method.
-func (m *MockAutoScalingAPI) DisableMetricsCollection(arg0 *autoscaling.DisableMetricsCollectionInput) (*autoscaling.DisableMetricsCollectionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableMetricsCollection", arg0)
-	ret0, _ := ret[0].(*autoscaling.DisableMetricsCollectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableMetricsCollection indicates an expected call of DisableMetricsCollection.
-func (mr *MockAutoScalingAPIMockRecorder) DisableMetricsCollection(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableMetricsCollection", reflect.TypeOf((*MockAutoScalingAPI)(nil).DisableMetricsCollection), arg0)
-}
-
-// DisableMetricsCollectionRequest mocks base method.
-func (m *MockAutoScalingAPI) DisableMetricsCollectionRequest(arg0 *autoscaling.DisableMetricsCollectionInput) (*request.Request, *autoscaling.DisableMetricsCollectionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableMetricsCollectionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.DisableMetricsCollectionOutput)
-	return ret0, ret1
-}
-
-// DisableMetricsCollectionRequest indicates an expected call of DisableMetricsCollectionRequest.
-func (mr *MockAutoScalingAPIMockRecorder) DisableMetricsCollectionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableMetricsCollectionRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DisableMetricsCollectionRequest), arg0)
-}
-
-// DisableMetricsCollectionWithContext mocks base method.
-func (m *MockAutoScalingAPI) DisableMetricsCollectionWithContext(arg0 context.Context, arg1 *autoscaling.DisableMetricsCollectionInput, arg2 ...request.Option) (*autoscaling.DisableMetricsCollectionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisableMetricsCollectionWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.DisableMetricsCollectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableMetricsCollectionWithContext indicates an expected call of DisableMetricsCollectionWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) DisableMetricsCollectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableMetricsCollectionWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DisableMetricsCollectionWithContext), varargs...)
-}
-
-// EnableMetricsCollection mocks base method.
-func (m *MockAutoScalingAPI) EnableMetricsCollection(arg0 *autoscaling.EnableMetricsCollectionInput) (*autoscaling.EnableMetricsCollectionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableMetricsCollection", arg0)
-	ret0, _ := ret[0].(*autoscaling.EnableMetricsCollectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableMetricsCollection indicates an expected call of EnableMetricsCollection.
-func (mr *MockAutoScalingAPIMockRecorder) EnableMetricsCollection(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableMetricsCollection", reflect.TypeOf((*MockAutoScalingAPI)(nil).EnableMetricsCollection), arg0)
-}
-
-// EnableMetricsCollectionRequest mocks base method.
-func (m *MockAutoScalingAPI) EnableMetricsCollectionRequest(arg0 *autoscaling.EnableMetricsCollectionInput) (*request.Request, *autoscaling.EnableMetricsCollectionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableMetricsCollectionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.EnableMetricsCollectionOutput)
-	return ret0, ret1
-}
-
-// EnableMetricsCollectionRequest indicates an expected call of EnableMetricsCollectionRequest.
-func (mr *MockAutoScalingAPIMockRecorder) EnableMetricsCollectionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableMetricsCollectionRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).EnableMetricsCollectionRequest), arg0)
-}
-
-// EnableMetricsCollectionWithContext mocks base method.
-func (m *MockAutoScalingAPI) EnableMetricsCollectionWithContext(arg0 context.Context, arg1 *autoscaling.EnableMetricsCollectionInput, arg2 ...request.Option) (*autoscaling.EnableMetricsCollectionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EnableMetricsCollectionWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.EnableMetricsCollectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableMetricsCollectionWithContext indicates an expected call of EnableMetricsCollectionWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) EnableMetricsCollectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableMetricsCollectionWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).EnableMetricsCollectionWithContext), varargs...)
-}
-
-// EnterStandby mocks base method.
-func (m *MockAutoScalingAPI) EnterStandby(arg0 *autoscaling.EnterStandbyInput) (*autoscaling.EnterStandbyOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnterStandby", arg0)
-	ret0, _ := ret[0].(*autoscaling.EnterStandbyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnterStandby indicates an expected call of EnterStandby.
-func (mr *MockAutoScalingAPIMockRecorder) EnterStandby(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnterStandby", reflect.TypeOf((*MockAutoScalingAPI)(nil).EnterStandby), arg0)
-}
-
-// EnterStandbyRequest mocks base method.
-func (m *MockAutoScalingAPI) EnterStandbyRequest(arg0 *autoscaling.EnterStandbyInput) (*request.Request, *autoscaling.EnterStandbyOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnterStandbyRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.EnterStandbyOutput)
-	return ret0, ret1
-}
-
-// EnterStandbyRequest indicates an expected call of EnterStandbyRequest.
-func (mr *MockAutoScalingAPIMockRecorder) EnterStandbyRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnterStandbyRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).EnterStandbyRequest), arg0)
-}
-
-// EnterStandbyWithContext mocks base method.
-func (m *MockAutoScalingAPI) EnterStandbyWithContext(arg0 context.Context, arg1 *autoscaling.EnterStandbyInput, arg2 ...request.Option) (*autoscaling.EnterStandbyOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EnterStandbyWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.EnterStandbyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnterStandbyWithContext indicates an expected call of EnterStandbyWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) EnterStandbyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnterStandbyWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).EnterStandbyWithContext), varargs...)
-}
-
-// ExecutePolicy mocks base method.
-func (m *MockAutoScalingAPI) ExecutePolicy(arg0 *autoscaling.ExecutePolicyInput) (*autoscaling.ExecutePolicyOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ExecutePolicy", arg0)
-	ret0, _ := ret[0].(*autoscaling.ExecutePolicyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ExecutePolicy indicates an expected call of ExecutePolicy.
-func (mr *MockAutoScalingAPIMockRecorder) ExecutePolicy(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecutePolicy", reflect.TypeOf((*MockAutoScalingAPI)(nil).ExecutePolicy), arg0)
-}
-
-// ExecutePolicyRequest mocks base method.
-func (m *MockAutoScalingAPI) ExecutePolicyRequest(arg0 *autoscaling.ExecutePolicyInput) (*request.Request, *autoscaling.ExecutePolicyOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ExecutePolicyRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.ExecutePolicyOutput)
-	return ret0, ret1
-}
-
-// ExecutePolicyRequest indicates an expected call of ExecutePolicyRequest.
-func (mr *MockAutoScalingAPIMockRecorder) ExecutePolicyRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecutePolicyRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).ExecutePolicyRequest), arg0)
-}
-
-// ExecutePolicyWithContext mocks base method.
-func (m *MockAutoScalingAPI) ExecutePolicyWithContext(arg0 context.Context, arg1 *autoscaling.ExecutePolicyInput, arg2 ...request.Option) (*autoscaling.ExecutePolicyOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ExecutePolicyWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.ExecutePolicyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ExecutePolicyWithContext indicates an expected call of ExecutePolicyWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) ExecutePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecutePolicyWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).ExecutePolicyWithContext), varargs...)
-}
-
-// ExitStandby mocks base method.
-func (m *MockAutoScalingAPI) ExitStandby(arg0 *autoscaling.ExitStandbyInput) (*autoscaling.ExitStandbyOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ExitStandby", arg0)
-	ret0, _ := ret[0].(*autoscaling.ExitStandbyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ExitStandby indicates an expected call of ExitStandby.
-func (mr *MockAutoScalingAPIMockRecorder) ExitStandby(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExitStandby", reflect.TypeOf((*MockAutoScalingAPI)(nil).ExitStandby), arg0)
-}
-
-// ExitStandbyRequest mocks base method.
-func (m *MockAutoScalingAPI) ExitStandbyRequest(arg0 *autoscaling.ExitStandbyInput) (*request.Request, *autoscaling.ExitStandbyOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ExitStandbyRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.ExitStandbyOutput)
-	return ret0, ret1
-}
-
-// ExitStandbyRequest indicates an expected call of ExitStandbyRequest.
-func (mr *MockAutoScalingAPIMockRecorder) ExitStandbyRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExitStandbyRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).ExitStandbyRequest), arg0)
-}
-
-// ExitStandbyWithContext mocks base method.
-func (m *MockAutoScalingAPI) ExitStandbyWithContext(arg0 context.Context, arg1 *autoscaling.ExitStandbyInput, arg2 ...request.Option) (*autoscaling.ExitStandbyOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ExitStandbyWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.ExitStandbyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ExitStandbyWithContext indicates an expected call of ExitStandbyWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) ExitStandbyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExitStandbyWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).ExitStandbyWithContext), varargs...)
-}
-
-// GetPredictiveScalingForecast mocks base method.
-func (m *MockAutoScalingAPI) GetPredictiveScalingForecast(arg0 *autoscaling.GetPredictiveScalingForecastInput) (*autoscaling.GetPredictiveScalingForecastOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetPredictiveScalingForecast", arg0)
-	ret0, _ := ret[0].(*autoscaling.GetPredictiveScalingForecastOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetPredictiveScalingForecast indicates an expected call of GetPredictiveScalingForecast.
-func (mr *MockAutoScalingAPIMockRecorder) GetPredictiveScalingForecast(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPredictiveScalingForecast", reflect.TypeOf((*MockAutoScalingAPI)(nil).GetPredictiveScalingForecast), arg0)
-}
-
-// GetPredictiveScalingForecastRequest mocks base method.
-func (m *MockAutoScalingAPI) GetPredictiveScalingForecastRequest(arg0 *autoscaling.GetPredictiveScalingForecastInput) (*request.Request, *autoscaling.GetPredictiveScalingForecastOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetPredictiveScalingForecastRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.GetPredictiveScalingForecastOutput)
-	return ret0, ret1
-}
-
-// GetPredictiveScalingForecastRequest indicates an expected call of GetPredictiveScalingForecastRequest.
-func (mr *MockAutoScalingAPIMockRecorder) GetPredictiveScalingForecastRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPredictiveScalingForecastRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).GetPredictiveScalingForecastRequest), arg0)
-}
-
-// GetPredictiveScalingForecastWithContext mocks base method.
-func (m *MockAutoScalingAPI) GetPredictiveScalingForecastWithContext(arg0 context.Context, arg1 *autoscaling.GetPredictiveScalingForecastInput, arg2 ...request.Option) (*autoscaling.GetPredictiveScalingForecastOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetPredictiveScalingForecastWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.GetPredictiveScalingForecastOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetPredictiveScalingForecastWithContext indicates an expected call of GetPredictiveScalingForecastWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) GetPredictiveScalingForecastWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPredictiveScalingForecastWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).GetPredictiveScalingForecastWithContext), varargs...)
-}
-
-// PutLifecycleHook mocks base method.
-func (m *MockAutoScalingAPI) PutLifecycleHook(arg0 *autoscaling.PutLifecycleHookInput) (*autoscaling.PutLifecycleHookOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PutLifecycleHook", arg0)
-	ret0, _ := ret[0].(*autoscaling.PutLifecycleHookOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PutLifecycleHook indicates an expected call of PutLifecycleHook.
-func (mr *MockAutoScalingAPIMockRecorder) PutLifecycleHook(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutLifecycleHook", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutLifecycleHook), arg0)
-}
-
-// PutLifecycleHookRequest mocks base method.
-func (m *MockAutoScalingAPI) PutLifecycleHookRequest(arg0 *autoscaling.PutLifecycleHookInput) (*request.Request, *autoscaling.PutLifecycleHookOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PutLifecycleHookRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.PutLifecycleHookOutput)
-	return ret0, ret1
-}
-
-// PutLifecycleHookRequest indicates an expected call of PutLifecycleHookRequest.
-func (mr *MockAutoScalingAPIMockRecorder) PutLifecycleHookRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutLifecycleHookRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutLifecycleHookRequest), arg0)
-}
-
-// PutLifecycleHookWithContext mocks base method.
-func (m *MockAutoScalingAPI) PutLifecycleHookWithContext(arg0 context.Context, arg1 *autoscaling.PutLifecycleHookInput, arg2 ...request.Option) (*autoscaling.PutLifecycleHookOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "PutLifecycleHookWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.PutLifecycleHookOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PutLifecycleHookWithContext indicates an expected call of PutLifecycleHookWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) PutLifecycleHookWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutLifecycleHookWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutLifecycleHookWithContext), varargs...)
-}
-
-// PutNotificationConfiguration mocks base method.
-func (m *MockAutoScalingAPI) PutNotificationConfiguration(arg0 *autoscaling.PutNotificationConfigurationInput) (*autoscaling.PutNotificationConfigurationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PutNotificationConfiguration", arg0)
-	ret0, _ := ret[0].(*autoscaling.PutNotificationConfigurationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PutNotificationConfiguration indicates an expected call of PutNotificationConfiguration.
-func (mr *MockAutoScalingAPIMockRecorder) PutNotificationConfiguration(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutNotificationConfiguration", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutNotificationConfiguration), arg0)
-}
-
-// PutNotificationConfigurationRequest mocks base method.
-func (m *MockAutoScalingAPI) PutNotificationConfigurationRequest(arg0 *autoscaling.PutNotificationConfigurationInput) (*request.Request, *autoscaling.PutNotificationConfigurationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PutNotificationConfigurationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.PutNotificationConfigurationOutput)
-	return ret0, ret1
-}
-
-// PutNotificationConfigurationRequest indicates an expected call of PutNotificationConfigurationRequest.
-func (mr *MockAutoScalingAPIMockRecorder) PutNotificationConfigurationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutNotificationConfigurationRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutNotificationConfigurationRequest), arg0)
-}
-
-// PutNotificationConfigurationWithContext mocks base method.
-func (m *MockAutoScalingAPI) PutNotificationConfigurationWithContext(arg0 context.Context, arg1 *autoscaling.PutNotificationConfigurationInput, arg2 ...request.Option) (*autoscaling.PutNotificationConfigurationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "PutNotificationConfigurationWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.PutNotificationConfigurationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PutNotificationConfigurationWithContext indicates an expected call of PutNotificationConfigurationWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) PutNotificationConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutNotificationConfigurationWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutNotificationConfigurationWithContext), varargs...)
-}
-
-// PutScalingPolicy mocks base method.
-func (m *MockAutoScalingAPI) PutScalingPolicy(arg0 *autoscaling.PutScalingPolicyInput) (*autoscaling.PutScalingPolicyOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PutScalingPolicy", arg0)
-	ret0, _ := ret[0].(*autoscaling.PutScalingPolicyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PutScalingPolicy indicates an expected call of PutScalingPolicy.
-func (mr *MockAutoScalingAPIMockRecorder) PutScalingPolicy(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutScalingPolicy", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutScalingPolicy), arg0)
-}
-
-// PutScalingPolicyRequest mocks base method.
-func (m *MockAutoScalingAPI) PutScalingPolicyRequest(arg0 *autoscaling.PutScalingPolicyInput) (*request.Request, *autoscaling.PutScalingPolicyOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PutScalingPolicyRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.PutScalingPolicyOutput)
-	return ret0, ret1
-}
-
-// PutScalingPolicyRequest indicates an expected call of PutScalingPolicyRequest.
-func (mr *MockAutoScalingAPIMockRecorder) PutScalingPolicyRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutScalingPolicyRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutScalingPolicyRequest), arg0)
-}
-
-// PutScalingPolicyWithContext mocks base method.
-func (m *MockAutoScalingAPI) PutScalingPolicyWithContext(arg0 context.Context, arg1 *autoscaling.PutScalingPolicyInput, arg2 ...request.Option) (*autoscaling.PutScalingPolicyOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "PutScalingPolicyWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.PutScalingPolicyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PutScalingPolicyWithContext indicates an expected call of PutScalingPolicyWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) PutScalingPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutScalingPolicyWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutScalingPolicyWithContext), varargs...)
-}
-
-// PutScheduledUpdateGroupAction mocks base method.
-func (m *MockAutoScalingAPI) PutScheduledUpdateGroupAction(arg0 *autoscaling.PutScheduledUpdateGroupActionInput) (*autoscaling.PutScheduledUpdateGroupActionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PutScheduledUpdateGroupAction", arg0)
-	ret0, _ := ret[0].(*autoscaling.PutScheduledUpdateGroupActionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PutScheduledUpdateGroupAction indicates an expected call of PutScheduledUpdateGroupAction.
-func (mr *MockAutoScalingAPIMockRecorder) PutScheduledUpdateGroupAction(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutScheduledUpdateGroupAction", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutScheduledUpdateGroupAction), arg0)
-}
-
-// PutScheduledUpdateGroupActionRequest mocks base method.
-func (m *MockAutoScalingAPI) PutScheduledUpdateGroupActionRequest(arg0 *autoscaling.PutScheduledUpdateGroupActionInput) (*request.Request, *autoscaling.PutScheduledUpdateGroupActionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PutScheduledUpdateGroupActionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.PutScheduledUpdateGroupActionOutput)
-	return ret0, ret1
-}
-
-// PutScheduledUpdateGroupActionRequest indicates an expected call of PutScheduledUpdateGroupActionRequest.
-func (mr *MockAutoScalingAPIMockRecorder) PutScheduledUpdateGroupActionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutScheduledUpdateGroupActionRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutScheduledUpdateGroupActionRequest), arg0)
-}
-
-// PutScheduledUpdateGroupActionWithContext mocks base method.
-func (m *MockAutoScalingAPI) PutScheduledUpdateGroupActionWithContext(arg0 context.Context, arg1 *autoscaling.PutScheduledUpdateGroupActionInput, arg2 ...request.Option) (*autoscaling.PutScheduledUpdateGroupActionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "PutScheduledUpdateGroupActionWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.PutScheduledUpdateGroupActionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PutScheduledUpdateGroupActionWithContext indicates an expected call of PutScheduledUpdateGroupActionWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) PutScheduledUpdateGroupActionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutScheduledUpdateGroupActionWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutScheduledUpdateGroupActionWithContext), varargs...)
-}
-
-// PutWarmPool mocks base method.
-func (m *MockAutoScalingAPI) PutWarmPool(arg0 *autoscaling.PutWarmPoolInput) (*autoscaling.PutWarmPoolOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PutWarmPool", arg0)
-	ret0, _ := ret[0].(*autoscaling.PutWarmPoolOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PutWarmPool indicates an expected call of PutWarmPool.
-func (mr *MockAutoScalingAPIMockRecorder) PutWarmPool(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutWarmPool", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutWarmPool), arg0)
-}
-
-// PutWarmPoolRequest mocks base method.
-func (m *MockAutoScalingAPI) PutWarmPoolRequest(arg0 *autoscaling.PutWarmPoolInput) (*request.Request, *autoscaling.PutWarmPoolOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PutWarmPoolRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.PutWarmPoolOutput)
-	return ret0, ret1
-}
-
-// PutWarmPoolRequest indicates an expected call of PutWarmPoolRequest.
-func (mr *MockAutoScalingAPIMockRecorder) PutWarmPoolRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutWarmPoolRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutWarmPoolRequest), arg0)
-}
-
-// PutWarmPoolWithContext mocks base method.
-func (m *MockAutoScalingAPI) PutWarmPoolWithContext(arg0 context.Context, arg1 *autoscaling.PutWarmPoolInput, arg2 ...request.Option) (*autoscaling.PutWarmPoolOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "PutWarmPoolWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.PutWarmPoolOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PutWarmPoolWithContext indicates an expected call of PutWarmPoolWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) PutWarmPoolWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutWarmPoolWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutWarmPoolWithContext), varargs...)
-}
-
-// RecordLifecycleActionHeartbeat mocks base method.
-func (m *MockAutoScalingAPI) RecordLifecycleActionHeartbeat(arg0 *autoscaling.RecordLifecycleActionHeartbeatInput) (*autoscaling.RecordLifecycleActionHeartbeatOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RecordLifecycleActionHeartbeat", arg0)
-	ret0, _ := ret[0].(*autoscaling.RecordLifecycleActionHeartbeatOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RecordLifecycleActionHeartbeat indicates an expected call of RecordLifecycleActionHeartbeat.
-func (mr *MockAutoScalingAPIMockRecorder) RecordLifecycleActionHeartbeat(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordLifecycleActionHeartbeat", reflect.TypeOf((*MockAutoScalingAPI)(nil).RecordLifecycleActionHeartbeat), arg0)
-}
-
-// RecordLifecycleActionHeartbeatRequest mocks base method.
-func (m *MockAutoScalingAPI) RecordLifecycleActionHeartbeatRequest(arg0 *autoscaling.RecordLifecycleActionHeartbeatInput) (*request.Request, *autoscaling.RecordLifecycleActionHeartbeatOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RecordLifecycleActionHeartbeatRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.RecordLifecycleActionHeartbeatOutput)
-	return ret0, ret1
-}
-
-// RecordLifecycleActionHeartbeatRequest indicates an expected call of RecordLifecycleActionHeartbeatRequest.
-func (mr *MockAutoScalingAPIMockRecorder) RecordLifecycleActionHeartbeatRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordLifecycleActionHeartbeatRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).RecordLifecycleActionHeartbeatRequest), arg0)
-}
-
-// RecordLifecycleActionHeartbeatWithContext mocks base method.
-func (m *MockAutoScalingAPI) RecordLifecycleActionHeartbeatWithContext(arg0 context.Context, arg1 *autoscaling.RecordLifecycleActionHeartbeatInput, arg2 ...request.Option) (*autoscaling.RecordLifecycleActionHeartbeatOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RecordLifecycleActionHeartbeatWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.RecordLifecycleActionHeartbeatOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RecordLifecycleActionHeartbeatWithContext indicates an expected call of RecordLifecycleActionHeartbeatWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) RecordLifecycleActionHeartbeatWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordLifecycleActionHeartbeatWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).RecordLifecycleActionHeartbeatWithContext), varargs...)
-}
-
-// ResumeProcesses mocks base method.
-func (m *MockAutoScalingAPI) ResumeProcesses(arg0 *autoscaling.ScalingProcessQuery) (*autoscaling.ResumeProcessesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResumeProcesses", arg0)
-	ret0, _ := ret[0].(*autoscaling.ResumeProcessesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ResumeProcesses indicates an expected call of ResumeProcesses.
-func (mr *MockAutoScalingAPIMockRecorder) ResumeProcesses(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeProcesses", reflect.TypeOf((*MockAutoScalingAPI)(nil).ResumeProcesses), arg0)
-}
-
-// ResumeProcessesRequest mocks base method.
-func (m *MockAutoScalingAPI) ResumeProcessesRequest(arg0 *autoscaling.ScalingProcessQuery) (*request.Request, *autoscaling.ResumeProcessesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResumeProcessesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.ResumeProcessesOutput)
-	return ret0, ret1
-}
-
-// ResumeProcessesRequest indicates an expected call of ResumeProcessesRequest.
-func (mr *MockAutoScalingAPIMockRecorder) ResumeProcessesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeProcessesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).ResumeProcessesRequest), arg0)
-}
-
-// ResumeProcessesWithContext mocks base method.
-func (m *MockAutoScalingAPI) ResumeProcessesWithContext(arg0 context.Context, arg1 *autoscaling.ScalingProcessQuery, arg2 ...request.Option) (*autoscaling.ResumeProcessesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ResumeProcessesWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.ResumeProcessesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ResumeProcessesWithContext indicates an expected call of ResumeProcessesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) ResumeProcessesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeProcessesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).ResumeProcessesWithContext), varargs...)
-}
-
-// RollbackInstanceRefresh mocks base method.
-func (m *MockAutoScalingAPI) RollbackInstanceRefresh(arg0 *autoscaling.RollbackInstanceRefreshInput) (*autoscaling.RollbackInstanceRefreshOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RollbackInstanceRefresh", arg0)
-	ret0, _ := ret[0].(*autoscaling.RollbackInstanceRefreshOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RollbackInstanceRefresh indicates an expected call of RollbackInstanceRefresh.
-func (mr *MockAutoScalingAPIMockRecorder) RollbackInstanceRefresh(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollbackInstanceRefresh", reflect.TypeOf((*MockAutoScalingAPI)(nil).RollbackInstanceRefresh), arg0)
-}
-
-// RollbackInstanceRefreshRequest mocks base method.
-func (m *MockAutoScalingAPI) RollbackInstanceRefreshRequest(arg0 *autoscaling.RollbackInstanceRefreshInput) (*request.Request, *autoscaling.RollbackInstanceRefreshOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RollbackInstanceRefreshRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.RollbackInstanceRefreshOutput)
-	return ret0, ret1
-}
-
-// RollbackInstanceRefreshRequest indicates an expected call of RollbackInstanceRefreshRequest.
-func (mr *MockAutoScalingAPIMockRecorder) RollbackInstanceRefreshRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollbackInstanceRefreshRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).RollbackInstanceRefreshRequest), arg0)
-}
-
-// RollbackInstanceRefreshWithContext mocks base method.
-func (m *MockAutoScalingAPI) RollbackInstanceRefreshWithContext(arg0 context.Context, arg1 *autoscaling.RollbackInstanceRefreshInput, arg2 ...request.Option) (*autoscaling.RollbackInstanceRefreshOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RollbackInstanceRefreshWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.RollbackInstanceRefreshOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RollbackInstanceRefreshWithContext indicates an expected call of RollbackInstanceRefreshWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) RollbackInstanceRefreshWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollbackInstanceRefreshWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).RollbackInstanceRefreshWithContext), varargs...)
-}
-
-// SetDesiredCapacity mocks base method.
-func (m *MockAutoScalingAPI) SetDesiredCapacity(arg0 *autoscaling.SetDesiredCapacityInput) (*autoscaling.SetDesiredCapacityOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetDesiredCapacity", arg0)
-	ret0, _ := ret[0].(*autoscaling.SetDesiredCapacityOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SetDesiredCapacity indicates an expected call of SetDesiredCapacity.
-func (mr *MockAutoScalingAPIMockRecorder) SetDesiredCapacity(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDesiredCapacity", reflect.TypeOf((*MockAutoScalingAPI)(nil).SetDesiredCapacity), arg0)
-}
-
-// SetDesiredCapacityRequest mocks base method.
-func (m *MockAutoScalingAPI) SetDesiredCapacityRequest(arg0 *autoscaling.SetDesiredCapacityInput) (*request.Request, *autoscaling.SetDesiredCapacityOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetDesiredCapacityRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.SetDesiredCapacityOutput)
-	return ret0, ret1
-}
-
-// SetDesiredCapacityRequest indicates an expected call of SetDesiredCapacityRequest.
-func (mr *MockAutoScalingAPIMockRecorder) SetDesiredCapacityRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDesiredCapacityRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).SetDesiredCapacityRequest), arg0)
-}
-
-// SetDesiredCapacityWithContext mocks base method.
-func (m *MockAutoScalingAPI) SetDesiredCapacityWithContext(arg0 context.Context, arg1 *autoscaling.SetDesiredCapacityInput, arg2 ...request.Option) (*autoscaling.SetDesiredCapacityOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SetDesiredCapacityWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.SetDesiredCapacityOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SetDesiredCapacityWithContext indicates an expected call of SetDesiredCapacityWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) SetDesiredCapacityWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDesiredCapacityWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).SetDesiredCapacityWithContext), varargs...)
-}
-
-// SetInstanceHealth mocks base method.
-func (m *MockAutoScalingAPI) SetInstanceHealth(arg0 *autoscaling.SetInstanceHealthInput) (*autoscaling.SetInstanceHealthOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetInstanceHealth", arg0)
-	ret0, _ := ret[0].(*autoscaling.SetInstanceHealthOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SetInstanceHealth indicates an expected call of SetInstanceHealth.
-func (mr *MockAutoScalingAPIMockRecorder) SetInstanceHealth(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInstanceHealth", reflect.TypeOf((*MockAutoScalingAPI)(nil).SetInstanceHealth), arg0)
-}
-
-// SetInstanceHealthRequest mocks base method.
-func (m *MockAutoScalingAPI) SetInstanceHealthRequest(arg0 *autoscaling.SetInstanceHealthInput) (*request.Request, *autoscaling.SetInstanceHealthOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetInstanceHealthRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.SetInstanceHealthOutput)
-	return ret0, ret1
-}
-
-// SetInstanceHealthRequest indicates an expected call of SetInstanceHealthRequest.
-func (mr *MockAutoScalingAPIMockRecorder) SetInstanceHealthRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInstanceHealthRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).SetInstanceHealthRequest), arg0)
-}
-
-// SetInstanceHealthWithContext mocks base method.
-func (m *MockAutoScalingAPI) SetInstanceHealthWithContext(arg0 context.Context, arg1 *autoscaling.SetInstanceHealthInput, arg2 ...request.Option) (*autoscaling.SetInstanceHealthOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SetInstanceHealthWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.SetInstanceHealthOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SetInstanceHealthWithContext indicates an expected call of SetInstanceHealthWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) SetInstanceHealthWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInstanceHealthWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).SetInstanceHealthWithContext), varargs...)
-}
-
-// SetInstanceProtection mocks base method.
-func (m *MockAutoScalingAPI) SetInstanceProtection(arg0 *autoscaling.SetInstanceProtectionInput) (*autoscaling.SetInstanceProtectionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetInstanceProtection", arg0)
-	ret0, _ := ret[0].(*autoscaling.SetInstanceProtectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SetInstanceProtection indicates an expected call of SetInstanceProtection.
-func (mr *MockAutoScalingAPIMockRecorder) SetInstanceProtection(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInstanceProtection", reflect.TypeOf((*MockAutoScalingAPI)(nil).SetInstanceProtection), arg0)
-}
-
-// SetInstanceProtectionRequest mocks base method.
-func (m *MockAutoScalingAPI) SetInstanceProtectionRequest(arg0 *autoscaling.SetInstanceProtectionInput) (*request.Request, *autoscaling.SetInstanceProtectionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetInstanceProtectionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.SetInstanceProtectionOutput)
-	return ret0, ret1
-}
-
-// SetInstanceProtectionRequest indicates an expected call of SetInstanceProtectionRequest.
-func (mr *MockAutoScalingAPIMockRecorder) SetInstanceProtectionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInstanceProtectionRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).SetInstanceProtectionRequest), arg0)
-}
-
-// SetInstanceProtectionWithContext mocks base method.
-func (m *MockAutoScalingAPI) SetInstanceProtectionWithContext(arg0 context.Context, arg1 *autoscaling.SetInstanceProtectionInput, arg2 ...request.Option) (*autoscaling.SetInstanceProtectionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SetInstanceProtectionWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.SetInstanceProtectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SetInstanceProtectionWithContext indicates an expected call of SetInstanceProtectionWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) SetInstanceProtectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInstanceProtectionWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).SetInstanceProtectionWithContext), varargs...)
-}
-
-// StartInstanceRefresh mocks base method.
-func (m *MockAutoScalingAPI) StartInstanceRefresh(arg0 *autoscaling.StartInstanceRefreshInput) (*autoscaling.StartInstanceRefreshOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StartInstanceRefresh", arg0)
-	ret0, _ := ret[0].(*autoscaling.StartInstanceRefreshOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StartInstanceRefresh indicates an expected call of StartInstanceRefresh.
-func (mr *MockAutoScalingAPIMockRecorder) StartInstanceRefresh(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstanceRefresh", reflect.TypeOf((*MockAutoScalingAPI)(nil).StartInstanceRefresh), arg0)
-}
-
-// StartInstanceRefreshRequest mocks base method.
-func (m *MockAutoScalingAPI) StartInstanceRefreshRequest(arg0 *autoscaling.StartInstanceRefreshInput) (*request.Request, *autoscaling.StartInstanceRefreshOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StartInstanceRefreshRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.StartInstanceRefreshOutput)
-	return ret0, ret1
-}
-
-// StartInstanceRefreshRequest indicates an expected call of StartInstanceRefreshRequest.
-func (mr *MockAutoScalingAPIMockRecorder) StartInstanceRefreshRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstanceRefreshRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).StartInstanceRefreshRequest), arg0)
-}
-
-// StartInstanceRefreshWithContext mocks base method.
-func (m *MockAutoScalingAPI) StartInstanceRefreshWithContext(arg0 context.Context, arg1 *autoscaling.StartInstanceRefreshInput, arg2 ...request.Option) (*autoscaling.StartInstanceRefreshOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "StartInstanceRefreshWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.StartInstanceRefreshOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StartInstanceRefreshWithContext indicates an expected call of StartInstanceRefreshWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) StartInstanceRefreshWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstanceRefreshWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).StartInstanceRefreshWithContext), varargs...)
-}
-
-// SuspendProcesses mocks base method.
-func (m *MockAutoScalingAPI) SuspendProcesses(arg0 *autoscaling.ScalingProcessQuery) (*autoscaling.SuspendProcessesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SuspendProcesses", arg0)
-	ret0, _ := ret[0].(*autoscaling.SuspendProcessesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SuspendProcesses indicates an expected call of SuspendProcesses.
-func (mr *MockAutoScalingAPIMockRecorder) SuspendProcesses(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuspendProcesses", reflect.TypeOf((*MockAutoScalingAPI)(nil).SuspendProcesses), arg0)
-}
-
-// SuspendProcessesRequest mocks base method.
-func (m *MockAutoScalingAPI) SuspendProcessesRequest(arg0 *autoscaling.ScalingProcessQuery) (*request.Request, *autoscaling.SuspendProcessesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SuspendProcessesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.SuspendProcessesOutput)
-	return ret0, ret1
-}
-
-// SuspendProcessesRequest indicates an expected call of SuspendProcessesRequest.
-func (mr *MockAutoScalingAPIMockRecorder) SuspendProcessesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuspendProcessesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).SuspendProcessesRequest), arg0)
-}
-
-// SuspendProcessesWithContext mocks base method.
-func (m *MockAutoScalingAPI) SuspendProcessesWithContext(arg0 context.Context, arg1 *autoscaling.ScalingProcessQuery, arg2 ...request.Option) (*autoscaling.SuspendProcessesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SuspendProcessesWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.SuspendProcessesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SuspendProcessesWithContext indicates an expected call of SuspendProcessesWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) SuspendProcessesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuspendProcessesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).SuspendProcessesWithContext), varargs...)
-}
-
-// TerminateInstanceInAutoScalingGroup mocks base method.
-func (m *MockAutoScalingAPI) TerminateInstanceInAutoScalingGroup(arg0 *autoscaling.TerminateInstanceInAutoScalingGroupInput) (*autoscaling.TerminateInstanceInAutoScalingGroupOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "TerminateInstanceInAutoScalingGroup", arg0)
-	ret0, _ := ret[0].(*autoscaling.TerminateInstanceInAutoScalingGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// TerminateInstanceInAutoScalingGroup indicates an expected call of TerminateInstanceInAutoScalingGroup.
-func (mr *MockAutoScalingAPIMockRecorder) TerminateInstanceInAutoScalingGroup(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateInstanceInAutoScalingGroup", reflect.TypeOf((*MockAutoScalingAPI)(nil).TerminateInstanceInAutoScalingGroup), arg0)
-}
-
-// TerminateInstanceInAutoScalingGroupRequest mocks base method.
-func (m *MockAutoScalingAPI) TerminateInstanceInAutoScalingGroupRequest(arg0 *autoscaling.TerminateInstanceInAutoScalingGroupInput) (*request.Request, *autoscaling.TerminateInstanceInAutoScalingGroupOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "TerminateInstanceInAutoScalingGroupRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.TerminateInstanceInAutoScalingGroupOutput)
-	return ret0, ret1
-}
-
-// TerminateInstanceInAutoScalingGroupRequest indicates an expected call of TerminateInstanceInAutoScalingGroupRequest.
-func (mr *MockAutoScalingAPIMockRecorder) TerminateInstanceInAutoScalingGroupRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateInstanceInAutoScalingGroupRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).TerminateInstanceInAutoScalingGroupRequest), arg0)
-}
-
-// TerminateInstanceInAutoScalingGroupWithContext mocks base method.
-func (m *MockAutoScalingAPI) TerminateInstanceInAutoScalingGroupWithContext(arg0 context.Context, arg1 *autoscaling.TerminateInstanceInAutoScalingGroupInput, arg2 ...request.Option) (*autoscaling.TerminateInstanceInAutoScalingGroupOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "TerminateInstanceInAutoScalingGroupWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.TerminateInstanceInAutoScalingGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// TerminateInstanceInAutoScalingGroupWithContext indicates an expected call of TerminateInstanceInAutoScalingGroupWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) TerminateInstanceInAutoScalingGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateInstanceInAutoScalingGroupWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).TerminateInstanceInAutoScalingGroupWithContext), varargs...)
-}
-
-// UpdateAutoScalingGroup mocks base method.
-func (m *MockAutoScalingAPI) UpdateAutoScalingGroup(arg0 *autoscaling.UpdateAutoScalingGroupInput) (*autoscaling.UpdateAutoScalingGroupOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpdateAutoScalingGroup", arg0)
-	ret0, _ := ret[0].(*autoscaling.UpdateAutoScalingGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UpdateAutoScalingGroup indicates an expected call of UpdateAutoScalingGroup.
-func (mr *MockAutoScalingAPIMockRecorder) UpdateAutoScalingGroup(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAutoScalingGroup", reflect.TypeOf((*MockAutoScalingAPI)(nil).UpdateAutoScalingGroup), arg0)
-}
-
-// UpdateAutoScalingGroupRequest mocks base method.
-func (m *MockAutoScalingAPI) UpdateAutoScalingGroupRequest(arg0 *autoscaling.UpdateAutoScalingGroupInput) (*request.Request, *autoscaling.UpdateAutoScalingGroupOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpdateAutoScalingGroupRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*autoscaling.UpdateAutoScalingGroupOutput)
-	return ret0, ret1
-}
-
-// UpdateAutoScalingGroupRequest indicates an expected call of UpdateAutoScalingGroupRequest.
-func (mr *MockAutoScalingAPIMockRecorder) UpdateAutoScalingGroupRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAutoScalingGroupRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).UpdateAutoScalingGroupRequest), arg0)
-}
-
-// UpdateAutoScalingGroupWithContext mocks base method.
-func (m *MockAutoScalingAPI) UpdateAutoScalingGroupWithContext(arg0 context.Context, arg1 *autoscaling.UpdateAutoScalingGroupInput, arg2 ...request.Option) (*autoscaling.UpdateAutoScalingGroupOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "UpdateAutoScalingGroupWithContext", varargs...)
-	ret0, _ := ret[0].(*autoscaling.UpdateAutoScalingGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UpdateAutoScalingGroupWithContext indicates an expected call of UpdateAutoScalingGroupWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) UpdateAutoScalingGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAutoScalingGroupWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).UpdateAutoScalingGroupWithContext), varargs...)
-}
-
-// WaitUntilGroupExists mocks base method.
-func (m *MockAutoScalingAPI) WaitUntilGroupExists(arg0 *autoscaling.DescribeAutoScalingGroupsInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilGroupExists", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilGroupExists indicates an expected call of WaitUntilGroupExists.
-func (mr *MockAutoScalingAPIMockRecorder) WaitUntilGroupExists(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilGroupExists", reflect.TypeOf((*MockAutoScalingAPI)(nil).WaitUntilGroupExists), arg0)
-}
-
-// WaitUntilGroupExistsWithContext mocks base method.
-func (m *MockAutoScalingAPI) WaitUntilGroupExistsWithContext(arg0 context.Context, arg1 *autoscaling.DescribeAutoScalingGroupsInput, arg2 ...request.WaiterOption) error {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "WaitUntilGroupExistsWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilGroupExistsWithContext indicates an expected call of WaitUntilGroupExistsWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) WaitUntilGroupExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilGroupExistsWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).WaitUntilGroupExistsWithContext), varargs...)
-}
-
-// WaitUntilGroupInService mocks base method.
-func (m *MockAutoScalingAPI) WaitUntilGroupInService(arg0 *autoscaling.DescribeAutoScalingGroupsInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilGroupInService", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilGroupInService indicates an expected call of WaitUntilGroupInService.
-func (mr *MockAutoScalingAPIMockRecorder) WaitUntilGroupInService(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilGroupInService", reflect.TypeOf((*MockAutoScalingAPI)(nil).WaitUntilGroupInService), arg0)
-}
-
-// WaitUntilGroupInServiceWithContext mocks base method.
-func (m *MockAutoScalingAPI) WaitUntilGroupInServiceWithContext(arg0 context.Context, arg1 *autoscaling.DescribeAutoScalingGroupsInput, arg2 ...request.WaiterOption) error {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "WaitUntilGroupInServiceWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilGroupInServiceWithContext indicates an expected call of WaitUntilGroupInServiceWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) WaitUntilGroupInServiceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilGroupInServiceWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).WaitUntilGroupInServiceWithContext), varargs...)
-}
-
-// WaitUntilGroupNotExists mocks base method.
-func (m *MockAutoScalingAPI) WaitUntilGroupNotExists(arg0 *autoscaling.DescribeAutoScalingGroupsInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilGroupNotExists", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilGroupNotExists indicates an expected call of WaitUntilGroupNotExists.
-func (mr *MockAutoScalingAPIMockRecorder) WaitUntilGroupNotExists(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilGroupNotExists", reflect.TypeOf((*MockAutoScalingAPI)(nil).WaitUntilGroupNotExists), arg0)
-}
-
-// WaitUntilGroupNotExistsWithContext mocks base method.
-func (m *MockAutoScalingAPI) WaitUntilGroupNotExistsWithContext(arg0 context.Context, arg1 *autoscaling.DescribeAutoScalingGroupsInput, arg2 ...request.WaiterOption) error {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "WaitUntilGroupNotExistsWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilGroupNotExistsWithContext indicates an expected call of WaitUntilGroupNotExistsWithContext.
-func (mr *MockAutoScalingAPIMockRecorder) WaitUntilGroupNotExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilGroupNotExistsWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).WaitUntilGroupNotExistsWithContext), varargs...)
-}
diff --git a/pkg/cloud/services/autoscaling/mock_autoscalingiface/doc.go b/pkg/cloud/services/autoscaling/mock_autoscalingiface/doc.go
index f664299d6..dd96a0c4a 100644
--- a/pkg/cloud/services/autoscaling/mock_autoscalingiface/doc.go
+++ b/pkg/cloud/services/autoscaling/mock_autoscalingiface/doc.go
@@ -14,9 +14,9 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Package mock_autoscalingiface provides a mock implementation for the AutoScalingAPI interface.
+// Package mock_autoscalingiface provides a mock implementation for the autoscaling client interface.
 // Run go generate to regenerate this mock.
 //
-//go:generate ../../../../../hack/tools/bin/mockgen -destination autoscalingapi_mock.go -package mock_autoscalingiface github.com/aws/aws-sdk-go/service/autoscaling/autoscalingiface AutoScalingAPI
-//go:generate /usr/bin/env bash -c "cat ../../../../../hack/boilerplate/boilerplate.generatego.txt autoscalingapi_mock.go > _autoscalingapi_mock.go && mv _autoscalingapi_mock.go autoscalingapi_mock.go"
+//go:generate ../../../../../hack/tools/bin/mockgen -destination autoscaling_mock.go -package mock_autoscalingiface sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/autoscaling AutoScalingAPI
+//go:generate /usr/bin/env bash -c "cat ../../../../../hack/boilerplate/boilerplate.generatego.txt autoscaling_mock.go > _autoscaling_mock.go && mv _autoscaling_mock.go autoscaling_mock.go"
 package mock_autoscalingiface //nolint:stylecheck
diff --git a/pkg/cloud/services/autoscaling/service.go b/pkg/cloud/services/autoscaling/service.go
index 188ef77a4..ec9019bbf 100644
--- a/pkg/cloud/services/autoscaling/service.go
+++ b/pkg/cloud/services/autoscaling/service.go
@@ -17,7 +17,9 @@ limitations under the License.
 package asg
 
 import (
-	"github.com/aws/aws-sdk-go/service/autoscaling/autoscalingiface"
+	"context"
+
+	"github.com/aws/aws-sdk-go-v2/service/autoscaling"
 	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
 
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud"
@@ -29,10 +31,29 @@ import (
 // One alternative is to have a large list of functions from the asg client.
 type Service struct {
 	scope     cloud.ClusterScoper
-	ASGClient autoscalingiface.AutoScalingAPI
+	ASGClient AutoScalingAPI
 	EC2Client ec2iface.EC2API
 }
 
+// AutoScalingAPI is an interface for the AWS AutoScaling API client.
+type AutoScalingAPI interface {
+	CreateAutoScalingGroup(ctx context.Context, params *autoscaling.CreateAutoScalingGroupInput, optFns ...func(*autoscaling.Options)) (*autoscaling.CreateAutoScalingGroupOutput, error)
+	DeleteAutoScalingGroup(ctx context.Context, params *autoscaling.DeleteAutoScalingGroupInput, optFns ...func(*autoscaling.Options)) (*autoscaling.DeleteAutoScalingGroupOutput, error)
+	DescribeAutoScalingGroups(ctx context.Context, params *autoscaling.DescribeAutoScalingGroupsInput, optFns ...func(*autoscaling.Options)) (*autoscaling.DescribeAutoScalingGroupsOutput, error)
+	UpdateAutoScalingGroup(ctx context.Context, params *autoscaling.UpdateAutoScalingGroupInput, optFns ...func(*autoscaling.Options)) (*autoscaling.UpdateAutoScalingGroupOutput, error)
+	StartInstanceRefresh(ctx context.Context, params *autoscaling.StartInstanceRefreshInput, optFns ...func(*autoscaling.Options)) (*autoscaling.StartInstanceRefreshOutput, error)
+	CreateOrUpdateTags(ctx context.Context, params *autoscaling.CreateOrUpdateTagsInput, optFns ...func(*autoscaling.Options)) (*autoscaling.CreateOrUpdateTagsOutput, error)
+	ResumeProcesses(ctx context.Context, params *autoscaling.ResumeProcessesInput, optFns ...func(*autoscaling.Options)) (*autoscaling.ResumeProcessesOutput, error)
+	DeleteTags(ctx context.Context, params *autoscaling.DeleteTagsInput, optFns ...func(*autoscaling.Options)) (*autoscaling.DeleteTagsOutput, error)
+	SuspendProcesses(ctx context.Context, params *autoscaling.SuspendProcessesInput, optFns ...func(*autoscaling.Options)) (*autoscaling.SuspendProcessesOutput, error)
+	DescribeInstanceRefreshes(ctx context.Context, params *autoscaling.DescribeInstanceRefreshesInput, optFns ...func(*autoscaling.Options)) (*autoscaling.DescribeInstanceRefreshesOutput, error)
+	DescribeLifecycleHooks(ctx context.Context, params *autoscaling.DescribeLifecycleHooksInput, optFns ...func(*autoscaling.Options)) (*autoscaling.DescribeLifecycleHooksOutput, error)
+	PutLifecycleHook(ctx context.Context, params *autoscaling.PutLifecycleHookInput, optFns ...func(*autoscaling.Options)) (*autoscaling.PutLifecycleHookOutput, error)
+	DeleteLifecycleHook(ctx context.Context, params *autoscaling.DeleteLifecycleHookInput, optFns ...func(*autoscaling.Options)) (*autoscaling.DeleteLifecycleHookOutput, error)
+}
+
+var _ AutoScalingAPI = &autoscaling.Client{}
+
 // NewService returns a new service given the asg api client.
 func NewService(clusterScope cloud.ClusterScoper) *Service {
 	return &Service{
diff --git a/pkg/cloud/services/ec2/launchtemplate.go b/pkg/cloud/services/ec2/launchtemplate.go
index 148f8d486..000abdfde 100644
--- a/pkg/cloud/services/ec2/launchtemplate.go
+++ b/pkg/cloud/services/ec2/launchtemplate.go
@@ -680,6 +680,24 @@ func (s *Service) deleteLaunchTemplateVersion(id string, version *int64) error {
 	return nil
 }
 
+// SDKToSpotMarketOptions converts EC2 instance market options to SpotMarketOptions.
+func SDKToSpotMarketOptions(instanceMarketOptions *ec2.LaunchTemplateInstanceMarketOptions) *infrav1.SpotMarketOptions {
+	if instanceMarketOptions == nil || aws.StringValue(instanceMarketOptions.MarketType) != ec2.MarketTypeSpot {
+		return nil
+	}
+
+	if instanceMarketOptions.SpotOptions == nil {
+		return &infrav1.SpotMarketOptions{}
+	}
+
+	result := &infrav1.SpotMarketOptions{}
+	if instanceMarketOptions.SpotOptions.MaxPrice != nil {
+		result.MaxPrice = instanceMarketOptions.SpotOptions.MaxPrice
+	}
+
+	return result
+}
+
 // SDKToLaunchTemplate converts an AWS EC2 SDK instance to the CAPA instance type.
 func (s *Service) SDKToLaunchTemplate(d *ec2.LaunchTemplateVersion) (*expinfrav1.AWSLaunchTemplate, string, *apimachinerytypes.NamespacedName, error) {
 	v := d.LaunchTemplateData
@@ -688,9 +706,10 @@ func (s *Service) SDKToLaunchTemplate(d *ec2.LaunchTemplateVersion) (*expinfrav1
 		AMI: infrav1.AMIReference{
 			ID: v.ImageId,
 		},
-		InstanceType:  aws.StringValue(v.InstanceType),
-		SSHKeyName:    v.KeyName,
-		VersionNumber: d.VersionNumber,
+		InstanceType:      aws.StringValue(v.InstanceType),
+		SSHKeyName:        v.KeyName,
+		SpotMarketOptions: SDKToSpotMarketOptions(v.InstanceMarketOptions),
+		VersionNumber:     d.VersionNumber,
 	}
 
 	if v.MetadataOptions != nil {
@@ -777,6 +796,9 @@ func (s *Service) LaunchTemplateNeedsUpdate(scope scope.LaunchTemplateScope, inc
 	if !cmp.Equal(incoming.InstanceMetadataOptions, existing.InstanceMetadataOptions) {
 		return true, nil
 	}
+	if !cmp.Equal(incoming.SpotMarketOptions, existing.SpotMarketOptions) {
+		return true, nil
+	}
 
 	incomingIDs, err := s.GetAdditionalSecurityGroupsIDs(incoming.AdditionalSecurityGroups)
 	if err != nil {
diff --git a/pkg/cloud/services/eks/addons.go b/pkg/cloud/services/eks/addons.go
index 45c9a8cd8..c1bc494d8 100644
--- a/pkg/cloud/services/eks/addons.go
+++ b/pkg/cloud/services/eks/addons.go
@@ -197,7 +197,7 @@ func (s *Service) translateAPIToAddon(addons []ekscontrolplanev1.Addon) []*eksad
 		convertedAddon := &eksaddons.EKSAddon{
 			Name:                  &addon.Name,
 			Version:               &addon.Version,
-			Configuration:         &addon.Configuration,
+			Configuration:         convertConfiguration(addon.Configuration),
 			Tags:                  ngTags(s.scope.Cluster.Name, s.scope.AdditionalTags()),
 			ResolveConflict:       convertConflictResolution(*addon.ConflictResolution),
 			ServiceAccountRoleARN: addon.ServiceAccountRoleArn,
@@ -215,3 +215,10 @@ func convertConflictResolution(conflict ekscontrolplanev1.AddonResolution) *stri
 	}
 	return aws.String(eks.ResolveConflictsOverwrite)
 }
+
+func convertConfiguration(configuration string) *string {
+	if configuration == "" {
+		return nil
+	}
+	return &configuration
+}
diff --git a/pkg/cloud/services/eks/nodegroup.go b/pkg/cloud/services/eks/nodegroup.go
index 3ece1a942..fe9edbd33 100644
--- a/pkg/cloud/services/eks/nodegroup.go
+++ b/pkg/cloud/services/eks/nodegroup.go
@@ -20,9 +20,10 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/aws/aws-sdk-go-v2/service/autoscaling"
+	autoscalingtypes "github.com/aws/aws-sdk-go-v2/service/autoscaling/types"
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/service/autoscaling"
 	"github.com/aws/aws-sdk-go/service/eks"
 	"github.com/aws/aws-sdk-go/service/iam"
 	"github.com/google/go-cmp/cmp"
@@ -74,7 +75,7 @@ func (s *NodegroupService) describeNodegroup() (*eks.Nodegroup, error) {
 	return out.Nodegroup, nil
 }
 
-func (s *NodegroupService) describeASGs(ng *eks.Nodegroup) (*autoscaling.Group, error) {
+func (s *NodegroupService) describeASGs(ng *eks.Nodegroup) (*autoscalingtypes.AutoScalingGroup, error) {
 	eksClusterName := s.scope.KubernetesClusterName()
 	nodegroupName := s.scope.NodegroupName()
 	s.scope.Debug("describing node group ASG", "cluster", eksClusterName, "nodegroup", nodegroupName)
@@ -84,12 +85,12 @@ func (s *NodegroupService) describeASGs(ng *eks.Nodegroup) (*autoscaling.Group,
 	}
 
 	input := &autoscaling.DescribeAutoScalingGroupsInput{
-		AutoScalingGroupNames: []*string{
-			ng.Resources.AutoScalingGroups[0].Name,
+		AutoScalingGroupNames: []string{
+			*ng.Resources.AutoScalingGroups[0].Name,
 		},
 	}
 
-	out, err := s.AutoscalingClient.DescribeAutoScalingGroupsWithContext(context.TODO(), input)
+	out, err := s.AutoscalingClient.DescribeAutoScalingGroups(context.TODO(), input)
 	switch {
 	case awserrors.IsNotFound(err):
 		return nil, nil
@@ -99,7 +100,7 @@ func (s *NodegroupService) describeASGs(ng *eks.Nodegroup) (*autoscaling.Group,
 		return nil, errors.Wrap(err, "no ASG found")
 	}
 
-	return out.AutoScalingGroups[0], nil
+	return &out.AutoScalingGroups[0], nil
 }
 
 func (s *NodegroupService) scalingConfig() *eks.NodegroupScalingConfig {
@@ -615,9 +616,9 @@ func (s *NodegroupService) setStatus(ng *eks.Nodegroup) error {
 	if managedPool.Status.Ready && ng.Resources != nil && len(ng.Resources.AutoScalingGroups) > 0 {
 		req := autoscaling.DescribeAutoScalingGroupsInput{}
 		for _, asg := range ng.Resources.AutoScalingGroups {
-			req.AutoScalingGroupNames = append(req.AutoScalingGroupNames, asg.Name)
+			req.AutoScalingGroupNames = append(req.AutoScalingGroupNames, *asg.Name)
 		}
-		groups, err := s.AutoscalingClient.DescribeAutoScalingGroupsWithContext(context.TODO(), &req)
+		groups, err := s.AutoscalingClient.DescribeAutoScalingGroups(context.TODO(), &req)
 		if err != nil {
 			return errors.Wrap(err, "failed to describe AutoScalingGroup for nodegroup")
 		}
diff --git a/pkg/cloud/services/eks/service.go b/pkg/cloud/services/eks/service.go
index 6f6cb280f..c36672092 100644
--- a/pkg/cloud/services/eks/service.go
+++ b/pkg/cloud/services/eks/service.go
@@ -19,8 +19,8 @@ package eks
 import (
 	"net/http"
 
+	"github.com/aws/aws-sdk-go-v2/service/autoscaling"
 	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/autoscaling/autoscalingiface"
 	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
 	"github.com/aws/aws-sdk-go/service/eks"
 	"github.com/aws/aws-sdk-go/service/eks/eksiface"
@@ -93,7 +93,7 @@ func NewService(controlPlaneScope *scope.ManagedControlPlaneScope, opts ...Servi
 type NodegroupService struct {
 	scope             *scope.ManagedMachinePoolScope
 	ASGService        services.ASGInterface
-	AutoscalingClient autoscalingiface.AutoScalingAPI
+	AutoscalingClient *autoscaling.Client
 	EKSClient         eksiface.EKSAPI
 	iam.IAMService
 	STSClient stsiface.STSAPI
diff --git a/pkg/cloud/services/eks/tags.go b/pkg/cloud/services/eks/tags.go
index 1ed0fd60e..fab3ce8fa 100644
--- a/pkg/cloud/services/eks/tags.go
+++ b/pkg/cloud/services/eks/tags.go
@@ -20,8 +20,9 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/aws/aws-sdk-go-v2/service/autoscaling"
+	autoscalingtypes "github.com/aws/aws-sdk-go-v2/service/autoscaling/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/autoscaling"
 	"github.com/aws/aws-sdk-go/service/eks"
 	"github.com/aws/aws-sdk-go/service/eks/eksiface"
 	"github.com/pkg/errors"
@@ -115,7 +116,7 @@ func (s *NodegroupService) reconcileTags(ng *eks.Nodegroup) error {
 	return updateTags(s.EKSClient, ng.NodegroupArn, aws.StringValueMap(ng.Tags), tags)
 }
 
-func tagDescriptionsToMap(input []*autoscaling.TagDescription) map[string]string {
+func tagDescriptionsToMap(input []autoscalingtypes.TagDescription) map[string]string {
 	tags := make(map[string]string)
 	for _, v := range input {
 		tags[*v.Key] = *v.Value
@@ -140,7 +141,7 @@ func (s *NodegroupService) reconcileASGTags(ng *eks.Nodegroup) error {
 			// https://stackoverflow.com/questions/62446118/implicit-memory-aliasing-in-for-loop
 			kCopy := k
 			vCopy := v
-			input.Tags = append(input.Tags, &autoscaling.Tag{
+			input.Tags = append(input.Tags, autoscalingtypes.Tag{
 				Key:               &kCopy,
 				PropagateAtLaunch: aws.Bool(true),
 				ResourceId:        asg.AutoScalingGroupName,
@@ -148,7 +149,7 @@ func (s *NodegroupService) reconcileASGTags(ng *eks.Nodegroup) error {
 				Value:             &vCopy,
 			})
 		}
-		_, err = s.AutoscalingClient.CreateOrUpdateTagsWithContext(context.TODO(), input)
+		_, err = s.AutoscalingClient.CreateOrUpdateTags(context.TODO(), input)
 		if err != nil {
 			return errors.Wrap(err, "failed to add tags to nodegroup's AutoScalingGroup")
 		}
@@ -160,13 +161,13 @@ func (s *NodegroupService) reconcileASGTags(ng *eks.Nodegroup) error {
 			// The k/vCopy is used to address the "Implicit memory aliasing in for loop" issue
 			// https://stackoverflow.com/questions/62446118/implicit-memory-aliasing-in-for-loop
 			kCopy := k
-			input.Tags = append(input.Tags, &autoscaling.Tag{
+			input.Tags = append(input.Tags, autoscalingtypes.Tag{
 				Key:          &kCopy,
 				ResourceId:   asg.AutoScalingGroupName,
 				ResourceType: ptr.To[string]("auto-scaling-group"),
 			})
 		}
-		_, err = s.AutoscalingClient.DeleteTagsWithContext(context.TODO(), input)
+		_, err = s.AutoscalingClient.DeleteTags(context.TODO(), input)
 		if err != nil {
 			return errors.Wrap(err, "failed to delete tags to nodegroup's AutoScalingGroup")
 		}
diff --git a/pkg/cloud/services/s3/s3.go b/pkg/cloud/services/s3/s3.go
index 2b8369e34..f9aa20eb3 100644
--- a/pkg/cloud/services/s3/s3.go
+++ b/pkg/cloud/services/s3/s3.go
@@ -65,6 +65,8 @@ type S3API interface {
 	PutObject(ctx context.Context, params *s3.PutObjectInput, optFns ...func(*s3.Options)) (*s3.PutObjectOutput, error)
 }
 
+var _ S3API = &s3.Client{}
+
 // NewService returns a new service given the api clients.
 func NewService(s3Scope scope.S3Scope) *Service {
 	s3Client := scope.NewS3Client(s3Scope, s3Scope, s3Scope, s3Scope.InfraCluster())
diff --git a/pkg/eks/addons/types.go b/pkg/eks/addons/types.go
index 67c4a2b58..9ddce2c17 100644
--- a/pkg/eks/addons/types.go
+++ b/pkg/eks/addons/types.go
@@ -36,7 +36,7 @@ type EKSAddon struct {
 
 // IsEqual determines if 2 EKSAddon are equal.
 func (e *EKSAddon) IsEqual(other *EKSAddon, includeTags bool) bool {
-	//NOTE: we do not compare the ARN as that is only for existing addons
+	// NOTE: we do not compare the ARN as that is only for existing addons
 	if e == other {
 		return true
 	}
@@ -49,9 +49,6 @@ func (e *EKSAddon) IsEqual(other *EKSAddon, includeTags bool) bool {
 	if !cmp.Equal(e.Configuration, other.Configuration) {
 		return false
 	}
-	if !cmp.Equal(e.ResolveConflict, other.ResolveConflict) {
-		return false
-	}
 
 	if includeTags {
 		diffTags := e.Tags.Difference(other.Tags)
diff --git a/pkg/utils/utils.go b/pkg/utils/utils.go
index 9bad7e0a7..748c95f23 100644
--- a/pkg/utils/utils.go
+++ b/pkg/utils/utils.go
@@ -4,7 +4,9 @@ package utils
 import (
 	"context"
 	"fmt"
+	"math"
 
+	"k8s.io/utils/ptr"
 	crclient "sigs.k8s.io/controller-runtime/pkg/client"
 
 	clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
@@ -25,3 +27,24 @@ func GetMachinePools(ctx context.Context, client crclient.Client, clusterName st
 
 	return machinePoolList.Items, nil
 }
+
+// ToInt64Pointer converts an int32 pointer to an int64 pointer.
+func ToInt64Pointer(to *int32) *int64 {
+	if to == nil {
+		return nil
+	}
+	return ptr.To(int64(*to))
+}
+
+// ToInt32Pointer converts an int64 pointer to an int32 pointer.
+func ToInt32Pointer(to *int64) *int32 {
+	if to == nil {
+		return nil
+	}
+
+	if *to > math.MaxInt32 || *to < math.MinInt32 {
+		panic(fmt.Sprintf("Value %d is out of int32 range", *to))
+	}
+
+	return ptr.To(int32(*to))
+}



Test patch:
diff --git a/pkg/cloud/services/autoscaling/autoscalinggroup_test.go b/pkg/cloud/services/autoscaling/autoscalinggroup_test.go
index 943469616..91660a139 100644
--- a/pkg/cloud/services/autoscaling/autoscalinggroup_test.go
+++ b/pkg/cloud/services/autoscaling/autoscalinggroup_test.go
@@ -21,12 +21,14 @@ import (
 	"sort"
 	"testing"
 
+	"github.com/aws/aws-sdk-go-v2/service/autoscaling"
+	autoscalingtypes "github.com/aws/aws-sdk-go-v2/service/autoscaling/types"
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/autoscaling"
 	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/golang/mock/gomock"
 	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
 	. "github.com/onsi/gomega"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -60,9 +62,9 @@ func TestServiceGetASGByName(t *testing.T) {
 			wantErr:         false,
 			wantASG:         false,
 			expect: func(m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.DescribeAutoScalingGroupsWithContext(context.TODO(), gomock.Eq(&autoscaling.DescribeAutoScalingGroupsInput{
-					AutoScalingGroupNames: []*string{
-						aws.String("test-asg-is-not-present"),
+				m.DescribeAutoScalingGroups(context.TODO(), gomock.Eq(&autoscaling.DescribeAutoScalingGroupsInput{
+					AutoScalingGroupNames: []string{
+						"test-asg-is-not-present",
 					},
 				})).
 					Return(nil, awserrors.NewNotFound("not found"))
@@ -74,9 +76,9 @@ func TestServiceGetASGByName(t *testing.T) {
 			wantErr:         true,
 			wantASG:         false,
 			expect: func(m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.DescribeAutoScalingGroupsWithContext(context.TODO(), gomock.Eq(&autoscaling.DescribeAutoScalingGroupsInput{
-					AutoScalingGroupNames: []*string{
-						aws.String("dependency-failure-occurred"),
+				m.DescribeAutoScalingGroups(context.TODO(), gomock.Eq(&autoscaling.DescribeAutoScalingGroupsInput{
+					AutoScalingGroupNames: []string{
+						"dependency-failure-occurred",
 					},
 				})).
 					Return(nil, awserrors.NewFailedDependency("unknown error occurred"))
@@ -88,21 +90,21 @@ func TestServiceGetASGByName(t *testing.T) {
 			wantErr:         false,
 			wantASG:         true,
 			expect: func(m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.DescribeAutoScalingGroupsWithContext(context.TODO(), gomock.Eq(&autoscaling.DescribeAutoScalingGroupsInput{
-					AutoScalingGroupNames: []*string{
-						aws.String("test-group-is-present"),
+				m.DescribeAutoScalingGroups(context.TODO(), gomock.Eq(&autoscaling.DescribeAutoScalingGroupsInput{
+					AutoScalingGroupNames: []string{
+						"test-group-is-present",
 					},
 				})).
 					Return(&autoscaling.DescribeAutoScalingGroupsOutput{
-						AutoScalingGroups: []*autoscaling.Group{
+						AutoScalingGroups: []autoscalingtypes.AutoScalingGroup{
 							{
 								AutoScalingGroupName: aws.String("test-group-is-present"),
-								MixedInstancesPolicy: &autoscaling.MixedInstancesPolicy{
-									InstancesDistribution: &autoscaling.InstancesDistribution{
+								MixedInstancesPolicy: &autoscalingtypes.MixedInstancesPolicy{
+									InstancesDistribution: &autoscalingtypes.InstancesDistribution{
 										OnDemandAllocationStrategy: aws.String("prioritized"),
 										SpotAllocationStrategy:     aws.String("price-capacity-optimized"),
 									},
-									LaunchTemplate: &autoscaling.LaunchTemplate{},
+									LaunchTemplate: &autoscalingtypes.LaunchTemplate{},
 								},
 							},
 						}}, nil)
@@ -135,28 +137,28 @@ func TestServiceGetASGByName(t *testing.T) {
 func TestServiceSDKToAutoScalingGroup(t *testing.T) {
 	tests := []struct {
 		name    string
-		input   *autoscaling.Group
+		input   *autoscalingtypes.AutoScalingGroup
 		want    *expinfrav1.AutoScalingGroup
 		wantErr bool
 	}{
 		{
 			name: "valid input - all required fields filled",
-			input: &autoscaling.Group{
+			input: &autoscalingtypes.AutoScalingGroup{
 				AutoScalingGroupARN:  aws.String("test-id"),
 				AutoScalingGroupName: aws.String("test-name"),
-				DesiredCapacity:      aws.Int64(1234),
-				MaxSize:              aws.Int64(1234),
-				MinSize:              aws.Int64(1234),
+				DesiredCapacity:      aws.Int32(1234),
+				MaxSize:              aws.Int32(1234),
+				MinSize:              aws.Int32(1234),
 				CapacityRebalance:    aws.Bool(true),
-				MixedInstancesPolicy: &autoscaling.MixedInstancesPolicy{
-					InstancesDistribution: &autoscaling.InstancesDistribution{
+				MixedInstancesPolicy: &autoscalingtypes.MixedInstancesPolicy{
+					InstancesDistribution: &autoscalingtypes.InstancesDistribution{
 						OnDemandAllocationStrategy:          aws.String("prioritized"),
-						OnDemandBaseCapacity:                aws.Int64(1234),
-						OnDemandPercentageAboveBaseCapacity: aws.Int64(1234),
+						OnDemandBaseCapacity:                aws.Int32(1234),
+						OnDemandPercentageAboveBaseCapacity: aws.Int32(1234),
 						SpotAllocationStrategy:              aws.String("lowest-price"),
 					},
-					LaunchTemplate: &autoscaling.LaunchTemplate{
-						Overrides: []*autoscaling.LaunchTemplateOverrides{
+					LaunchTemplate: &autoscalingtypes.LaunchTemplate{
+						Overrides: []autoscalingtypes.LaunchTemplateOverrides{
 							{
 								InstanceType:     aws.String("t2.medium"),
 								WeightedCapacity: aws.String("test-weighted-cap"),
@@ -190,11 +192,11 @@ func TestServiceSDKToAutoScalingGroup(t *testing.T) {
 		},
 		{
 			name: "valid input - suspended processes",
-			input: &autoscaling.Group{
-				DesiredCapacity: aws.Int64(1234),
-				MaxSize:         aws.Int64(1234),
-				MinSize:         aws.Int64(1234),
-				SuspendedProcesses: []*autoscaling.SuspendedProcess{
+			input: &autoscalingtypes.AutoScalingGroup{
+				DesiredCapacity: aws.Int32(1234),
+				MaxSize:         aws.Int32(1234),
+				MinSize:         aws.Int32(1234),
+				SuspendedProcesses: []autoscalingtypes.SuspendedProcess{
 					{
 						ProcessName:      aws.String("process1"),
 						SuspensionReason: aws.String("not relevant"),
@@ -211,22 +213,22 @@ func TestServiceSDKToAutoScalingGroup(t *testing.T) {
 		},
 		{
 			name: "valid input - all fields filled",
-			input: &autoscaling.Group{
+			input: &autoscalingtypes.AutoScalingGroup{
 				AutoScalingGroupARN:  aws.String("test-id"),
 				AutoScalingGroupName: aws.String("test-name"),
-				DesiredCapacity:      aws.Int64(1234),
-				MaxSize:              aws.Int64(1234),
-				MinSize:              aws.Int64(1234),
+				DesiredCapacity:      aws.Int32(1234),
+				MaxSize:              aws.Int32(1234),
+				MinSize:              aws.Int32(1234),
 				CapacityRebalance:    aws.Bool(true),
-				MixedInstancesPolicy: &autoscaling.MixedInstancesPolicy{
-					InstancesDistribution: &autoscaling.InstancesDistribution{
+				MixedInstancesPolicy: &autoscalingtypes.MixedInstancesPolicy{
+					InstancesDistribution: &autoscalingtypes.InstancesDistribution{
 						OnDemandAllocationStrategy:          aws.String("prioritized"),
-						OnDemandBaseCapacity:                aws.Int64(1234),
-						OnDemandPercentageAboveBaseCapacity: aws.Int64(1234),
+						OnDemandBaseCapacity:                aws.Int32(1234),
+						OnDemandPercentageAboveBaseCapacity: aws.Int32(1234),
 						SpotAllocationStrategy:              aws.String("lowest-price"),
 					},
-					LaunchTemplate: &autoscaling.LaunchTemplate{
-						Overrides: []*autoscaling.LaunchTemplateOverrides{
+					LaunchTemplate: &autoscalingtypes.LaunchTemplate{
+						Overrides: []autoscalingtypes.LaunchTemplateOverrides{
 							{
 								InstanceType:     aws.String("t2.medium"),
 								WeightedCapacity: aws.String("test-weighted-cap"),
@@ -235,16 +237,16 @@ func TestServiceSDKToAutoScalingGroup(t *testing.T) {
 					},
 				},
 				Status: aws.String("status"),
-				Tags: []*autoscaling.TagDescription{
+				Tags: []autoscalingtypes.TagDescription{
 					{
 						Key:   aws.String("key"),
 						Value: aws.String("value"),
 					},
 				},
-				Instances: []*autoscaling.Instance{
+				Instances: []autoscalingtypes.Instance{
 					{
 						InstanceId:       aws.String("instanceId"),
-						LifecycleState:   aws.String("lifecycleState"),
+						LifecycleState:   "lifecycleState",
 						AvailabilityZone: aws.String("us-east-1a"),
 					},
 				},
@@ -285,12 +287,12 @@ func TestServiceSDKToAutoScalingGroup(t *testing.T) {
 		},
 		{
 			name: "valid input - without mixedInstancesPolicy",
-			input: &autoscaling.Group{
+			input: &autoscalingtypes.AutoScalingGroup{
 				AutoScalingGroupARN:  aws.String("test-id"),
 				AutoScalingGroupName: aws.String("test-name"),
-				DesiredCapacity:      aws.Int64(1234),
-				MaxSize:              aws.Int64(1234),
-				MinSize:              aws.Int64(1234),
+				DesiredCapacity:      aws.Int32(1234),
+				MaxSize:              aws.Int32(1234),
+				MinSize:              aws.Int32(1234),
 				CapacityRebalance:    aws.Bool(true),
 				MixedInstancesPolicy: nil,
 			},
@@ -307,22 +309,22 @@ func TestServiceSDKToAutoScalingGroup(t *testing.T) {
 		},
 		{
 			name: "invalid input - incorrect on-demand allocation strategy",
-			input: &autoscaling.Group{
+			input: &autoscalingtypes.AutoScalingGroup{
 				AutoScalingGroupARN:  aws.String("test-id"),
 				AutoScalingGroupName: aws.String("test-name"),
-				DesiredCapacity:      aws.Int64(1234),
-				MaxSize:              aws.Int64(1234),
-				MinSize:              aws.Int64(1234),
+				DesiredCapacity:      aws.Int32(1234),
+				MaxSize:              aws.Int32(1234),
+				MinSize:              aws.Int32(1234),
 				CapacityRebalance:    aws.Bool(true),
-				MixedInstancesPolicy: &autoscaling.MixedInstancesPolicy{
-					InstancesDistribution: &autoscaling.InstancesDistribution{
+				MixedInstancesPolicy: &autoscalingtypes.MixedInstancesPolicy{
+					InstancesDistribution: &autoscalingtypes.InstancesDistribution{
 						OnDemandAllocationStrategy:          aws.String("prioritized"),
-						OnDemandBaseCapacity:                aws.Int64(1234),
-						OnDemandPercentageAboveBaseCapacity: aws.Int64(1234),
+						OnDemandBaseCapacity:                aws.Int32(1234),
+						OnDemandPercentageAboveBaseCapacity: aws.Int32(1234),
 						SpotAllocationStrategy:              aws.String("INVALIDONDEMANDALLOCATIONSTRATEGY"),
 					},
-					LaunchTemplate: &autoscaling.LaunchTemplate{
-						Overrides: []*autoscaling.LaunchTemplateOverrides{
+					LaunchTemplate: &autoscalingtypes.LaunchTemplate{
+						Overrides: []autoscalingtypes.LaunchTemplateOverrides{
 							{
 								InstanceType:     aws.String("t2.medium"),
 								WeightedCapacity: aws.String("test-weighted-cap"),
@@ -335,22 +337,22 @@ func TestServiceSDKToAutoScalingGroup(t *testing.T) {
 		},
 		{
 			name: "invalid input - incorrect spot allocation strategy",
-			input: &autoscaling.Group{
+			input: &autoscalingtypes.AutoScalingGroup{
 				AutoScalingGroupARN:  aws.String("test-id"),
 				AutoScalingGroupName: aws.String("test-name"),
-				DesiredCapacity:      aws.Int64(1234),
-				MaxSize:              aws.Int64(1234),
-				MinSize:              aws.Int64(1234),
+				DesiredCapacity:      aws.Int32(1234),
+				MaxSize:              aws.Int32(1234),
+				MinSize:              aws.Int32(1234),
 				CapacityRebalance:    aws.Bool(true),
-				MixedInstancesPolicy: &autoscaling.MixedInstancesPolicy{
-					InstancesDistribution: &autoscaling.InstancesDistribution{
+				MixedInstancesPolicy: &autoscalingtypes.MixedInstancesPolicy{
+					InstancesDistribution: &autoscalingtypes.InstancesDistribution{
 						OnDemandAllocationStrategy:          aws.String("prioritized"),
-						OnDemandBaseCapacity:                aws.Int64(1234),
-						OnDemandPercentageAboveBaseCapacity: aws.Int64(1234),
+						OnDemandBaseCapacity:                aws.Int32(1234),
+						OnDemandPercentageAboveBaseCapacity: aws.Int32(1234),
 						SpotAllocationStrategy:              aws.String("INVALIDSPOTALLOCATIONSTRATEGY"),
 					},
-					LaunchTemplate: &autoscaling.LaunchTemplate{
-						Overrides: []*autoscaling.LaunchTemplateOverrides{
+					LaunchTemplate: &autoscalingtypes.LaunchTemplate{
+						Overrides: []autoscalingtypes.LaunchTemplateOverrides{
 							{
 								InstanceType:     aws.String("t2.medium"),
 								WeightedCapacity: aws.String("test-weighted-cap"),
@@ -401,9 +403,9 @@ func TestServiceASGIfExists(t *testing.T) {
 			wantErr: false,
 			wantASG: false,
 			expect: func(m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.DescribeAutoScalingGroupsWithContext(context.TODO(), gomock.Eq(&autoscaling.DescribeAutoScalingGroupsInput{
-					AutoScalingGroupNames: []*string{
-						aws.String("asgName"),
+				m.DescribeAutoScalingGroups(context.TODO(), gomock.Eq(&autoscaling.DescribeAutoScalingGroupsInput{
+					AutoScalingGroupNames: []string{
+						"asgName",
 					},
 				})).
 					Return(nil, awserrors.NewNotFound("resource not found"))
@@ -415,9 +417,9 @@ func TestServiceASGIfExists(t *testing.T) {
 			wantErr: true,
 			wantASG: false,
 			expect: func(m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.DescribeAutoScalingGroupsWithContext(context.TODO(), gomock.Eq(&autoscaling.DescribeAutoScalingGroupsInput{
-					AutoScalingGroupNames: []*string{
-						aws.String("asgName"),
+				m.DescribeAutoScalingGroups(context.TODO(), gomock.Eq(&autoscaling.DescribeAutoScalingGroupsInput{
+					AutoScalingGroupNames: []string{
+						"asgName",
 					},
 				})).
 					Return(nil, awserrors.NewFailedDependency("unknown error occurred"))
@@ -429,21 +431,21 @@ func TestServiceASGIfExists(t *testing.T) {
 			wantErr: false,
 			wantASG: true,
 			expect: func(m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.DescribeAutoScalingGroupsWithContext(context.TODO(), gomock.Eq(&autoscaling.DescribeAutoScalingGroupsInput{
-					AutoScalingGroupNames: []*string{
-						aws.String("asgName"),
+				m.DescribeAutoScalingGroups(context.TODO(), gomock.Eq(&autoscaling.DescribeAutoScalingGroupsInput{
+					AutoScalingGroupNames: []string{
+						"asgName",
 					},
 				})).
 					Return(&autoscaling.DescribeAutoScalingGroupsOutput{
-						AutoScalingGroups: []*autoscaling.Group{
+						AutoScalingGroups: []autoscalingtypes.AutoScalingGroup{
 							{
 								AutoScalingGroupName: aws.String("asgName"),
-								MixedInstancesPolicy: &autoscaling.MixedInstancesPolicy{
-									InstancesDistribution: &autoscaling.InstancesDistribution{
+								MixedInstancesPolicy: &autoscalingtypes.MixedInstancesPolicy{
+									InstancesDistribution: &autoscalingtypes.InstancesDistribution{
 										OnDemandAllocationStrategy: aws.String("prioritized"),
 										SpotAllocationStrategy:     aws.String("price-capacity-optimized"),
 									},
-									LaunchTemplate: &autoscaling.LaunchTemplate{},
+									LaunchTemplate: &autoscalingtypes.LaunchTemplate{},
 								},
 							},
 						}}, nil)
@@ -490,31 +492,31 @@ func TestServiceCreateASG(t *testing.T) {
 				expected := &autoscaling.CreateAutoScalingGroupInput{
 					AutoScalingGroupName:  aws.String("create-asg-success"),
 					CapacityRebalance:     aws.Bool(false),
-					DefaultCooldown:       aws.Int64(0),
-					DefaultInstanceWarmup: aws.Int64(0),
-					MixedInstancesPolicy: &autoscaling.MixedInstancesPolicy{
-						InstancesDistribution: &autoscaling.InstancesDistribution{
+					DefaultCooldown:       aws.Int32(0),
+					DefaultInstanceWarmup: aws.Int32(0),
+					MixedInstancesPolicy: &autoscalingtypes.MixedInstancesPolicy{
+						InstancesDistribution: &autoscalingtypes.InstancesDistribution{
 							OnDemandAllocationStrategy:          aws.String("prioritized"),
-							OnDemandBaseCapacity:                aws.Int64(0),
-							OnDemandPercentageAboveBaseCapacity: aws.Int64(100),
+							OnDemandBaseCapacity:                aws.Int32(0),
+							OnDemandPercentageAboveBaseCapacity: aws.Int32(100),
 							SpotAllocationStrategy:              aws.String(""),
 						},
-						LaunchTemplate: &autoscaling.LaunchTemplate{
-							LaunchTemplateSpecification: &autoscaling.LaunchTemplateSpecification{
+						LaunchTemplate: &autoscalingtypes.LaunchTemplate{
+							LaunchTemplateSpecification: &autoscalingtypes.LaunchTemplateSpecification{
 								LaunchTemplateName: aws.String("create-asg-success"),
 								Version:            aws.String("$Latest"),
 							},
-							Overrides: []*autoscaling.LaunchTemplateOverrides{
+							Overrides: []autoscalingtypes.LaunchTemplateOverrides{
 								{
 									InstanceType: aws.String("t1.large"),
 								},
 							},
 						},
 					},
-					DesiredCapacity: aws.Int64(1),
-					MaxSize:         aws.Int64(2),
-					MinSize:         aws.Int64(1),
-					Tags: []*autoscaling.Tag{
+					DesiredCapacity: aws.Int32(1),
+					MaxSize:         aws.Int32(2),
+					MinSize:         aws.Int32(1),
+					Tags: []autoscalingtypes.Tag{
 						{
 							Key:               aws.String("kubernetes.io/cluster/test"),
 							PropagateAtLaunch: aws.Bool(false),
@@ -547,18 +549,26 @@ func TestServiceCreateASG(t *testing.T) {
 					VPCZoneIdentifier: aws.String("subnet1"),
 				}
 
-				m.CreateAutoScalingGroupWithContext(context.TODO(), gomock.AssignableToTypeOf(&autoscaling.CreateAutoScalingGroupInput{})).Do(
+				m.CreateAutoScalingGroup(context.TODO(), gomock.AssignableToTypeOf(&autoscaling.CreateAutoScalingGroupInput{})).Do(
 					func(ctx context.Context, actual *autoscaling.CreateAutoScalingGroupInput, requestOptions ...request.Option) (*autoscaling.CreateAutoScalingGroupOutput, error) {
-						sortTagsByKey := func(tags []*autoscaling.Tag) {
+						sortTagsByKey := func(tags []autoscalingtypes.Tag) {
 							sort.Slice(tags, func(i, j int) bool {
 								return *(tags[i].Key) < *(tags[j].Key)
 							})
 						}
-						// sorting tags to avoid failure due to different ordering of tags
+						// Sort tags to avoid failures due to ordering differences
 						sortTagsByKey(actual.Tags)
 						sortTagsByKey(expected.Tags)
-						if !cmp.Equal(expected, actual) {
-							t.Fatalf("Actual CreateAutoScalingGroupInput did not match expected, Actual : %v, Expected: %v", actual, expected)
+						if !cmp.Equal(expected, actual, cmpopts.IgnoreUnexported(
+							autoscalingtypes.InstancesDistribution{},
+							autoscalingtypes.MixedInstancesPolicy{},
+							autoscalingtypes.LaunchTemplate{},
+							autoscalingtypes.LaunchTemplateSpecification{},
+							autoscalingtypes.LaunchTemplateOverrides{},
+							autoscalingtypes.Tag{},
+							autoscaling.CreateAutoScalingGroupInput{},
+						)) {
+							t.Fatalf("Actual CreateAutoScalingGroupInput did not match expected, Actual: %v, Expected: %v", actual, expected)
 						}
 						return &autoscaling.CreateAutoScalingGroupOutput{}, nil
 					})
@@ -577,7 +587,7 @@ func TestServiceCreateASG(t *testing.T) {
 			},
 			wantErr: false,
 			expect: func(m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.CreateAutoScalingGroupWithContext(context.TODO(), gomock.AssignableToTypeOf(&autoscaling.CreateAutoScalingGroupInput{})).Do(
+				m.CreateAutoScalingGroup(context.TODO(), gomock.AssignableToTypeOf(&autoscaling.CreateAutoScalingGroupInput{})).Do(
 					func(ctx context.Context, actual *autoscaling.CreateAutoScalingGroupInput, requestOptions ...request.Option) (*autoscaling.CreateAutoScalingGroupOutput, error) {
 						if actual.DesiredCapacity != nil {
 							t.Fatalf("Actual DesiredCapacity did not match expected, Actual: %d, Expected: <nil>", *actual.DesiredCapacity)
@@ -599,7 +609,7 @@ func TestServiceCreateASG(t *testing.T) {
 			},
 			wantErr: false,
 			expect: func(m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.CreateAutoScalingGroupWithContext(context.TODO(), gomock.AssignableToTypeOf(&autoscaling.CreateAutoScalingGroupInput{})).Do(
+				m.CreateAutoScalingGroup(context.TODO(), gomock.AssignableToTypeOf(&autoscaling.CreateAutoScalingGroupInput{})).Do(
 					func(ctx context.Context, actual *autoscaling.CreateAutoScalingGroupInput, requestOptions ...request.Option) (*autoscaling.CreateAutoScalingGroupOutput, error) {
 						if actual.DesiredCapacity != nil {
 							t.Fatalf("Actual DesiredCapacity did not match expected, Actual: %d, Expected: <nil>", *actual.DesiredCapacity)
@@ -650,7 +660,7 @@ func TestServiceCreateASG(t *testing.T) {
 			wantErr: true,
 			wantASG: false,
 			expect: func(m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.CreateAutoScalingGroupWithContext(context.TODO(), gomock.AssignableToTypeOf(&autoscaling.CreateAutoScalingGroupInput{})).Return(nil, awserrors.NewFailedDependency("dependency failure"))
+				m.CreateAutoScalingGroup(context.TODO(), gomock.AssignableToTypeOf(&autoscaling.CreateAutoScalingGroupInput{})).Return(nil, awserrors.NewFailedDependency("dependency failure"))
 			},
 		},
 		{
@@ -713,12 +723,12 @@ func TestServiceUpdateASG(t *testing.T) {
 				mps.AWSMachinePool.Spec.MaxSize = 5
 			},
 			expect: func(e *mocks.MockEC2APIMockRecorder, m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder, g *WithT) {
-				m.UpdateAutoScalingGroupWithContext(context.TODO(), gomock.AssignableToTypeOf(&autoscaling.UpdateAutoScalingGroupInput{})).DoAndReturn(func(ctx context.Context, input *autoscaling.UpdateAutoScalingGroupInput, options ...request.Option) (*autoscaling.UpdateAutoScalingGroupOutput, error) {
+				m.UpdateAutoScalingGroup(context.TODO(), gomock.AssignableToTypeOf(&autoscaling.UpdateAutoScalingGroupInput{})).DoAndReturn(func(ctx context.Context, input *autoscaling.UpdateAutoScalingGroupInput, options ...request.Option) (*autoscaling.UpdateAutoScalingGroupOutput, error) {
 					// CAPA should set min/max, and because there's no "externally managed" annotation, also the
 					// "desired" number of instances
-					g.Expect(input.MinSize).To(BeComparableTo(ptr.To[int64](2)))
-					g.Expect(input.MaxSize).To(BeComparableTo(ptr.To[int64](5)))
-					g.Expect(input.DesiredCapacity).To(BeComparableTo(ptr.To[int64](3)))
+					g.Expect(input.MinSize).To(BeComparableTo(ptr.To[int32](2)))
+					g.Expect(input.MaxSize).To(BeComparableTo(ptr.To[int32](5)))
+					g.Expect(input.DesiredCapacity).To(BeComparableTo(ptr.To[int32](3)))
 					return &autoscaling.UpdateAutoScalingGroupOutput{}, nil
 				})
 			},
@@ -731,7 +741,7 @@ func TestServiceUpdateASG(t *testing.T) {
 				mps.AWSMachinePool.Spec.MixedInstancesPolicy = nil
 			},
 			expect: func(e *mocks.MockEC2APIMockRecorder, m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder, g *WithT) {
-				m.UpdateAutoScalingGroupWithContext(context.TODO(), gomock.AssignableToTypeOf(&autoscaling.UpdateAutoScalingGroupInput{})).Return(nil, awserrors.NewFailedDependency("dependency failure"))
+				m.UpdateAutoScalingGroup(context.TODO(), gomock.AssignableToTypeOf(&autoscaling.UpdateAutoScalingGroupInput{})).Return(nil, awserrors.NewFailedDependency("dependency failure"))
 			},
 		},
 		{
@@ -746,10 +756,10 @@ func TestServiceUpdateASG(t *testing.T) {
 				mps.AWSMachinePool.Spec.MaxSize = 50
 			},
 			expect: func(e *mocks.MockEC2APIMockRecorder, m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder, g *WithT) {
-				m.UpdateAutoScalingGroupWithContext(context.TODO(), gomock.AssignableToTypeOf(&autoscaling.UpdateAutoScalingGroupInput{})).DoAndReturn(func(ctx context.Context, input *autoscaling.UpdateAutoScalingGroupInput, options ...request.Option) (*autoscaling.UpdateAutoScalingGroupOutput, error) {
+				m.UpdateAutoScalingGroup(context.TODO(), gomock.AssignableToTypeOf(&autoscaling.UpdateAutoScalingGroupInput{})).DoAndReturn(func(ctx context.Context, input *autoscaling.UpdateAutoScalingGroupInput, options ...request.Option) (*autoscaling.UpdateAutoScalingGroupOutput, error) {
 					// CAPA should set min/max, but not the externally managed "desired" number of instances
-					g.Expect(input.MinSize).To(BeComparableTo(ptr.To[int64](20)))
-					g.Expect(input.MaxSize).To(BeComparableTo(ptr.To[int64](50)))
+					g.Expect(input.MinSize).To(BeComparableTo(ptr.To[int32](20)))
+					g.Expect(input.MaxSize).To(BeComparableTo(ptr.To[int32](50)))
 					g.Expect(input.DesiredCapacity).To(BeNil())
 					return &autoscaling.UpdateAutoScalingGroupOutput{}, nil
 				})
@@ -804,7 +814,7 @@ func TestServiceUpdateASGWithSubnetFilters(t *testing.T) {
 				e.DescribeSubnetsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSubnetsInput{})).Return(&ec2.DescribeSubnetsOutput{
 					Subnets: []*ec2.Subnet{{SubnetId: aws.String("subnet-02")}},
 				}, nil)
-				m.UpdateAutoScalingGroupWithContext(context.TODO(), gomock.AssignableToTypeOf(&autoscaling.UpdateAutoScalingGroupInput{})).Return(&autoscaling.UpdateAutoScalingGroupOutput{}, nil)
+				m.UpdateAutoScalingGroup(context.TODO(), gomock.AssignableToTypeOf(&autoscaling.UpdateAutoScalingGroupInput{})).Return(&autoscaling.UpdateAutoScalingGroupOutput{}, nil)
 			},
 		},
 		{
@@ -837,7 +847,7 @@ func TestServiceUpdateASGWithSubnetFilters(t *testing.T) {
 				},
 			},
 			expect: func(e *mocks.MockEC2APIMockRecorder, m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.UpdateAutoScalingGroupWithContext(context.TODO(), gomock.AssignableToTypeOf(&autoscaling.UpdateAutoScalingGroupInput{})).Return(nil, awserrors.NewFailedDependency("dependency failure"))
+				m.UpdateAutoScalingGroup(context.TODO(), gomock.AssignableToTypeOf(&autoscaling.UpdateAutoScalingGroupInput{})).Return(nil, awserrors.NewFailedDependency("dependency failure"))
 			},
 		},
 	}
@@ -903,7 +913,7 @@ func TestServiceUpdateResourceTags(t *testing.T) {
 			},
 			wantErr: false,
 			expect: func(m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.CreateOrUpdateTagsWithContext(context.TODO(), gomock.Eq(&autoscaling.CreateOrUpdateTagsInput{
+				m.CreateOrUpdateTags(context.TODO(), gomock.Eq(&autoscaling.CreateOrUpdateTagsInput{
 					Tags: mapToTags(map[string]string{
 						"key1": "value1",
 					}, aws.String("mock-resource-id")),
@@ -921,7 +931,7 @@ func TestServiceUpdateResourceTags(t *testing.T) {
 			},
 			wantErr: true,
 			expect: func(m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.CreateOrUpdateTagsWithContext(context.TODO(), gomock.Eq(&autoscaling.CreateOrUpdateTagsInput{
+				m.CreateOrUpdateTags(context.TODO(), gomock.Eq(&autoscaling.CreateOrUpdateTagsInput{
 					Tags: mapToTags(map[string]string{
 						"key1": "value1",
 					}, aws.String("mock-resource-id")),
@@ -939,7 +949,7 @@ func TestServiceUpdateResourceTags(t *testing.T) {
 			},
 			wantErr: false,
 			expect: func(m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.DeleteTagsWithContext(context.TODO(), gomock.Eq(&autoscaling.DeleteTagsInput{
+				m.DeleteTags(context.TODO(), gomock.Eq(&autoscaling.DeleteTagsInput{
 					Tags: mapToTags(map[string]string{
 						"key1": "value1",
 					}, aws.String("mock-resource-id")),
@@ -957,7 +967,7 @@ func TestServiceUpdateResourceTags(t *testing.T) {
 			},
 			wantErr: true,
 			expect: func(m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.DeleteTagsWithContext(context.TODO(), gomock.Eq(&autoscaling.DeleteTagsInput{
+				m.DeleteTags(context.TODO(), gomock.Eq(&autoscaling.DeleteTagsInput{
 					Tags: mapToTags(map[string]string{
 						"key1": "value1",
 					}, aws.String("mock-resource-id")),
@@ -998,7 +1008,7 @@ func TestServiceDeleteASG(t *testing.T) {
 			name:    "Delete ASG successful",
 			wantErr: false,
 			expect: func(m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.DeleteAutoScalingGroupWithContext(context.TODO(), gomock.Eq(&autoscaling.DeleteAutoScalingGroupInput{
+				m.DeleteAutoScalingGroup(context.TODO(), gomock.Eq(&autoscaling.DeleteAutoScalingGroupInput{
 					AutoScalingGroupName: aws.String("asgName"),
 					ForceDelete:          aws.Bool(true),
 				})).
@@ -1009,7 +1019,7 @@ func TestServiceDeleteASG(t *testing.T) {
 			name:    "Delete ASG should fail when ASG is not found",
 			wantErr: true,
 			expect: func(m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.DeleteAutoScalingGroupWithContext(context.TODO(), gomock.Eq(&autoscaling.DeleteAutoScalingGroupInput{
+				m.DeleteAutoScalingGroup(context.TODO(), gomock.Eq(&autoscaling.DeleteAutoScalingGroupInput{
 					AutoScalingGroupName: aws.String("asgName"),
 					ForceDelete:          aws.Bool(true),
 				})).
@@ -1049,37 +1059,41 @@ func TestServiceDeleteASGAndWait(t *testing.T) {
 			name:    "Delete ASG with wait passed",
 			wantErr: false,
 			expect: func(m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.DeleteAutoScalingGroupWithContext(context.TODO(), gomock.Eq(&autoscaling.DeleteAutoScalingGroupInput{
+				m.DeleteAutoScalingGroup(gomock.Any(), gomock.Eq(&autoscaling.DeleteAutoScalingGroupInput{
 					AutoScalingGroupName: aws.String("asgName"),
 					ForceDelete:          aws.Bool(true),
 				})).
-					Return(nil, nil)
-				m.WaitUntilGroupNotExistsWithContext(context.TODO(), gomock.Eq(&autoscaling.DescribeAutoScalingGroupsInput{
-					AutoScalingGroupNames: aws.StringSlice([]string{"asgName"}),
-				})).
-					Return(nil)
+					Return(&autoscaling.DeleteAutoScalingGroupOutput{}, nil)
+				m.DescribeAutoScalingGroups(gomock.Any(), gomock.Eq(&autoscaling.DescribeAutoScalingGroupsInput{
+					AutoScalingGroupNames: []string{"asgName"},
+				}),
+					gomock.Any()).
+					Return(&autoscaling.DescribeAutoScalingGroupsOutput{
+						AutoScalingGroups: []autoscalingtypes.AutoScalingGroup{},
+					}, nil)
 			},
 		},
 		{
 			name:    "should return error if delete ASG failed while waiting",
 			wantErr: true,
 			expect: func(m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.DeleteAutoScalingGroupWithContext(context.TODO(), gomock.Eq(&autoscaling.DeleteAutoScalingGroupInput{
+				m.DeleteAutoScalingGroup(gomock.Any(), gomock.Eq(&autoscaling.DeleteAutoScalingGroupInput{
 					AutoScalingGroupName: aws.String("asgName"),
 					ForceDelete:          aws.Bool(true),
 				})).
-					Return(nil, nil)
-				m.WaitUntilGroupNotExistsWithContext(context.TODO(), gomock.Eq(&autoscaling.DescribeAutoScalingGroupsInput{
-					AutoScalingGroupNames: aws.StringSlice([]string{"asgName"}),
-				})).
-					Return(awserrors.NewFailedDependency("dependency error"))
+					Return(&autoscaling.DeleteAutoScalingGroupOutput{}, nil)
+				m.DescribeAutoScalingGroups(gomock.Any(), gomock.Eq(&autoscaling.DescribeAutoScalingGroupsInput{
+					AutoScalingGroupNames: []string{"asgName"},
+				}),
+					gomock.Any()).
+					Return(nil, awserrors.NewFailedDependency("dependency error"))
 			},
 		},
 		{
 			name:    "should return error if delete ASG failed during ASG deletion",
 			wantErr: true,
 			expect: func(m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.DeleteAutoScalingGroupWithContext(context.TODO(), gomock.Eq(&autoscaling.DeleteAutoScalingGroupInput{
+				m.DeleteAutoScalingGroup(context.TODO(), gomock.Eq(&autoscaling.DeleteAutoScalingGroupInput{
 					AutoScalingGroupName: aws.String("asgName"),
 					ForceDelete:          aws.Bool(true),
 				})).
@@ -1121,7 +1135,7 @@ func TestServiceCanStartASGInstanceRefresh(t *testing.T) {
 			wantErr:  true,
 			canStart: false,
 			expect: func(m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.DescribeInstanceRefreshesWithContext(context.TODO(), gomock.Eq(&autoscaling.DescribeInstanceRefreshesInput{
+				m.DescribeInstanceRefreshes(context.TODO(), gomock.Eq(&autoscaling.DescribeInstanceRefreshesInput{
 					AutoScalingGroupName: aws.String("machinePoolName"),
 				})).
 					Return(nil, awserrors.NewConflict("some error"))
@@ -1132,7 +1146,7 @@ func TestServiceCanStartASGInstanceRefresh(t *testing.T) {
 			wantErr:  false,
 			canStart: true,
 			expect: func(m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.DescribeInstanceRefreshesWithContext(context.TODO(), gomock.Eq(&autoscaling.DescribeInstanceRefreshesInput{
+				m.DescribeInstanceRefreshes(context.TODO(), gomock.Eq(&autoscaling.DescribeInstanceRefreshesInput{
 					AutoScalingGroupName: aws.String("machinePoolName"),
 				})).
 					Return(&autoscaling.DescribeInstanceRefreshesOutput{}, nil)
@@ -1143,13 +1157,13 @@ func TestServiceCanStartASGInstanceRefresh(t *testing.T) {
 			wantErr:  false,
 			canStart: false,
 			expect: func(m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.DescribeInstanceRefreshesWithContext(context.TODO(), gomock.Eq(&autoscaling.DescribeInstanceRefreshesInput{
+				m.DescribeInstanceRefreshes(context.TODO(), gomock.Eq(&autoscaling.DescribeInstanceRefreshesInput{
 					AutoScalingGroupName: aws.String("machinePoolName"),
 				})).
 					Return(&autoscaling.DescribeInstanceRefreshesOutput{
-						InstanceRefreshes: []*autoscaling.InstanceRefresh{
+						InstanceRefreshes: []autoscalingtypes.InstanceRefresh{
 							{
-								Status: aws.String(autoscaling.InstanceRefreshStatusInProgress),
+								Status: autoscalingtypes.InstanceRefreshStatusInProgress,
 							},
 						},
 					}, nil)
@@ -1197,13 +1211,13 @@ func TestServiceStartASGInstanceRefresh(t *testing.T) {
 			name:    "should return error if start instance refresh failed",
 			wantErr: true,
 			expect: func(m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.StartInstanceRefreshWithContext(context.TODO(), gomock.Eq(&autoscaling.StartInstanceRefreshInput{
+				m.StartInstanceRefresh(context.TODO(), gomock.Eq(&autoscaling.StartInstanceRefreshInput{
 					AutoScalingGroupName: aws.String("mpn"),
-					Strategy:             aws.String("Rolling"),
-					Preferences: &autoscaling.RefreshPreferences{
-						InstanceWarmup:       aws.Int64(100),
-						MinHealthyPercentage: aws.Int64(80),
-						MaxHealthyPercentage: aws.Int64(100),
+					Strategy:             autoscalingtypes.RefreshStrategyRolling,
+					Preferences: &autoscalingtypes.RefreshPreferences{
+						InstanceWarmup:       aws.Int32(100),
+						MinHealthyPercentage: aws.Int32(80),
+						MaxHealthyPercentage: aws.Int32(100),
 					},
 				})).
 					Return(nil, awserrors.NewNotFound("not found"))
@@ -1213,13 +1227,13 @@ func TestServiceStartASGInstanceRefresh(t *testing.T) {
 			name:    "should return nil if start instance refresh is success",
 			wantErr: false,
 			expect: func(m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				m.StartInstanceRefreshWithContext(context.TODO(), gomock.Eq(&autoscaling.StartInstanceRefreshInput{
+				m.StartInstanceRefresh(context.TODO(), gomock.Eq(&autoscaling.StartInstanceRefreshInput{
 					AutoScalingGroupName: aws.String("mpn"),
-					Strategy:             aws.String("Rolling"),
-					Preferences: &autoscaling.RefreshPreferences{
-						InstanceWarmup:       aws.Int64(100),
-						MinHealthyPercentage: aws.Int64(80),
-						MaxHealthyPercentage: aws.Int64(100),
+					Strategy:             autoscalingtypes.RefreshStrategyRolling,
+					Preferences: &autoscalingtypes.RefreshPreferences{
+						InstanceWarmup:       aws.Int32(100),
+						MinHealthyPercentage: aws.Int32(80),
+						MaxHealthyPercentage: aws.Int32(100),
 					},
 				})).
 					Return(&autoscaling.StartInstanceRefreshOutput{}, nil)
diff --git a/pkg/cloud/services/ec2/launchtemplate_test.go b/pkg/cloud/services/ec2/launchtemplate_test.go
index a15243fe1..b04907b7c 100644
--- a/pkg/cloud/services/ec2/launchtemplate_test.go
+++ b/pkg/cloud/services/ec2/launchtemplate_test.go
@@ -353,6 +353,139 @@ func TestServiceSDKToLaunchTemplate(t *testing.T) {
 			wantHash:          testUserDataHash,
 			wantDataSecretKey: nil, // respective tag is not given
 		},
+		{
+			name: "spot market options",
+			input: &ec2.LaunchTemplateVersion{
+				LaunchTemplateId:   aws.String("lt-12345"),
+				LaunchTemplateName: aws.String("foo"),
+				LaunchTemplateData: &ec2.ResponseLaunchTemplateData{
+					ImageId: aws.String("foo-image"),
+					IamInstanceProfile: &ec2.LaunchTemplateIamInstanceProfileSpecification{
+						Arn: aws.String("instance-profile/foo-profile"),
+					},
+					KeyName: aws.String("foo-keyname"),
+					InstanceMarketOptions: &ec2.LaunchTemplateInstanceMarketOptions{
+						MarketType: aws.String(ec2.MarketTypeSpot),
+						SpotOptions: &ec2.LaunchTemplateSpotMarketOptions{
+							MaxPrice: aws.String("0.05"),
+						},
+					},
+					UserData: aws.String(base64.StdEncoding.EncodeToString([]byte(testUserData))),
+				},
+				VersionNumber: aws.Int64(1),
+			},
+			wantLT: &expinfrav1.AWSLaunchTemplate{
+				Name: "foo",
+				AMI: infrav1.AMIReference{
+					ID: aws.String("foo-image"),
+				},
+				IamInstanceProfile: "foo-profile",
+				SSHKeyName:         aws.String("foo-keyname"),
+				VersionNumber:      aws.Int64(1),
+				SpotMarketOptions: &infrav1.SpotMarketOptions{
+					MaxPrice: aws.String("0.05"),
+				},
+			},
+			wantHash:          testUserDataHash,
+			wantDataSecretKey: nil,
+		},
+		{
+			name: "spot market options with no max price",
+			input: &ec2.LaunchTemplateVersion{
+				LaunchTemplateId:   aws.String("lt-12345"),
+				LaunchTemplateName: aws.String("foo"),
+				LaunchTemplateData: &ec2.ResponseLaunchTemplateData{
+					ImageId: aws.String("foo-image"),
+					IamInstanceProfile: &ec2.LaunchTemplateIamInstanceProfileSpecification{
+						Arn: aws.String("instance-profile/foo-profile"),
+					},
+					KeyName: aws.String("foo-keyname"),
+					InstanceMarketOptions: &ec2.LaunchTemplateInstanceMarketOptions{
+						MarketType:  aws.String(ec2.MarketTypeSpot),
+						SpotOptions: &ec2.LaunchTemplateSpotMarketOptions{},
+					},
+					UserData: aws.String(base64.StdEncoding.EncodeToString([]byte(testUserData))),
+				},
+				VersionNumber: aws.Int64(1),
+			},
+			wantLT: &expinfrav1.AWSLaunchTemplate{
+				Name: "foo",
+				AMI: infrav1.AMIReference{
+					ID: aws.String("foo-image"),
+				},
+				IamInstanceProfile: "foo-profile",
+				SSHKeyName:         aws.String("foo-keyname"),
+				VersionNumber:      aws.Int64(1),
+				SpotMarketOptions:  &infrav1.SpotMarketOptions{},
+			},
+			wantHash:          testUserDataHash,
+			wantDataSecretKey: nil,
+		},
+		{
+			name: "spot market options without SpotOptions",
+			input: &ec2.LaunchTemplateVersion{
+				LaunchTemplateId:   aws.String("lt-12345"),
+				LaunchTemplateName: aws.String("foo"),
+				LaunchTemplateData: &ec2.ResponseLaunchTemplateData{
+					ImageId: aws.String("foo-image"),
+					IamInstanceProfile: &ec2.LaunchTemplateIamInstanceProfileSpecification{
+						Arn: aws.String("instance-profile/foo-profile"),
+					},
+					KeyName: aws.String("foo-keyname"),
+					InstanceMarketOptions: &ec2.LaunchTemplateInstanceMarketOptions{
+						MarketType: aws.String(ec2.MarketTypeSpot),
+					},
+					UserData: aws.String(base64.StdEncoding.EncodeToString([]byte(testUserData))),
+				},
+				VersionNumber: aws.Int64(1),
+			},
+			wantLT: &expinfrav1.AWSLaunchTemplate{
+				Name: "foo",
+				AMI: infrav1.AMIReference{
+					ID: aws.String("foo-image"),
+				},
+				IamInstanceProfile: "foo-profile",
+				SSHKeyName:         aws.String("foo-keyname"),
+				VersionNumber:      aws.Int64(1),
+				SpotMarketOptions:  &infrav1.SpotMarketOptions{},
+			},
+			wantHash:          testUserDataHash,
+			wantDataSecretKey: nil,
+		},
+		{
+			name: "non-spot market type",
+			input: &ec2.LaunchTemplateVersion{
+				LaunchTemplateId:   aws.String("lt-12345"),
+				LaunchTemplateName: aws.String("foo"),
+				LaunchTemplateData: &ec2.ResponseLaunchTemplateData{
+					ImageId: aws.String("foo-image"),
+					IamInstanceProfile: &ec2.LaunchTemplateIamInstanceProfileSpecification{
+						Arn: aws.String("instance-profile/foo-profile"),
+					},
+					KeyName: aws.String("foo-keyname"),
+					InstanceMarketOptions: &ec2.LaunchTemplateInstanceMarketOptions{
+						MarketType: aws.String("different-market-type"),
+						SpotOptions: &ec2.LaunchTemplateSpotMarketOptions{
+							MaxPrice: aws.String("0.05"),
+						},
+					},
+					UserData: aws.String(base64.StdEncoding.EncodeToString([]byte(testUserData))),
+				},
+				VersionNumber: aws.Int64(1),
+			},
+			wantLT: &expinfrav1.AWSLaunchTemplate{
+				Name: "foo",
+				AMI: infrav1.AMIReference{
+					ID: aws.String("foo-image"),
+				},
+				IamInstanceProfile: "foo-profile",
+				SSHKeyName:         aws.String("foo-keyname"),
+				VersionNumber:      aws.Int64(1),
+				SpotMarketOptions:  nil, // Should be nil since market type is not "spot"
+			},
+			wantHash:          testUserDataHash,
+			wantDataSecretKey: nil,
+		},
 		{
 			name: "tag of bootstrap secret",
 			input: &ec2.LaunchTemplateVersion{
@@ -440,6 +573,20 @@ func TestServiceLaunchTemplateNeedsUpdate(t *testing.T) {
 		want     bool
 		wantErr  bool
 	}{
+		{
+			name: "only core security groups, order shouldn't matter",
+			incoming: &expinfrav1.AWSLaunchTemplate{
+				AdditionalSecurityGroups: []infrav1.AWSResourceReference{},
+			},
+			existing: &expinfrav1.AWSLaunchTemplate{
+				AdditionalSecurityGroups: []infrav1.AWSResourceReference{
+					{ID: aws.String("sg-222")},
+					{ID: aws.String("sg-111")},
+				},
+			},
+			want:    false,
+			wantErr: false,
+		},
 		{
 			name: "the same security groups",
 			incoming: &expinfrav1.AWSLaunchTemplate{
@@ -497,6 +644,10 @@ func TestServiceLaunchTemplateNeedsUpdate(t *testing.T) {
 				IamInstanceProfile: DefaultAmiNameFormat,
 			},
 			existing: &expinfrav1.AWSLaunchTemplate{
+				AdditionalSecurityGroups: []infrav1.AWSResourceReference{
+					{ID: aws.String("sg-111")},
+					{ID: aws.String("sg-222")},
+				},
 				IamInstanceProfile: "some-other-profile",
 			},
 			want: true,
@@ -507,6 +658,10 @@ func TestServiceLaunchTemplateNeedsUpdate(t *testing.T) {
 				InstanceType: "t3.micro",
 			},
 			existing: &expinfrav1.AWSLaunchTemplate{
+				AdditionalSecurityGroups: []infrav1.AWSResourceReference{
+					{ID: aws.String("sg-111")},
+					{ID: aws.String("sg-222")},
+				},
 				InstanceType: "t3.large",
 			},
 			want: true,
@@ -540,9 +695,14 @@ func TestServiceLaunchTemplateNeedsUpdate(t *testing.T) {
 					HTTPTokens:              infrav1.HTTPTokensStateRequired,
 				},
 			},
-			existing: &expinfrav1.AWSLaunchTemplate{},
-			want:     true,
-			wantErr:  false,
+			existing: &expinfrav1.AWSLaunchTemplate{
+				AdditionalSecurityGroups: []infrav1.AWSResourceReference{
+					{ID: aws.String("sg-111")},
+					{ID: aws.String("sg-222")},
+				},
+			},
+			want:    true,
+			wantErr: false,
 		},
 		{
 			name:     "new launch template instance metadata options, removing IMDSv2 requirement",
@@ -556,6 +716,59 @@ func TestServiceLaunchTemplateNeedsUpdate(t *testing.T) {
 			want:    true,
 			wantErr: false,
 		},
+		{
+			name: "Should return true if incoming SpotMarketOptions is different from existing SpotMarketOptions",
+			incoming: &expinfrav1.AWSLaunchTemplate{
+				SpotMarketOptions: &infrav1.SpotMarketOptions{
+					MaxPrice: aws.String("0.10"),
+				},
+			},
+			existing: &expinfrav1.AWSLaunchTemplate{
+				AdditionalSecurityGroups: []infrav1.AWSResourceReference{
+					{ID: aws.String("sg-111")},
+					{ID: aws.String("sg-222")},
+				},
+				SpotMarketOptions: &infrav1.SpotMarketOptions{
+					MaxPrice: aws.String("0.05"),
+				},
+			},
+			want:    true,
+			wantErr: false,
+		},
+		{
+			name: "Should return true if incoming adds SpotMarketOptions and existing has none",
+			incoming: &expinfrav1.AWSLaunchTemplate{
+				SpotMarketOptions: &infrav1.SpotMarketOptions{
+					MaxPrice: aws.String("0.10"),
+				},
+			},
+			existing: &expinfrav1.AWSLaunchTemplate{
+				AdditionalSecurityGroups: []infrav1.AWSResourceReference{
+					{ID: aws.String("sg-111")},
+					{ID: aws.String("sg-222")},
+				},
+				SpotMarketOptions: nil,
+			},
+			want:    true,
+			wantErr: false,
+		},
+		{
+			name: "Should return true if incoming removes SpotMarketOptions and existing has some",
+			incoming: &expinfrav1.AWSLaunchTemplate{
+				SpotMarketOptions: nil,
+			},
+			existing: &expinfrav1.AWSLaunchTemplate{
+				AdditionalSecurityGroups: []infrav1.AWSResourceReference{
+					{ID: aws.String("sg-111")},
+					{ID: aws.String("sg-222")},
+				},
+				SpotMarketOptions: &infrav1.SpotMarketOptions{
+					MaxPrice: aws.String("0.05"),
+				},
+			},
+			want:    true,
+			wantErr: false,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
diff --git a/pkg/eks/addons/types_test.go b/pkg/eks/addons/types_test.go
index dd363254c..a21d68538 100644
--- a/pkg/eks/addons/types_test.go
+++ b/pkg/eks/addons/types_test.go
@@ -54,6 +54,32 @@ func TestAddOnEqual(t *testing.T) {
 			},
 			result: gomega.BeTrueBecause("addon values are equal (except status)"),
 		},
+		{
+			orig: &EKSAddon{
+				Version:               ptr("a"),
+				ServiceAccountRoleARN: ptr("b"),
+				Configuration:         nil,
+			},
+			other: &EKSAddon{
+				Version:               ptr("a"),
+				ServiceAccountRoleARN: ptr("b"),
+				Configuration:         nil,
+			},
+			result: gomega.BeTrueBecause("addon values are equal with optional nil configuration"),
+		},
+		{
+			orig: &EKSAddon{
+				Version:               ptr("a"),
+				ServiceAccountRoleARN: ptr("b"),
+				ResolveConflict:       ptr("OVERWRITE"),
+			},
+			other: &EKSAddon{
+				Version:               ptr("a"),
+				ServiceAccountRoleARN: ptr("b"),
+				ResolveConflict:       nil,
+			},
+			result: gomega.BeTrueBecause("addon values are equal with expected diff on resolve conflict"),
+		},
 		{
 			orig: &EKSAddon{
 				Version:               ptr("a"),
diff --git a/test/e2e/shared/aws.go b/test/e2e/shared/aws.go
index e5f9f9a0a..94df5ebd7 100644
--- a/test/e2e/shared/aws.go
+++ b/test/e2e/shared/aws.go
@@ -32,6 +32,10 @@ import (
 	"strings"
 	"time"
 
+	awsv2 "github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/config"
+	iam "github.com/aws/aws-sdk-go-v2/service/iam"
+	iamtypes "github.com/aws/aws-sdk-go-v2/service/iam/types"
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/client"
 	awscreds "github.com/aws/aws-sdk-go/aws/credentials"
@@ -44,7 +48,6 @@ import (
 	"github.com/aws/aws-sdk-go/service/efs"
 	"github.com/aws/aws-sdk-go/service/eks"
 	"github.com/aws/aws-sdk-go/service/elb"
-	"github.com/aws/aws-sdk-go/service/iam"
 	"github.com/aws/aws-sdk-go/service/servicequotas"
 	"github.com/aws/aws-sdk-go/service/sts"
 	cfn_iam "github.com/awslabs/goformation/v4/cloudformation/iam"
@@ -363,6 +366,25 @@ func (i *AWSInfrastructure) DeleteInfrastructure() {
 	}
 }
 
+func NewAWSConfig(ctx context.Context) awsv2.Config {
+	By("Getting an AWS config using SDK v2 - from environment")
+
+	region, err := credentials.ResolveRegion("")
+	Expect(err).NotTo(HaveOccurred())
+
+	cfg, err := config.LoadDefaultConfig(ctx,
+		config.WithRegion(region),
+		config.WithClientLogMode(awsv2.LogSigning),
+		config.WithSharedConfigProfile(""),
+	)
+	Expect(err).NotTo(HaveOccurred())
+
+	_, err = cfg.Credentials.Retrieve(ctx)
+	Expect(err).NotTo(HaveOccurred())
+
+	return cfg
+}
+
 func NewAWSSession() client.ConfigProvider {
 	By("Getting an AWS IAM session - from environment")
 	region, err := credentials.ResolveRegion("")
@@ -378,8 +400,10 @@ func NewAWSSession() client.ConfigProvider {
 	return sess
 }
 
-func NewAWSSessionRepoWithKey(accessKey *iam.AccessKey) client.ConfigProvider {
+func NewAWSSessionRepoWithKey(accessKey *iamtypes.AccessKey) client.ConfigProvider {
 	By("Getting an AWS IAM session - from access key")
+	Expect(accessKey.AccessKeyId).NotTo(BeNil())
+	Expect(accessKey.SecretAccessKey).NotTo(BeNil())
 	config := aws.NewConfig().WithCredentialsChainVerboseErrors(true).WithRegion("us-east-1")
 	config.Credentials = awscreds.NewStaticCredentials(*accessKey.AccessKeyId, *accessKey.SecretAccessKey, "")
 
@@ -392,8 +416,10 @@ func NewAWSSessionRepoWithKey(accessKey *iam.AccessKey) client.ConfigProvider {
 	return sess
 }
 
-func NewAWSSessionWithKey(accessKey *iam.AccessKey) client.ConfigProvider {
+func NewAWSSessionWithKey(accessKey *iamtypes.AccessKey) client.ConfigProvider {
 	By("Getting an AWS IAM session - from access key")
+	Expect(accessKey.AccessKeyId).NotTo(BeNil())
+	Expect(accessKey.SecretAccessKey).NotTo(BeNil())
 	region, err := credentials.ResolveRegion("")
 	Expect(err).NotTo(HaveOccurred())
 	config := aws.NewConfig().WithCredentialsChainVerboseErrors(true).WithRegion(region)
@@ -409,7 +435,7 @@ func NewAWSSessionWithKey(accessKey *iam.AccessKey) client.ConfigProvider {
 }
 
 // createCloudFormationStack ensures the cloudformation stack is up to date.
-func createCloudFormationStack(prov client.ConfigProvider, t *cfn_bootstrap.Template, tags map[string]string) error {
+func createCloudFormationStack(ctx context.Context, cfg awsv2.Config, prov client.ConfigProvider, t *cfn_bootstrap.Template, tags map[string]string) error {
 	By(fmt.Sprintf("Creating AWS CloudFormation stack for AWS IAM resources: stack-name=%s", t.Spec.StackName))
 	cfnClient := cfn.New(prov)
 	// CloudFormation stack will clean up on a failure, we don't need an Eventually here.
@@ -421,8 +447,8 @@ func createCloudFormationStack(prov client.ConfigProvider, t *cfn_bootstrap.Temp
 
 		// always clean up on a failure because we could leak these resources and the next cloud formation create would
 		// fail with the same problem.
-		deleteMultitenancyRoles(prov)
-		deleteResourcesInCloudFormation(prov, t)
+		deleteMultitenancyRoles(ctx, cfg)
+		deleteResourcesInCloudFormation(ctx, cfg, t)
 		return err
 	}
 
@@ -471,8 +497,8 @@ func SetMultitenancyEnvVars(prov client.ConfigProvider) error {
 }
 
 // Delete resources that already exists.
-func deleteResourcesInCloudFormation(prov client.ConfigProvider, t *cfn_bootstrap.Template) {
-	iamSvc := iam.New(prov)
+func deleteResourcesInCloudFormation(ctx context.Context, cfg awsv2.Config, t *cfn_bootstrap.Template) {
+	iamSvc := iam.NewFromConfig(cfg)
 	temp := *renderCustomCloudFormation(t)
 	var (
 		iamUsers         []*cfn_iam.User
@@ -507,72 +533,76 @@ func deleteResourcesInCloudFormation(prov client.ConfigProvider, t *cfn_bootstra
 		By(fmt.Sprintf("deleting the following user: %q", user.UserName))
 		repeat := false
 		Eventually(func(gomega Gomega) bool {
-			err := DeleteUser(prov, user.UserName)
+			err := DeleteUser(ctx, cfg, user.UserName)
 			if err != nil && !repeat {
 				By(fmt.Sprintf("failed to delete user '%q'; reason: %+v", user.UserName, err))
 				repeat = true
 			}
-			code, ok := awserrors.Code(err)
-			return err == nil || (ok && code == iam.ErrCodeNoSuchEntityException)
+			var noSuchEntityErr *iamtypes.NoSuchEntityException
+			return err == nil || errors.As(err, &noSuchEntityErr)
 		}, 5*time.Minute, 5*time.Second).Should(BeTrue(), fmt.Sprintf("Eventually failed deleting the user: %q", user.UserName))
 	}
 	for _, role := range iamRoles {
 		By(fmt.Sprintf("deleting the following role: %s", role.RoleName))
 		repeat := false
 		Eventually(func(gomega Gomega) bool {
-			err := DeleteRole(prov, role.RoleName)
+			err := DeleteRole(ctx, cfg, role.RoleName)
 			if err != nil && !repeat {
 				By(fmt.Sprintf("failed to delete role '%s'; reason: %+v", role.RoleName, err))
 				repeat = true
 			}
-			code, ok := awserrors.Code(err)
-			return err == nil || (ok && code == iam.ErrCodeNoSuchEntityException)
+			var noSuchEntityErr *iamtypes.NoSuchEntityException
+			return err == nil || errors.As(err, &noSuchEntityErr)
 		}, 5*time.Minute, 5*time.Second).Should(BeTrue(), fmt.Sprintf("Eventually failed deleting the following role: %q", role.RoleName))
 	}
 	for _, profile := range instanceProfiles {
 		By(fmt.Sprintf("cleanup for profile with name '%s'", profile.InstanceProfileName))
 		repeat := false
 		Eventually(func(gomega Gomega) bool {
-			_, err := iamSvc.DeleteInstanceProfile(&iam.DeleteInstanceProfileInput{InstanceProfileName: aws.String(profile.InstanceProfileName)})
+			_, err := iamSvc.DeleteInstanceProfile(ctx, &iam.DeleteInstanceProfileInput{
+				InstanceProfileName: aws.String(profile.InstanceProfileName),
+			})
 			if err != nil && !repeat {
 				By(fmt.Sprintf("failed to delete role '%s'; reason: %+v", profile.InstanceProfileName, err))
 				repeat = true
 			}
-			code, ok := awserrors.Code(err)
-			return err == nil || (ok && code == iam.ErrCodeNoSuchEntityException)
+			var noSuchEntityErr *iamtypes.NoSuchEntityException
+			return err == nil || errors.As(err, &noSuchEntityErr)
 		}, 5*time.Minute, 5*time.Second).Should(BeTrue(), fmt.Sprintf("Eventually failed cleaning up profile with name %q", profile.InstanceProfileName))
 	}
 	for _, group := range groups {
 		repeat := false
 		Eventually(func(gomega Gomega) bool {
-			_, err := iamSvc.DeleteGroup(&iam.DeleteGroupInput{GroupName: aws.String(group.GroupName)})
+			_, err := iamSvc.DeleteGroup(ctx, &iam.DeleteGroupInput{
+				GroupName: aws.String(group.GroupName),
+			})
 			if err != nil && !repeat {
 				By(fmt.Sprintf("failed to delete group '%s'; reason: %+v", group.GroupName, err))
 				repeat = true
 			}
-			code, ok := awserrors.Code(err)
-			return err == nil || (ok && code == iam.ErrCodeNoSuchEntityException)
+			var noSuchEntityErr *iamtypes.NoSuchEntityException
+			return err == nil || errors.As(err, &noSuchEntityErr)
 		}, 5*time.Minute, 5*time.Second).Should(BeTrue(), fmt.Sprintf("Eventually failed deleting group %q", group.GroupName))
 	}
 	for _, policy := range policies {
-		policies, err := iamSvc.ListPolicies(&iam.ListPoliciesInput{})
+		listPoliciesOutput, err := iamSvc.ListPolicies(ctx, &iam.ListPoliciesInput{})
 		Expect(err).NotTo(HaveOccurred())
-		if len(policies.Policies) > 0 {
-			for _, p := range policies.Policies {
-				if aws.StringValue(p.PolicyName) == policy.ManagedPolicyName {
-					By(fmt.Sprintf("cleanup for policy '%s'", p.String()))
+		if len(listPoliciesOutput.Policies) > 0 {
+			for _, p := range listPoliciesOutput.Policies {
+				if awsv2.ToString(p.PolicyName) == policy.ManagedPolicyName {
+					By(fmt.Sprintf("cleanup for policy '%s'", awsv2.ToString(p.PolicyName)))
 					repeat := false
 					Eventually(func(gomega Gomega) bool {
-						response, err := iamSvc.DeletePolicy(&iam.DeletePolicyInput{
+						_, err := iamSvc.DeletePolicy(ctx, &iam.DeletePolicyInput{
 							PolicyArn: p.Arn,
 						})
 						if err != nil && !repeat {
-							By(fmt.Sprintf("failed to delete policy '%s'; reason: %+v, response: %s", policy.Description, err, response.String()))
+							By(fmt.Sprintf("failed to delete policy '%s'; reason: %+v", policy.Description, err))
 							repeat = true
 						}
-						code, ok := awserrors.Code(err)
-						return err == nil || (ok && code == iam.ErrCodeNoSuchEntityException)
-					}, 5*time.Minute, 5*time.Second).Should(BeTrue(), fmt.Sprintf("Eventually failed to delete policy %q", p.String()))
+						var noSuchEntityErr *iamtypes.NoSuchEntityException
+						return err == nil || errors.As(err, &noSuchEntityErr)
+					}, 5*time.Minute, 5*time.Second).Should(BeTrue(), fmt.Sprintf("Eventually failed to delete policy %q", awsv2.ToString(p.PolicyName)))
 					// TODO: why is there a break here? Don't we want to clean up everything?
 					break
 				}
@@ -582,33 +612,35 @@ func deleteResourcesInCloudFormation(prov client.ConfigProvider, t *cfn_bootstra
 }
 
 // TODO: remove once test infra accounts are fixed.
-func deleteMultitenancyRoles(prov client.ConfigProvider) {
-	if err := DeleteRole(prov, "multi-tenancy-role"); err != nil {
+func deleteMultitenancyRoles(ctx context.Context, cfg awsv2.Config) {
+	if err := DeleteRole(ctx, cfg, "multi-tenancy-role"); err != nil {
 		By(fmt.Sprintf("failed to delete role multi-tenancy-role %s", err))
 	}
-	if err := DeleteRole(prov, "multi-tenancy-nested-role"); err != nil {
+	if err := DeleteRole(ctx, cfg, "multi-tenancy-nested-role"); err != nil {
 		By(fmt.Sprintf("failed to delete role multi-tenancy-nested-role %s", err))
 	}
 }
 
 // detachAllPoliciesForRole detaches all policies for role.
-func detachAllPoliciesForRole(prov client.ConfigProvider, name string) error {
-	iamSvc := iam.New(prov)
+func detachAllPoliciesForRole(ctx context.Context, cfg awsv2.Config, name string) error {
+	iamSvc := iam.NewFromConfig(cfg)
 
 	input := &iam.ListAttachedRolePoliciesInput{
-		RoleName: &name,
+		RoleName: aws.String(name),
 	}
-	policies, err := iamSvc.ListAttachedRolePolicies(input)
+
+	policies, err := iamSvc.ListAttachedRolePolicies(ctx, input)
 	if err != nil {
 		return errors.New("error fetching policies for role")
 	}
+
 	for _, p := range policies.AttachedPolicies {
 		input := &iam.DetachRolePolicyInput{
 			RoleName:  aws.String(name),
 			PolicyArn: p.PolicyArn,
 		}
 
-		_, err := iamSvc.DetachRolePolicy(input)
+		_, err := iamSvc.DetachRolePolicy(ctx, input)
 		if err != nil {
 			return errors.New("failed detaching policy from a role")
 		}
@@ -617,16 +649,16 @@ func detachAllPoliciesForRole(prov client.ConfigProvider, name string) error {
 }
 
 // DeleteUser deletes an IAM user in a best effort manner.
-func DeleteUser(prov client.ConfigProvider, name string) error {
-	iamSvc := iam.New(prov)
+func DeleteUser(ctx context.Context, cfg awsv2.Config, name string) error {
+	iamSvc := iam.NewFromConfig(cfg)
 
-	// if role does not exist, return.
-	_, err := iamSvc.GetUser(&iam.GetUserInput{UserName: aws.String(name)})
+	// if user does not exist, return.
+	_, err := iamSvc.GetUser(ctx, &iam.GetUserInput{UserName: aws.String(name)})
 	if err != nil {
 		return err
 	}
 
-	_, err = iamSvc.DeleteUser(&iam.DeleteUserInput{UserName: aws.String(name)})
+	_, err = iamSvc.DeleteUser(ctx, &iam.DeleteUserInput{UserName: aws.String(name)})
 	if err != nil {
 		return err
 	}
@@ -635,20 +667,20 @@ func DeleteUser(prov client.ConfigProvider, name string) error {
 }
 
 // DeleteRole deletes roles in a best effort manner.
-func DeleteRole(prov client.ConfigProvider, name string) error {
-	iamSvc := iam.New(prov)
+func DeleteRole(ctx context.Context, cfg awsv2.Config, name string) error {
+	iamSvc := iam.NewFromConfig(cfg)
 
 	// if role does not exist, return.
-	_, err := iamSvc.GetRole(&iam.GetRoleInput{RoleName: aws.String(name)})
+	_, err := iamSvc.GetRole(ctx, &iam.GetRoleInput{RoleName: aws.String(name)})
 	if err != nil {
 		return err
 	}
 
-	if err := detachAllPoliciesForRole(prov, name); err != nil {
+	if err := detachAllPoliciesForRole(ctx, cfg, name); err != nil {
 		return err
 	}
 
-	_, err = iamSvc.DeleteRole(&iam.DeleteRoleInput{RoleName: aws.String(name)})
+	_, err = iamSvc.DeleteRole(ctx, &iam.DeleteRoleInput{RoleName: aws.String(name)})
 	if err != nil {
 		return err
 	}
@@ -656,16 +688,17 @@ func DeleteRole(prov client.ConfigProvider, name string) error {
 	return nil
 }
 
-func GetPolicyArn(prov client.ConfigProvider, name string) string {
-	iamSvc := iam.New(prov)
-	policyList, err := iamSvc.ListPolicies(&iam.ListPoliciesInput{
-		Scope: aws.String(iam.PolicyScopeTypeLocal),
+func GetPolicyArn(ctx context.Context, cfg awsv2.Config, name string) string {
+	iamSvc := iam.NewFromConfig(cfg)
+
+	policyList, err := iamSvc.ListPolicies(ctx, &iam.ListPoliciesInput{
+		Scope: iamtypes.PolicyScopeTypeLocal,
 	})
 	Expect(err).NotTo(HaveOccurred())
 
 	for _, policy := range policyList.Policies {
-		if aws.StringValue(policy.PolicyName) == name {
-			return aws.StringValue(policy.Arn)
+		if awsv2.ToString(policy.PolicyName) == name {
+			return awsv2.ToString(policy.Arn)
 		}
 	}
 	return ""
@@ -787,21 +820,25 @@ func ensureTestImageUploaded(e2eCtx *E2EContext) error {
 
 // ensureNoServiceLinkedRoles removes an auto-created IAM role, and tests
 // the controller's IAM permissions to use ELB and Spot instances successfully.
-func ensureNoServiceLinkedRoles(prov client.ConfigProvider) {
+func ensureNoServiceLinkedRoles(ctx context.Context, cfg awsv2.Config) {
+	iamSvc := iam.NewFromConfig(cfg)
+
 	By("Deleting AWS IAM Service Linked Role: role-name=AWSServiceRoleForElasticLoadBalancing")
-	iamSvc := iam.New(prov)
-	_, err := iamSvc.DeleteServiceLinkedRole(&iam.DeleteServiceLinkedRoleInput{
+	_, err := iamSvc.DeleteServiceLinkedRole(ctx, &iam.DeleteServiceLinkedRoleInput{
 		RoleName: aws.String("AWSServiceRoleForElasticLoadBalancing"),
 	})
-	if code, _ := awserrors.Code(err); code != iam.ErrCodeNoSuchEntityException {
+
+	var noSuchEntityErr *iamtypes.NoSuchEntityException
+	if !errors.As(err, &noSuchEntityErr) {
 		Expect(err).NotTo(HaveOccurred())
 	}
 
 	By("Deleting AWS IAM Service Linked Role: role-name=AWSServiceRoleForEC2Spot")
-	_, err = iamSvc.DeleteServiceLinkedRole(&iam.DeleteServiceLinkedRoleInput{
+	_, err = iamSvc.DeleteServiceLinkedRole(ctx, &iam.DeleteServiceLinkedRoleInput{
 		RoleName: aws.String("AWSServiceRoleForEC2Spot"),
 	})
-	if code, _ := awserrors.Code(err); code != iam.ErrCodeNoSuchEntityException {
+
+	if !errors.As(err, &noSuchEntityErr) {
 		Expect(err).NotTo(HaveOccurred())
 	}
 }
@@ -831,7 +868,7 @@ func ensureStackTags(prov client.ConfigProvider, stackName string, expectedTags
 }
 
 // encodeCredentials leverages clusterawsadm to encode AWS credentials.
-func encodeCredentials(accessKey *iam.AccessKey, region string) string {
+func encodeCredentials(accessKey *iamtypes.AccessKey, region string) string {
 	creds := credentials.AWSCredentials{
 		Region:          region,
 		AccessKeyID:     *accessKey.AccessKeyId,
@@ -844,25 +881,28 @@ func encodeCredentials(accessKey *iam.AccessKey, region string) string {
 
 // newUserAccessKey generates a new AWS Access Key pair based off of the
 // bootstrap user. This tests that the CloudFormation policy is correct.
-func newUserAccessKey(prov client.ConfigProvider, userName string) *iam.AccessKey {
-	iamSvc := iam.New(prov)
-	keyOuts, _ := iamSvc.ListAccessKeys(&iam.ListAccessKeysInput{
+func newUserAccessKey(ctx context.Context, cfg awsv2.Config, userName string) *iamtypes.AccessKey {
+	iamSvc := iam.NewFromConfig(cfg)
+
+	keyOuts, _ := iamSvc.ListAccessKeys(ctx, &iam.ListAccessKeysInput{
 		UserName: aws.String(userName),
 	})
 	for i := range keyOuts.AccessKeyMetadata {
 		By(fmt.Sprintf("Deleting an existing access key: user-name=%s", userName))
-		_, err := iamSvc.DeleteAccessKey(&iam.DeleteAccessKeyInput{
+		_, err := iamSvc.DeleteAccessKey(ctx, &iam.DeleteAccessKeyInput{
 			UserName:    aws.String(userName),
 			AccessKeyId: keyOuts.AccessKeyMetadata[i].AccessKeyId,
 		})
 		Expect(err).NotTo(HaveOccurred())
 	}
 	By(fmt.Sprintf("Creating an access key: user-name=%s", userName))
-	out, err := iamSvc.CreateAccessKey(&iam.CreateAccessKeyInput{UserName: aws.String(userName)})
+	out, err := iamSvc.CreateAccessKey(ctx, &iam.CreateAccessKeyInput{UserName: aws.String(userName)})
 	Expect(err).NotTo(HaveOccurred())
 	Expect(out.AccessKey).ToNot(BeNil())
+	Expect(out.AccessKey.AccessKeyId).ToNot(BeNil())
+	Expect(out.AccessKey.SecretAccessKey).ToNot(BeNil())
 
-	return &iam.AccessKey{
+	return &iamtypes.AccessKey{
 		AccessKeyId:     out.AccessKey.AccessKeyId,
 		SecretAccessKey: out.AccessKey.SecretAccessKey,
 	}
diff --git a/test/e2e/shared/context.go b/test/e2e/shared/context.go
index 5e2e15b5b..724d309ef 100644
--- a/test/e2e/shared/context.go
+++ b/test/e2e/shared/context.go
@@ -23,8 +23,9 @@ import (
 	"context"
 	"time"
 
+	awsv2 "github.com/aws/aws-sdk-go-v2/aws"
+	iamtypes "github.com/aws/aws-sdk-go-v2/service/iam/types"
 	"github.com/aws/aws-sdk-go/aws/client"
-	"github.com/aws/aws-sdk-go/service/iam"
 	"github.com/awslabs/goformation/v4/cloudformation"
 	"github.com/gofrs/flock"
 	corev1 "k8s.io/api/core/v1"
@@ -64,6 +65,8 @@ type E2EContext struct {
 	Environment RuntimeEnvironment
 	// AWSSession is the AWS session for the tests.
 	AWSSession client.ConfigProvider
+	// AWSClient is the AWS client for the tests.
+	AWSConfig awsv2.Config
 	// BootstrapUserAWSSession is the AWS session for the bootstrap user.
 	BootstrapUserAWSSession client.ConfigProvider
 	// IsManaged indicates that this is for the managed part of the provider.
@@ -116,8 +119,8 @@ type RuntimeEnvironment struct {
 	BootstrapClusterProxy framework.ClusterProxy
 	// BootstrapTemplate is the clusterawsadm bootstrap template for this run.
 	BootstrapTemplate *cfn_bootstrap.Template
-	// BootstrapAccessKey is the bootstrap user access key.
-	BootstrapAccessKey *iam.AccessKey
+	// BootstrapAccessKey is the bootstrap user access key for AWS SDK v2.
+	BootstrapAccessKey *iamtypes.AccessKey
 	// ResourceTicker for dumping resources.
 	ResourceTicker *time.Ticker
 	// ResourceTickerDone to stop ticking.
diff --git a/test/e2e/shared/suite.go b/test/e2e/shared/suite.go
index 0a6c65619..c1a84767f 100644
--- a/test/e2e/shared/suite.go
+++ b/test/e2e/shared/suite.go
@@ -31,7 +31,7 @@ import (
 	"strconv"
 	"time"
 
-	"github.com/aws/aws-sdk-go/service/iam"
+	iamtypes "github.com/aws/aws-sdk-go-v2/service/iam/types"
 	"github.com/gofrs/flock"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
@@ -49,7 +49,7 @@ type synchronizedBeforeTestSuiteConfig struct {
 	KubeconfigPath           string               `json:"kubeconfigPath,omitempty"`
 	Region                   string               `json:"region,omitempty"`
 	E2EConfig                clusterctl.E2EConfig `json:"e2eConfig,omitempty"`
-	BootstrapAccessKey       *iam.AccessKey       `json:"bootstrapAccessKey,omitempty"`
+	BootstrapAccessKey       *iamtypes.AccessKey  `json:"bootstrapAccessKey,omitempty"`
 	KubetestConfigFilePath   string               `json:"kubetestConfigFilePath,omitempty"`
 	UseCIArtifacts           bool                 `json:"useCIArtifacts,omitempty"`
 	GinkgoNodes              int                  `json:"ginkgoNodes,omitempty"`
@@ -129,6 +129,7 @@ func Node1BeforeSuite(e2eCtx *E2EContext) []byte {
 
 	Expect(err).NotTo(HaveOccurred())
 	e2eCtx.AWSSession = NewAWSSession()
+	e2eCtx.AWSConfig = NewAWSConfig(context.TODO())
 
 	logAccountDetails(e2eCtx.AWSSession)
 
@@ -142,7 +143,7 @@ func Node1BeforeSuite(e2eCtx *E2EContext) []byte {
 			count++
 			By(fmt.Sprintf("Trying to create CloudFormation stack... attempt %d", count))
 			success := true
-			if err := createCloudFormationStack(e2eCtx.AWSSession, bootstrapTemplate, bootstrapTags); err != nil {
+			if err := createCloudFormationStack(context.TODO(), e2eCtx.AWSConfig, e2eCtx.AWSSession, bootstrapTemplate, bootstrapTags); err != nil {
 				By(fmt.Sprintf("Failed to create CloudFormation stack in attempt %d: %s", count, err.Error()))
 				deleteCloudFormationStack(e2eCtx.AWSSession, bootstrapTemplate)
 				success = false
@@ -152,9 +153,9 @@ func Node1BeforeSuite(e2eCtx *E2EContext) []byte {
 	}
 
 	ensureStackTags(e2eCtx.AWSSession, bootstrapTemplate.Spec.StackName, bootstrapTags)
-	ensureNoServiceLinkedRoles(e2eCtx.AWSSession)
+	ensureNoServiceLinkedRoles(context.TODO(), e2eCtx.AWSConfig)
 	ensureSSHKeyPair(e2eCtx.AWSSession, DefaultSSHKeyPairName)
-	e2eCtx.Environment.BootstrapAccessKey = newUserAccessKey(e2eCtx.AWSSession, bootstrapTemplate.Spec.BootstrapUser.UserName)
+	e2eCtx.Environment.BootstrapAccessKey = newUserAccessKey(context.TODO(), e2eCtx.AWSConfig, bootstrapTemplate.Spec.BootstrapUser.UserName)
 	e2eCtx.BootstrapUserAWSSession = NewAWSSessionWithKey(e2eCtx.Environment.BootstrapAccessKey)
 	Expect(ensureTestImageUploaded(e2eCtx)).NotTo(HaveOccurred())
 
@@ -230,6 +231,7 @@ func AllNodesBeforeSuite(e2eCtx *E2EContext, data []byte) {
 	e2eCtx.Settings.GinkgoNodes = conf.GinkgoNodes
 	e2eCtx.Settings.GinkgoSlowSpecThreshold = conf.GinkgoSlowSpecThreshold
 	e2eCtx.AWSSession = NewAWSSession()
+	e2eCtx.AWSConfig = NewAWSConfig(context.TODO())
 	azs := GetAvailabilityZones(e2eCtx.AWSSession)
 	SetEnvVar(AwsAvailabilityZone1, *azs[0].ZoneName, false)
 	SetEnvVar(AwsAvailabilityZone2, *azs[1].ZoneName, false)
diff --git a/test/e2e/suites/managed/eks_ipv6_test.go b/test/e2e/suites/managed/eks_ipv6_test.go
index 22743d26c..5523f57a3 100644
--- a/test/e2e/suites/managed/eks_ipv6_test.go
+++ b/test/e2e/suites/managed/eks_ipv6_test.go
@@ -82,6 +82,7 @@ var _ = ginkgo.Describe("[managed] [general] [ipv6] EKS cluster tests", func() {
 				ConfigClusterFn:       defaultConfigCluster,
 				BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy,
 				AWSSession:            e2eCtx.BootstrapUserAWSSession,
+				AWSConfig:             e2eCtx.AWSConfig,
 				Namespace:             namespace,
 				ClusterName:           clusterName,
 				IncludeScaling:        false,
diff --git a/test/e2e/suites/managed/eks_legacy_test.go b/test/e2e/suites/managed/eks_legacy_test.go
index 82b414a84..a737a7cf8 100644
--- a/test/e2e/suites/managed/eks_legacy_test.go
+++ b/test/e2e/suites/managed/eks_legacy_test.go
@@ -82,6 +82,7 @@ var _ = ginkgo.Describe("[managed] [legacy] EKS cluster tests - single kind", fu
 				ConfigClusterFn:       defaultConfigCluster,
 				BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy,
 				AWSSession:            e2eCtx.BootstrapUserAWSSession,
+				AWSConfig:             e2eCtx.AWSConfig,
 				Namespace:             namespace,
 				ClusterName:           clusterName,
 				IncludeScaling:        false,
diff --git a/test/e2e/suites/managed/eks_test.go b/test/e2e/suites/managed/eks_test.go
index 85e11b747..2f4106b9d 100644
--- a/test/e2e/suites/managed/eks_test.go
+++ b/test/e2e/suites/managed/eks_test.go
@@ -118,6 +118,7 @@ var _ = ginkgo.Describe("[managed] [general] EKS cluster tests", func() {
 				ConfigClusterFn:       defaultConfigCluster,
 				BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy,
 				AWSSession:            e2eCtx.BootstrapUserAWSSession,
+				AWSConfig:             e2eCtx.AWSConfig,
 				Namespace:             namespace,
 				ClusterName:           clusterName,
 				IncludeScaling:        true,
@@ -134,6 +135,7 @@ var _ = ginkgo.Describe("[managed] [general] EKS cluster tests", func() {
 				ConfigClusterFn:       defaultConfigCluster,
 				BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy,
 				AWSSession:            e2eCtx.BootstrapUserAWSSession,
+				AWSConfig:             e2eCtx.AWSConfig,
 				Namespace:             namespace,
 				ClusterName:           clusterName,
 				IncludeScaling:        true,
@@ -151,6 +153,7 @@ var _ = ginkgo.Describe("[managed] [general] EKS cluster tests", func() {
 				ConfigClusterFn:       defaultConfigCluster,
 				BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy,
 				AWSSession:            e2eCtx.BootstrapUserAWSSession,
+				AWSConfig:             e2eCtx.AWSConfig,
 				Namespace:             namespace,
 				ClusterName:           clusterName,
 				IncludeScaling:        true,
diff --git a/test/e2e/suites/managed/helpers.go b/test/e2e/suites/managed/helpers.go
index 841725435..2b74fd1a0 100644
--- a/test/e2e/suites/managed/helpers.go
+++ b/test/e2e/suites/managed/helpers.go
@@ -24,9 +24,10 @@ import (
 	"fmt"
 	"time"
 
+	awsv2 "github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/autoscaling"
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/client"
-	"github.com/aws/aws-sdk-go/service/autoscaling"
 	"github.com/aws/aws-sdk-go/service/eks"
 	"github.com/aws/aws-sdk-go/service/iam"
 	. "github.com/onsi/gomega"
@@ -198,26 +199,26 @@ func verifyManagedNodeGroup(eksClusterName, nodeGroupName string, checkOwned boo
 	}
 }
 
-func verifyASG(eksClusterName, asgName string, checkOwned bool, sess client.ConfigProvider) {
-	asgClient := autoscaling.New(sess)
+func verifyASG(eksClusterName, asgName string, checkOwned bool, cfg awsv2.Config) {
+	asgClient := autoscaling.NewFromConfig(cfg)
+
 	input := &autoscaling.DescribeAutoScalingGroupsInput{
-		AutoScalingGroupNames: []*string{
-			aws.String(asgName),
+		AutoScalingGroupNames: []string{
+			asgName,
 		},
 	}
-
 	var (
 		result *autoscaling.DescribeAutoScalingGroupsOutput
 		err    error
 	)
 
 	Eventually(func() error {
-		result, err = asgClient.DescribeAutoScalingGroups(input)
+		result, err = asgClient.DescribeAutoScalingGroups(context.TODO(), input)
 		return err
 	}, clientRequestTimeout, clientRequestCheckInterval).Should(Succeed())
 
 	for _, instance := range result.AutoScalingGroups[0].Instances {
-		Expect(*instance.LifecycleState).To(Equal("InService"), "expecting the instance in service")
+		Expect(string(instance.LifecycleState)).To(Equal("InService"), "expecting the instance in service")
 	}
 
 	if checkOwned {
diff --git a/test/e2e/suites/managed/machine_pool.go b/test/e2e/suites/managed/machine_pool.go
index db9ab5260..da871cc3d 100644
--- a/test/e2e/suites/managed/machine_pool.go
+++ b/test/e2e/suites/managed/machine_pool.go
@@ -25,6 +25,7 @@ import (
 	"fmt"
 	"strings"
 
+	awsv2 "github.com/aws/aws-sdk-go-v2/aws"
 	"github.com/aws/aws-sdk-go/aws/client"
 	"github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
@@ -42,6 +43,7 @@ type MachinePoolSpecInput struct {
 	ConfigClusterFn       DefaultConfigClusterFn
 	BootstrapClusterProxy framework.ClusterProxy
 	AWSSession            client.ConfigProvider
+	AWSConfig             awsv2.Config
 	Namespace             *corev1.Namespace
 	ClusterName           string
 	IncludeScaling        bool
@@ -58,6 +60,7 @@ func MachinePoolSpec(ctx context.Context, inputGetter func() MachinePoolSpecInpu
 	Expect(input.ConfigClusterFn).ToNot(BeNil(), "Invalid argument. input.ConfigClusterFn can't be nil")
 	Expect(input.BootstrapClusterProxy).ToNot(BeNil(), "Invalid argument. input.BootstrapClusterProxy can't be nil")
 	Expect(input.AWSSession).ToNot(BeNil(), "Invalid argument. input.AWSSession can't be nil")
+	Expect(input.AWSConfig).ToNot(BeNil(), "Invalid argument. input.AWSCfg can't be nil")
 	Expect(input.Namespace).NotTo(BeNil(), "Invalid argument. input.Namespace can't be nil")
 	Expect(input.ClusterName).ShouldNot(BeEmpty(), "Invalid argument. input.ClusterName can't be empty")
 	Expect(input.Flavor).ShouldNot(BeEmpty(), "Invalid argument. input.Flavor can't be empty")
@@ -110,7 +113,7 @@ func MachinePoolSpec(ctx context.Context, inputGetter func() MachinePoolSpecInpu
 		verifyManagedNodeGroup(eksClusterName, nodeGroupName, true, input.AWSSession)
 	} else {
 		asgName := getASGName(input.ClusterName)
-		verifyASG(eksClusterName, asgName, true, input.AWSSession)
+		verifyASG(eksClusterName, asgName, true, input.AWSConfig)
 	}
 
 	if input.IncludeScaling { // TODO (richardcase): should this be a separate spec?