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

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

./test/mocks/aws_elbv2_mock.go
./test/mocks/aws_elb_mock.go
./test/e2e/suites/unmanaged/unmanaged_classic_elb_upgrade_test.go
./pkg/cloud/scope/elb.go
./pkg/cloud/services/elb
./pkg/cloud/services/mock_services/elb_interface_mock.go

Hints from issue comments:
@damdo: See examples on how to migrate here: https://github.com/kubernetes-sigs/cluster-api-provider-aws/pull/5389@faermanj: @damdo I could take this one, but can' self-assign, would you assign to me? @damdo: /assign @faermanj @damdo: Thanks Julio for taking this, much appreciated@damdo: Based on the conversation with @richardcase I've unassigned you @faermanj as you are busy with other work, in case anyone else has more time to pick this up. Feel free to reassign if you find time in the future. Thanks!@phuhung273: /assign

Solution patch:
diff --git a/config/crd/bases/infrastructure.cluster.x-k8s.io_awsmanagedmachinepools.yaml b/config/crd/bases/infrastructure.cluster.x-k8s.io_awsmanagedmachinepools.yaml
index fd2fc16c0..f2e499188 100644
--- a/config/crd/bases/infrastructure.cluster.x-k8s.io_awsmanagedmachinepools.yaml
+++ b/config/crd/bases/infrastructure.cluster.x-k8s.io_awsmanagedmachinepools.yaml
@@ -548,9 +548,22 @@ spec:
                 - AL2_x86_64
                 - AL2_x86_64_GPU
                 - AL2_ARM_64
+                - CUSTOM
+                - BOTTLEROCKET_ARM_64
+                - BOTTLEROCKET_x86_64
+                - BOTTLEROCKET_ARM_64_FIPS
+                - BOTTLEROCKET_x86_64_FIPS
+                - BOTTLEROCKET_ARM_64_NVIDIA
+                - BOTTLEROCKET_x86_64_NVIDIA
+                - WINDOWS_CORE_2019_x86_64
+                - WINDOWS_FULL_2019_x86_64
+                - WINDOWS_CORE_2022_x86_64
+                - WINDOWS_FULL_2022_x86_64
                 - AL2023_x86_64_STANDARD
                 - AL2023_ARM_64_STANDARD
-                - CUSTOM
+                - AL2023_x86_64_NEURON
+                - AL2023_x86_64_NVIDIA
+                - AL2023_ARM_64_NVIDIA
                 type: string
               amiVersion:
                 description: |-
diff --git a/controllers/awscluster_controller.go b/controllers/awscluster_controller.go
index 1d0d332f1..eb3904463 100644
--- a/controllers/awscluster_controller.go
+++ b/controllers/awscluster_controller.go
@@ -80,6 +80,7 @@ type AWSClusterReconciler struct {
 	ExternalResourceGC           bool
 	AlternativeGCStrategy        bool
 	TagUnmanagedNetworkResources bool
+	MaxWaitActiveUpdateDelete    time.Duration
 }
 
 // getEC2Service factory func is added for testing purpose so that we can inject mocked EC2Service to the AWSClusterReconciler.
@@ -178,6 +179,7 @@ func (r *AWSClusterReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 		ControllerName:               "awscluster",
 		Endpoints:                    r.Endpoints,
 		TagUnmanagedNetworkResources: r.TagUnmanagedNetworkResources,
+		MaxWaitActiveUpdateDelete:    r.MaxWaitActiveUpdateDelete,
 	})
 	if err != nil {
 		return reconcile.Result{}, errors.Errorf("failed to create scope: %+v", err)
@@ -247,7 +249,7 @@ func (r *AWSClusterReconciler) reconcileDelete(ctx context.Context, clusterScope
 		allErrs = append(allErrs, errors.Wrapf(err, "error deleting S3 Bucket"))
 	}
 
-	if err := elbsvc.DeleteLoadbalancers(); err != nil {
+	if err := elbsvc.DeleteLoadbalancers(ctx); err != nil {
 		allErrs = append(allErrs, errors.Wrapf(err, "error deleting load balancers"))
 	}
 
@@ -279,7 +281,7 @@ func (r *AWSClusterReconciler) reconcileDelete(ctx context.Context, clusterScope
 	return reconcile.Result{}, nil
 }
 
-func (r *AWSClusterReconciler) reconcileLoadBalancer(clusterScope *scope.ClusterScope, awsCluster *infrav1.AWSCluster) (*time.Duration, error) {
+func (r *AWSClusterReconciler) reconcileLoadBalancer(ctx context.Context, clusterScope *scope.ClusterScope, awsCluster *infrav1.AWSCluster) (*time.Duration, error) {
 	retryAfterDuration := 15 * time.Second
 	if clusterScope.AWSCluster.Spec.ControlPlaneLoadBalancer.LoadBalancerType == infrav1.LoadBalancerTypeDisabled {
 		clusterScope.Debug("load balancer reconciliation shifted to external provider, checking external endpoint")
@@ -289,7 +291,7 @@ func (r *AWSClusterReconciler) reconcileLoadBalancer(clusterScope *scope.Cluster
 
 	elbService := r.getELBService(clusterScope)
 
-	if err := elbService.ReconcileLoadbalancers(); err != nil {
+	if err := elbService.ReconcileLoadbalancers(ctx); err != nil {
 		clusterScope.Error(err, "failed to reconcile load balancer")
 		conditions.MarkFalse(awsCluster, infrav1.LoadBalancerReadyCondition, infrav1.LoadBalancerFailedReason, infrautilconditions.ErrorConditionAfterInit(clusterScope.ClusterObj()), "%s", err.Error())
 		return nil, err
@@ -354,7 +356,7 @@ func (r *AWSClusterReconciler) reconcileNormal(ctx context.Context, clusterScope
 		}
 	}
 
-	if requeueAfter, err := r.reconcileLoadBalancer(clusterScope, awsCluster); err != nil {
+	if requeueAfter, err := r.reconcileLoadBalancer(ctx, clusterScope, awsCluster); err != nil {
 		return reconcile.Result{}, err
 	} else if requeueAfter != nil {
 		return reconcile.Result{RequeueAfter: *requeueAfter}, err
diff --git a/controllers/awsmachine_controller.go b/controllers/awsmachine_controller.go
index 98f3b3127..7e3c21a26 100644
--- a/controllers/awsmachine_controller.go
+++ b/controllers/awsmachine_controller.go
@@ -87,6 +87,7 @@ type AWSMachineReconciler struct {
 	Endpoints                    []scope.ServiceEndpoint
 	WatchFilterValue             string
 	TagUnmanagedNetworkResources bool
+	MaxWaitActiveUpdateDelete    time.Duration
 }
 
 const (
@@ -330,7 +331,7 @@ func (r *AWSMachineReconciler) reconcileDelete(ctx context.Context, machineScope
 
 	machineScope.Debug("EC2 instance found matching deleted AWSMachine", "instance-id", instance.ID)
 
-	if err := r.reconcileLBAttachment(machineScope, elbScope, instance); err != nil {
+	if err := r.reconcileLBAttachment(ctx, machineScope, elbScope, instance); err != nil {
 		// We are tolerating AccessDenied error, so this won't block for users with older version of IAM;
 		// all the other errors are blocking.
 		// Because we are reconciling all load balancers, attempt to treat the error as a list of errors.
@@ -641,7 +642,7 @@ func (r *AWSMachineReconciler) reconcileNormal(ctx context.Context, machineScope
 			r.ensureStorageTags(ec2svc, instance, machineScope.AWSMachine, machineScope.AdditionalTags())
 		}
 
-		if err := r.reconcileLBAttachment(machineScope, elbScope, instance); err != nil {
+		if err := r.reconcileLBAttachment(ctx, machineScope, elbScope, instance); err != nil {
 			// We are tolerating InstanceNotRunning error, so we don't report it as an error condition.
 			// Because we are reconciling all load balancers, attempt to treat the error as a list of errors.
 			if err := kerrors.FilterOut(err, elb.IsInstanceNotRunning); err != nil {
@@ -954,7 +955,7 @@ func (r *AWSMachineReconciler) deleteIgnitionBootstrapDataFromS3(ctx context.Con
 
 // reconcileLBAttachment reconciles attachment to _all_ defined load balancers.
 // Callers are expected to filter out known-good errors out of the aggregate error list.
-func (r *AWSMachineReconciler) reconcileLBAttachment(machineScope *scope.MachineScope, elbScope scope.ELBScope, i *infrav1.Instance) error {
+func (r *AWSMachineReconciler) reconcileLBAttachment(ctx context.Context, machineScope *scope.MachineScope, elbScope scope.ELBScope, i *infrav1.Instance) error {
 	if !machineScope.IsControlPlane() {
 		return nil
 	}
@@ -971,14 +972,14 @@ func (r *AWSMachineReconciler) reconcileLBAttachment(machineScope *scope.Machine
 		if machineScope.AWSMachineIsDeleted() || machineScope.MachineIsDeleted() || !machineScope.InstanceIsRunning() {
 			if lbSpec.LoadBalancerType == infrav1.LoadBalancerTypeClassic {
 				machineScope.Debug("deregistering from classic load balancer")
-				return r.deregisterInstanceFromClassicLB(machineScope, elbsvc, i)
+				return r.deregisterInstanceFromClassicLB(ctx, machineScope, elbsvc, i)
 			}
 			machineScope.Debug("deregistering from v2 load balancer")
-			errs = append(errs, r.deregisterInstanceFromV2LB(machineScope, elbsvc, i, lbSpec))
+			errs = append(errs, r.deregisterInstanceFromV2LB(ctx, machineScope, elbsvc, i, lbSpec))
 			continue
 		}
 
-		if err := r.registerInstanceToLBs(machineScope, elbsvc, i, lbSpec); err != nil {
+		if err := r.registerInstanceToLBs(ctx, machineScope, elbsvc, i, lbSpec); err != nil {
 			errs = append(errs, errors.Wrapf(err, "could not register machine to load balancer"))
 		}
 	}
@@ -986,21 +987,21 @@ func (r *AWSMachineReconciler) reconcileLBAttachment(machineScope *scope.Machine
 	return kerrors.NewAggregate(errs)
 }
 
-func (r *AWSMachineReconciler) registerInstanceToLBs(machineScope *scope.MachineScope, elbsvc services.ELBInterface, i *infrav1.Instance, lb *infrav1.AWSLoadBalancerSpec) error {
+func (r *AWSMachineReconciler) registerInstanceToLBs(ctx context.Context, machineScope *scope.MachineScope, elbsvc services.ELBInterface, i *infrav1.Instance, lb *infrav1.AWSLoadBalancerSpec) error {
 	switch lb.LoadBalancerType {
 	case infrav1.LoadBalancerTypeClassic, "":
 		machineScope.Debug("registering to classic load balancer")
-		return r.registerInstanceToClassicLB(machineScope, elbsvc, i)
+		return r.registerInstanceToClassicLB(ctx, machineScope, elbsvc, i)
 	case infrav1.LoadBalancerTypeELB, infrav1.LoadBalancerTypeALB, infrav1.LoadBalancerTypeNLB:
 		machineScope.Debug("registering to v2 load balancer")
-		return r.registerInstanceToV2LB(machineScope, elbsvc, i, lb)
+		return r.registerInstanceToV2LB(ctx, machineScope, elbsvc, i, lb)
 	}
 
 	return errors.Errorf("unknown load balancer type %q", lb.LoadBalancerType)
 }
 
-func (r *AWSMachineReconciler) registerInstanceToClassicLB(machineScope *scope.MachineScope, elbsvc services.ELBInterface, i *infrav1.Instance) error {
-	registered, err := elbsvc.IsInstanceRegisteredWithAPIServerELB(i)
+func (r *AWSMachineReconciler) registerInstanceToClassicLB(ctx context.Context, machineScope *scope.MachineScope, elbsvc services.ELBInterface, i *infrav1.Instance) error {
+	registered, err := elbsvc.IsInstanceRegisteredWithAPIServerELB(ctx, i)
 	if err != nil {
 		r.Recorder.Eventf(machineScope.AWSMachine, corev1.EventTypeWarning, "FailedAttachControlPlaneELB",
 			"Failed to register control plane instance %q with classic load balancer: failed to determine registration status: %v", i.ID, err)
@@ -1011,7 +1012,7 @@ func (r *AWSMachineReconciler) registerInstanceToClassicLB(machineScope *scope.M
 		return nil
 	}
 
-	if err := elbsvc.RegisterInstanceWithAPIServerELB(i); err != nil {
+	if err := elbsvc.RegisterInstanceWithAPIServerELB(ctx, i); err != nil {
 		r.Recorder.Eventf(machineScope.AWSMachine, corev1.EventTypeWarning, "FailedAttachControlPlaneELB",
 			"Failed to register control plane instance %q with classic load balancer: %v", i.ID, err)
 		conditions.MarkFalse(machineScope.AWSMachine, infrav1.ELBAttachedCondition, infrav1.ELBAttachFailedReason, clusterv1.ConditionSeverityError, "%s", err.Error())
@@ -1023,8 +1024,8 @@ func (r *AWSMachineReconciler) registerInstanceToClassicLB(machineScope *scope.M
 	return nil
 }
 
-func (r *AWSMachineReconciler) registerInstanceToV2LB(machineScope *scope.MachineScope, elbsvc services.ELBInterface, instance *infrav1.Instance, lb *infrav1.AWSLoadBalancerSpec) error {
-	_, registered, err := elbsvc.IsInstanceRegisteredWithAPIServerLB(instance, lb)
+func (r *AWSMachineReconciler) registerInstanceToV2LB(ctx context.Context, machineScope *scope.MachineScope, elbsvc services.ELBInterface, instance *infrav1.Instance, lb *infrav1.AWSLoadBalancerSpec) error {
+	_, registered, err := elbsvc.IsInstanceRegisteredWithAPIServerLB(ctx, instance, lb)
 	if err != nil {
 		r.Recorder.Eventf(machineScope.AWSMachine, corev1.EventTypeWarning, "FailedAttachControlPlaneELB",
 			"Failed to register control plane instance %q with load balancer: failed to determine registration status: %v", instance.ID, err)
@@ -1043,7 +1044,7 @@ func (r *AWSMachineReconciler) registerInstanceToV2LB(machineScope *scope.Machin
 		return elb.NewInstanceNotRunning("instance is not running")
 	}
 
-	if err := elbsvc.RegisterInstanceWithAPIServerLB(instance, lb); err != nil {
+	if err := elbsvc.RegisterInstanceWithAPIServerLB(ctx, instance, lb); err != nil {
 		r.Recorder.Eventf(machineScope.AWSMachine, corev1.EventTypeWarning, "FailedAttachControlPlaneELB",
 			"Failed to register control plane instance %q with load balancer: %v", instance.ID, err)
 		conditions.MarkFalse(machineScope.AWSMachine, infrav1.ELBAttachedCondition, infrav1.ELBAttachFailedReason, clusterv1.ConditionSeverityError, "%s", err.Error())
@@ -1055,8 +1056,8 @@ func (r *AWSMachineReconciler) registerInstanceToV2LB(machineScope *scope.Machin
 	return nil
 }
 
-func (r *AWSMachineReconciler) deregisterInstanceFromClassicLB(machineScope *scope.MachineScope, elbsvc services.ELBInterface, instance *infrav1.Instance) error {
-	registered, err := elbsvc.IsInstanceRegisteredWithAPIServerELB(instance)
+func (r *AWSMachineReconciler) deregisterInstanceFromClassicLB(ctx context.Context, machineScope *scope.MachineScope, elbsvc services.ELBInterface, instance *infrav1.Instance) error {
+	registered, err := elbsvc.IsInstanceRegisteredWithAPIServerELB(ctx, instance)
 	if err != nil {
 		r.Recorder.Eventf(machineScope.AWSMachine, corev1.EventTypeWarning, "FailedDetachControlPlaneELB",
 			"Failed to deregister control plane instance %q from load balancer: failed to determine registration status: %v", instance.ID, err)
@@ -1067,7 +1068,7 @@ func (r *AWSMachineReconciler) deregisterInstanceFromClassicLB(machineScope *sco
 		return nil
 	}
 
-	if err := elbsvc.DeregisterInstanceFromAPIServerELB(instance); err != nil {
+	if err := elbsvc.DeregisterInstanceFromAPIServerELB(ctx, instance); err != nil {
 		r.Recorder.Eventf(machineScope.AWSMachine, corev1.EventTypeWarning, "FailedDetachControlPlaneELB",
 			"Failed to deregister control plane instance %q from load balancer: %v", instance.ID, err)
 		conditions.MarkFalse(machineScope.AWSMachine, infrav1.ELBAttachedCondition, infrav1.ELBDetachFailedReason, clusterv1.ConditionSeverityError, "%s", err.Error())
@@ -1079,8 +1080,8 @@ func (r *AWSMachineReconciler) deregisterInstanceFromClassicLB(machineScope *sco
 	return nil
 }
 
-func (r *AWSMachineReconciler) deregisterInstanceFromV2LB(machineScope *scope.MachineScope, elbsvc services.ELBInterface, i *infrav1.Instance, lb *infrav1.AWSLoadBalancerSpec) error {
-	targetGroupARNs, registered, err := elbsvc.IsInstanceRegisteredWithAPIServerLB(i, lb)
+func (r *AWSMachineReconciler) deregisterInstanceFromV2LB(ctx context.Context, machineScope *scope.MachineScope, elbsvc services.ELBInterface, i *infrav1.Instance, lb *infrav1.AWSLoadBalancerSpec) error {
+	targetGroupARNs, registered, err := elbsvc.IsInstanceRegisteredWithAPIServerLB(ctx, i, lb)
 	if err != nil {
 		r.Recorder.Eventf(machineScope.AWSMachine, corev1.EventTypeWarning, "FailedDetachControlPlaneELB",
 			"Failed to deregister control plane instance %q from load balancer: failed to determine registration status: %v", i.ID, err)
@@ -1092,7 +1093,7 @@ func (r *AWSMachineReconciler) deregisterInstanceFromV2LB(machineScope *scope.Ma
 	}
 
 	for _, targetGroupArn := range targetGroupARNs {
-		if err := elbsvc.DeregisterInstanceFromAPIServerLB(targetGroupArn, i); err != nil {
+		if err := elbsvc.DeregisterInstanceFromAPIServerLB(ctx, targetGroupArn, i); err != nil {
 			r.Recorder.Eventf(machineScope.AWSMachine, corev1.EventTypeWarning, "FailedDetachControlPlaneELB",
 				"Failed to deregister control plane instance %q from load balancer: %v", i.ID, err)
 			conditions.MarkFalse(machineScope.AWSMachine, infrav1.ELBAttachedCondition, infrav1.ELBDetachFailedReason, clusterv1.ConditionSeverityError, "%s", err.Error())
@@ -1234,6 +1235,7 @@ func (r *AWSMachineReconciler) getInfraCluster(ctx context.Context, log *logger.
 		AWSCluster:                   awsCluster,
 		ControllerName:               "awsmachine",
 		TagUnmanagedNetworkResources: r.TagUnmanagedNetworkResources,
+		MaxWaitActiveUpdateDelete:    r.MaxWaitActiveUpdateDelete,
 	})
 	if err != nil {
 		return nil, err
diff --git a/exp/api/v1beta2/awsmanagedmachinepool_types.go b/exp/api/v1beta2/awsmanagedmachinepool_types.go
index 08cf8568e..0aeb7be0d 100644
--- a/exp/api/v1beta2/awsmanagedmachinepool_types.go
+++ b/exp/api/v1beta2/awsmanagedmachinepool_types.go
@@ -27,6 +27,8 @@ import (
 )
 
 // ManagedMachineAMIType specifies which AWS AMI to use for a managed MachinePool.
+// Source of truth can be found using the link below:
+// https://docs.aws.amazon.com/eks/latest/APIReference/API_CreateNodegroup.html#AmazonEKS-CreateNodegroup-request-amiType
 type ManagedMachineAMIType string
 
 const (
@@ -36,10 +38,38 @@ const (
 	Al2x86_64GPU ManagedMachineAMIType = "AL2_x86_64_GPU"
 	// Al2Arm64 is the Arm AMI type.
 	Al2Arm64 ManagedMachineAMIType = "AL2_ARM_64"
+	// Custom is the custom AMI type.
+	Custom ManagedMachineAMIType = "CUSTOM"
+	// BottleRocketArm64 is the Arm AMI type.
+	BottleRocketArm64 ManagedMachineAMIType = "BOTTLEROCKET_ARM_64"
+	// BottleRocketx86_64 is the BottleRocket x86-64 AMI type.
+	BottleRocketx86_64 ManagedMachineAMIType = "BOTTLEROCKET_x86_64"
+	// BottleRocketArm64Fips is the BottleRocket Arm Fips AMI type.
+	BottleRocketArm64Fips ManagedMachineAMIType = "BOTTLEROCKET_ARM_64_FIPS"
+	// BottleRocketx86_64Fips is the BottleRocket x86-64 Fips AMI type.
+	BottleRocketx86_64Fips ManagedMachineAMIType = "BOTTLEROCKET_x86_64_FIPS"
+	// BottleRocketArm64Nvidia is the BottleRocket Arm Nvidia AMI type.
+	BottleRocketArm64Nvidia ManagedMachineAMIType = "BOTTLEROCKET_ARM_64_NVIDIA"
+	// BottleRocketx86_64Nvidia is the BottleRocket x86-64 Nvidia AMI type.
+	BottleRocketx86_64Nvidia ManagedMachineAMIType = "BOTTLEROCKET_x86_64_NVIDIA"
+	// WindowsCore2019x86_64 is the Windows Core 2019 x86-64 AMI type.
+	WindowsCore2019x86_64 ManagedMachineAMIType = "WINDOWS_CORE_2019_x86_64"
+	// WindowsFull2019x86_64 is the Windows Full 2019 x86-64 AMI type.
+	WindowsFull2019x86_64 ManagedMachineAMIType = "WINDOWS_FULL_2019_x86_64"
+	// WindowsCore2022x86_64 is the Windows Core 2022 x86-64 AMI type.
+	WindowsCore2022x86_64 ManagedMachineAMIType = "WINDOWS_CORE_2022_x86_64"
+	// WindowsFull2022x86_64 is the Windows Full 2022 x86-64 AMI type.
+	WindowsFull2022x86_64 ManagedMachineAMIType = "WINDOWS_FULL_2022_x86_64"
 	// Al2023x86_64 is the AL2023 x86-64 AMI type.
 	Al2023x86_64 ManagedMachineAMIType = "AL2023_x86_64_STANDARD"
 	// Al2023Arm64 is the AL2023 Arm AMI type.
 	Al2023Arm64 ManagedMachineAMIType = "AL2023_ARM_64_STANDARD"
+	// Al2023x86_64Neuron is the AL2023 x86-64 Neuron AMI type.
+	Al2023x86_64Neuron ManagedMachineAMIType = "AL2023_x86_64_NEURON"
+	// Al2023x86_64Nvidia is the AL2023 x86-64 Nvidia AMI type.
+	Al2023x86_64Nvidia ManagedMachineAMIType = "AL2023_x86_64_NVIDIA"
+	// Al2023Arm64Nvidia is the AL2023 Arm Nvidia AMI type.
+	Al2023Arm64Nvidia ManagedMachineAMIType = "AL2023_ARM_64_NVIDIA"
 )
 
 // ManagedMachinePoolCapacityType specifies the capacity type to be used for the managed MachinePool.
@@ -129,7 +159,7 @@ type AWSManagedMachinePoolSpec struct {
 	AMIVersion *string `json:"amiVersion,omitempty"`
 
 	// AMIType defines the AMI type
-	// +kubebuilder:validation:Enum:=AL2_x86_64;AL2_x86_64_GPU;AL2_ARM_64;AL2023_x86_64_STANDARD;AL2023_ARM_64_STANDARD;CUSTOM
+	// +kubebuilder:validation:Enum:=AL2_x86_64;AL2_x86_64_GPU;AL2_ARM_64;CUSTOM;BOTTLEROCKET_ARM_64;BOTTLEROCKET_x86_64;BOTTLEROCKET_ARM_64_FIPS;BOTTLEROCKET_x86_64_FIPS;BOTTLEROCKET_ARM_64_NVIDIA;BOTTLEROCKET_x86_64_NVIDIA;WINDOWS_CORE_2019_x86_64;WINDOWS_FULL_2019_x86_64;WINDOWS_CORE_2022_x86_64;WINDOWS_FULL_2022_x86_64;AL2023_x86_64_STANDARD;AL2023_ARM_64_STANDARD;AL2023_x86_64_NEURON;AL2023_x86_64_NVIDIA;AL2023_ARM_64_NVIDIA
 	// +kubebuilder:default:=AL2_x86_64
 	// +optional
 	AMIType *ManagedMachineAMIType `json:"amiType,omitempty"`
diff --git a/go.mod b/go.mod
index 20ff8b728..23abc3af9 100644
--- a/go.mod
+++ b/go.mod
@@ -13,7 +13,10 @@ require (
 	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/eks v1.64.0
+	github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing v1.29.6
+	github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2 v1.34.0
 	github.com/aws/aws-sdk-go-v2/service/iam v1.32.0
+	github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi v1.26.6
 	github.com/aws/aws-sdk-go-v2/service/s3 v1.53.1
 	github.com/aws/aws-sdk-go-v2/service/ssm v1.59.1
 	github.com/aws/aws-sdk-go-v2/service/sts v1.28.6
@@ -86,14 +89,14 @@ require (
 	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.36 // 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/ec2 v1.159.0
 	github.com/aws/aws-sdk-go-v2/service/eventbridge v1.39.3
 	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
 	github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.17.5 // indirect
 	github.com/aws/aws-sdk-go-v2/service/organizations v1.27.3 // indirect
-	github.com/aws/aws-sdk-go-v2/service/secretsmanager v1.28.6 // indirect
+	github.com/aws/aws-sdk-go-v2/service/secretsmanager v1.28.6
 	github.com/aws/aws-sdk-go-v2/service/servicequotas v1.21.4 // indirect
 	github.com/aws/aws-sdk-go-v2/service/sqs v1.38.8
 	github.com/aws/aws-sdk-go-v2/service/sso v1.20.5 // indirect
diff --git a/go.sum b/go.sum
index 7b9746e1b..59623666d 100644
--- a/go.sum
+++ b/go.sum
@@ -74,6 +74,10 @@ github.com/aws/aws-sdk-go-v2/service/ec2 v1.159.0 h1:DmmVmiLPlcntOcjWMRwDPMNx/wi
 github.com/aws/aws-sdk-go-v2/service/ec2 v1.159.0/go.mod h1:xejKuuRDjz6z5OqyeLsz01MlOqqW7CqpAB4PabNvpu8=
 github.com/aws/aws-sdk-go-v2/service/eks v1.64.0 h1:EYeOThTRysemFtC6J6h6b7dNg3jN03QuO5cg92ojIQE=
 github.com/aws/aws-sdk-go-v2/service/eks v1.64.0/go.mod h1:v1xXy6ea0PHtWkjFUvAUh6B/5wv7UF909Nru0dOIJDk=
+github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing v1.29.6 h1:9grU/+HRwLXJV8XUjEPThJj/H+0oHkeNBFpSSfZekeg=
+github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing v1.29.6/go.mod h1:N4fs285CsnBHlAkzBpQapefR/noggTyF09fWs72EzB4=
+github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2 v1.34.0 h1:8rDRtPOu3ax8jEctw7G926JQlnFdhZZA4KJzQ+4ks3Q=
+github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2 v1.34.0/go.mod h1:L5bVuO4PeXuDuMYZfL3IW69E6mz6PDCYpp6IKDlcLMA=
 github.com/aws/aws-sdk-go-v2/service/eventbridge v1.39.3 h1:T6L7fsONflMeXuvsT8qZ247hA8ShBB0jF9yUEhW4JqI=
 github.com/aws/aws-sdk-go-v2/service/eventbridge v1.39.3/go.mod h1:sIrUII6Z+hAVAgcpmsc2e9HvEr++m/v8aBPT7s4ZYUk=
 github.com/aws/aws-sdk-go-v2/service/iam v1.32.0 h1:ZNlfPdw849gBo/lvLFbEEvpTJMij0LXqiNWZ+lIamlU=
@@ -88,6 +92,8 @@ github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.17.5 h1:f9RyWNtS8oH7cZ
 github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.17.5/go.mod h1:h5CoMZV2VF297/VLhRhO1WF+XYWOzXo+4HsObA4HjBQ=
 github.com/aws/aws-sdk-go-v2/service/organizations v1.27.3 h1:CnPWlONzFX9/yO6IGuKg9sWUE8WhKztYRFbhmOHXjJI=
 github.com/aws/aws-sdk-go-v2/service/organizations v1.27.3/go.mod h1:hUHSXe9HFEmLfHrXndAX5e69rv0nBsg22VuNQYl0JLM=
+github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi v1.26.6 h1:PwbxovpcJvb25k019bkibvJfCpCmIANOFrXZIFPmRzk=
+github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi v1.26.6/go.mod h1:Z4xLt5mXspLKjBV92i165wAJ/3T6TIv4n7RtIS8pWV0=
 github.com/aws/aws-sdk-go-v2/service/s3 v1.53.1 h1:6cnno47Me9bRykw9AEv9zkXE+5or7jz8TsskTTccbgc=
 github.com/aws/aws-sdk-go-v2/service/s3 v1.53.1/go.mod h1:qmdkIIAC+GCLASF7R2whgNrJADz0QZPX+Seiw/i4S3o=
 github.com/aws/aws-sdk-go-v2/service/secretsmanager v1.28.6 h1:TIOEjw0i2yyhmhRry3Oeu9YtiiHWISZ6j/irS1W3gX4=
diff --git a/main.go b/main.go
index 8d5e4ebc8..4b712badc 100644
--- a/main.go
+++ b/main.go
@@ -316,6 +316,7 @@ func setupReconcilersAndWebhooks(ctx context.Context, mgr ctrl.Manager, awsServi
 			Endpoints:                    awsServiceEndpoints,
 			WatchFilterValue:             watchFilterValue,
 			TagUnmanagedNetworkResources: feature.Gates.Enabled(feature.TagUnmanagedNetworkResources),
+			MaxWaitActiveUpdateDelete:    maxWaitActiveUpdateDelete,
 		}).SetupWithManager(ctx, mgr, controller.Options{MaxConcurrentReconciles: awsMachineConcurrency, RecoverPanic: ptr.To[bool](true)}); err != nil {
 			setupLog.Error(err, "unable to create controller", "controller", "AWSMachine")
 			os.Exit(1)
@@ -330,6 +331,7 @@ func setupReconcilersAndWebhooks(ctx context.Context, mgr ctrl.Manager, awsServi
 			ExternalResourceGC:           externalResourceGC,
 			AlternativeGCStrategy:        alternativeGCStrategy,
 			TagUnmanagedNetworkResources: feature.Gates.Enabled(feature.TagUnmanagedNetworkResources),
+			MaxWaitActiveUpdateDelete:    maxWaitActiveUpdateDelete,
 		}).SetupWithManager(ctx, mgr, controller.Options{MaxConcurrentReconciles: awsClusterConcurrency, RecoverPanic: ptr.To[bool](true)}); err != nil {
 			setupLog.Error(err, "unable to create controller", "controller", "AWSCluster")
 			os.Exit(1)
diff --git a/pkg/cloud/converters/eks.go b/pkg/cloud/converters/eks.go
index 254ad7709..fbb35c67c 100644
--- a/pkg/cloud/converters/eks.go
+++ b/pkg/cloud/converters/eks.go
@@ -226,10 +226,38 @@ func AMITypeToSDK(amiType expinfrav1.ManagedMachineAMIType) ekstypes.AMITypes {
 		return ekstypes.AMITypesAl2X8664Gpu
 	case expinfrav1.Al2Arm64:
 		return ekstypes.AMITypesAl2Arm64
+	case expinfrav1.Custom:
+		return ekstypes.AMITypesCustom
+	case expinfrav1.BottleRocketArm64:
+		return ekstypes.AMITypesBottlerocketArm64
+	case expinfrav1.BottleRocketx86_64:
+		return ekstypes.AMITypesBottlerocketX8664
+	case expinfrav1.BottleRocketArm64Fips:
+		return ekstypes.AMITypesBottlerocketArm64Fips
+	case expinfrav1.BottleRocketx86_64Fips:
+		return ekstypes.AMITypesBottlerocketX8664Fips
+	case expinfrav1.BottleRocketArm64Nvidia:
+		return ekstypes.AMITypesBottlerocketArm64Nvidia
+	case expinfrav1.BottleRocketx86_64Nvidia:
+		return ekstypes.AMITypesBottlerocketX8664Nvidia
+	case expinfrav1.WindowsCore2019x86_64:
+		return ekstypes.AMITypesWindowsCore2019X8664
+	case expinfrav1.WindowsFull2019x86_64:
+		return ekstypes.AMITypesWindowsFull2019X8664
+	case expinfrav1.WindowsCore2022x86_64:
+		return ekstypes.AMITypesWindowsCore2022X8664
+	case expinfrav1.WindowsFull2022x86_64:
+		return ekstypes.AMITypesWindowsFull2022X8664
 	case expinfrav1.Al2023Arm64:
 		return ekstypes.AMITypesAl2023Arm64Standard
 	case expinfrav1.Al2023x86_64:
 		return ekstypes.AMITypesAl2023X8664Standard
+	case expinfrav1.Al2023x86_64Neuron:
+		return ekstypes.AMITypesAl2023X8664Neuron
+	case expinfrav1.Al2023x86_64Nvidia:
+		return ekstypes.AMITypesAl2023X8664Nvidia
+	case expinfrav1.Al2023Arm64Nvidia:
+		return ekstypes.AMITypesAl2023Arm64Nvidia
 	default:
 		return ekstypes.AMITypesCustom
 	}
diff --git a/pkg/cloud/converters/tags.go b/pkg/cloud/converters/tags.go
index fd85b4282..0b2284ed4 100644
--- a/pkg/cloud/converters/tags.go
+++ b/pkg/cloud/converters/tags.go
@@ -21,12 +21,12 @@ import (
 	"strings"
 
 	autoscalingtypes "github.com/aws/aws-sdk-go-v2/service/autoscaling/types"
+	elbtypes "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing/types"
+	elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types"
 	iamtypes "github.com/aws/aws-sdk-go-v2/service/iam/types"
 	ssmtypes "github.com/aws/aws-sdk-go-v2/service/ssm/types"
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/elb"
-	"github.com/aws/aws-sdk-go/service/elbv2"
 	"github.com/aws/aws-sdk-go/service/secretsmanager"
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
@@ -89,8 +89,8 @@ func MapToSSMTags(tags infrav1.Tags) []ssmtypes.Tag {
 	return result
 }
 
-// ELBTagsToMap converts a []*elb.Tag into a infrav1.Tags.
-func ELBTagsToMap(src []*elb.Tag) infrav1.Tags {
+// ELBTagsToMap converts a []elbtypes.Tag into a infrav1.Tags.
+func ELBTagsToMap(src []elbtypes.Tag) infrav1.Tags {
 	tags := make(infrav1.Tags, len(src))
 
 	for _, t := range src {
@@ -100,8 +100,8 @@ func ELBTagsToMap(src []*elb.Tag) infrav1.Tags {
 	return tags
 }
 
-// V2TagsToMap converts a []*elbv2.Tag into a infrav1.Tags.
-func V2TagsToMap(src []*elbv2.Tag) infrav1.Tags {
+// V2TagsToMap converts a []elbv2types.Tag into a infrav1.Tags.
+func V2TagsToMap(src []elbv2types.Tag) infrav1.Tags {
 	tags := make(infrav1.Tags, len(src))
 
 	for _, t := range src {
@@ -111,12 +111,12 @@ func V2TagsToMap(src []*elbv2.Tag) infrav1.Tags {
 	return tags
 }
 
-// MapToELBTags converts a infrav1.Tags to a []*elb.Tag.
-func MapToELBTags(src infrav1.Tags) []*elb.Tag {
-	tags := make([]*elb.Tag, 0, len(src))
+// MapToELBTags converts a infrav1.Tags to a []elbtypes.Tag.
+func MapToELBTags(src infrav1.Tags) []elbtypes.Tag {
+	tags := make([]elbtypes.Tag, 0, len(src))
 
 	for k, v := range src {
-		tag := &elb.Tag{
+		tag := elbtypes.Tag{
 			Key:   aws.String(k),
 			Value: aws.String(v),
 		}
@@ -130,12 +130,12 @@ func MapToELBTags(src infrav1.Tags) []*elb.Tag {
 	return tags
 }
 
-// MapToV2Tags converts a infrav1.Tags to a []*elbv2.Tag.
-func MapToV2Tags(src infrav1.Tags) []*elbv2.Tag {
-	tags := make([]*elbv2.Tag, 0, len(src))
+// MapToV2Tags converts a infrav1.Tags to a []*elbv2types.Tag.
+func MapToV2Tags(src infrav1.Tags) []elbv2types.Tag {
+	tags := make([]elbv2types.Tag, 0, len(src))
 
 	for k, v := range src {
-		tag := &elbv2.Tag{
+		tag := elbv2types.Tag{
 			Key:   aws.String(k),
 			Value: aws.String(v),
 		}
diff --git a/pkg/cloud/endpointsv2/endpoints.go b/pkg/cloud/endpointsv2/endpoints.go
index c061cd653..7f3cab14a 100644
--- a/pkg/cloud/endpointsv2/endpoints.go
+++ b/pkg/cloud/endpointsv2/endpoints.go
@@ -24,7 +24,12 @@ import (
 	"strings"
 
 	"github.com/aws/aws-sdk-go-v2/service/eks"
+	elb "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing"
+	elbv2 "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2"
+	"github.com/aws/aws-sdk-go-v2/service/eventbridge"
+	rgapi "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi"
 	"github.com/aws/aws-sdk-go-v2/service/s3"
+	"github.com/aws/aws-sdk-go-v2/service/sqs"
 	"github.com/aws/aws-sdk-go-v2/service/ssm"
 	smithyendpoints "github.com/aws/smithy-go/endpoints"
 
@@ -122,6 +127,116 @@ func (s *S3EndpointResolver) ResolveEndpoint(ctx context.Context, params s3.Endp
 	return s3.NewDefaultEndpointResolverV2().ResolveEndpoint(ctx, params)
 }
 
+// ELBEndpointResolver implements EndpointResolverV2 interface for ELB.
+type ELBEndpointResolver struct {
+	*MultiServiceEndpointResolver
+}
+
+// ResolveEndpoint for ELB.
+func (s *ELBEndpointResolver) ResolveEndpoint(ctx context.Context, params elb.EndpointParameters) (smithyendpoints.Endpoint, error) {
+	// If custom endpoint not found, return default endpoint for the service
+	log := logger.FromContext(ctx)
+	endpoint, ok := s.endpoints[elb.ServiceID]
+
+	if !ok {
+		log.Debug("Custom endpoint not found, using default endpoint")
+		return elb.NewDefaultEndpointResolverV2().ResolveEndpoint(ctx, params)
+	}
+
+	log.Debug("Custom endpoint found, using custom endpoint", "endpoint", endpoint.URL)
+	params.Endpoint = &endpoint.URL
+	params.Region = &endpoint.SigningRegion
+	return elb.NewDefaultEndpointResolverV2().ResolveEndpoint(ctx, params)
+}
+
+// ELBV2EndpointResolver implements EndpointResolverV2 interface for ELBV2.
+type ELBV2EndpointResolver struct {
+	*MultiServiceEndpointResolver
+}
+
+// ResolveEndpoint for ELBV2.
+func (s *ELBV2EndpointResolver) ResolveEndpoint(ctx context.Context, params elbv2.EndpointParameters) (smithyendpoints.Endpoint, error) {
+	// If custom endpoint not found, return default endpoint for the service
+	log := logger.FromContext(ctx)
+	endpoint, ok := s.endpoints[elbv2.ServiceID]
+
+	if !ok {
+		log.Debug("Custom endpoint not found, using default endpoint")
+		return elbv2.NewDefaultEndpointResolverV2().ResolveEndpoint(ctx, params)
+	}
+
+	log.Debug("Custom endpoint found, using custom endpoint", "endpoint", endpoint.URL)
+	params.Endpoint = &endpoint.URL
+	params.Region = &endpoint.SigningRegion
+	return elbv2.NewDefaultEndpointResolverV2().ResolveEndpoint(ctx, params)
+}
+
+// RGAPIEndpointResolver implements EndpointResolverV2 interface for RGAPI.
+type RGAPIEndpointResolver struct {
+	*MultiServiceEndpointResolver
+}
+
+// ResolveEndpoint for RGAPI.
+func (s *RGAPIEndpointResolver) ResolveEndpoint(ctx context.Context, params rgapi.EndpointParameters) (smithyendpoints.Endpoint, error) {
+	// If custom endpoint not found, return default endpoint for the service
+	log := logger.FromContext(ctx)
+	endpoint, ok := s.endpoints[rgapi.ServiceID]
+
+	if !ok {
+		log.Debug("Custom endpoint not found, using default endpoint")
+		return rgapi.NewDefaultEndpointResolverV2().ResolveEndpoint(ctx, params)
+	}
+
+	log.Debug("Custom endpoint found, using custom endpoint", "endpoint", endpoint.URL)
+	params.Endpoint = &endpoint.URL
+	params.Region = &endpoint.SigningRegion
+	return rgapi.NewDefaultEndpointResolverV2().ResolveEndpoint(ctx, params)
+}
+
+// SQSEndpointResolver implements EndpointResolverV2 interface for SQS.
+type SQSEndpointResolver struct {
+	*MultiServiceEndpointResolver
+}
+
+// ResolveEndpoint for SQS.
+func (s *SQSEndpointResolver) ResolveEndpoint(ctx context.Context, params sqs.EndpointParameters) (smithyendpoints.Endpoint, error) {
+	// If custom endpoint not found, return default endpoint for the service
+	log := logger.FromContext(ctx)
+	endpoint, ok := s.endpoints[sqs.ServiceID]
+
+	if !ok {
+		log.Debug("Custom endpoint not found, using default endpoint")
+		return sqs.NewDefaultEndpointResolverV2().ResolveEndpoint(ctx, params)
+	}
+
+	log.Debug("Custom endpoint found, using custom endpoint", "endpoint", endpoint.URL)
+	params.Endpoint = &endpoint.URL
+	params.Region = &endpoint.SigningRegion
+	return sqs.NewDefaultEndpointResolverV2().ResolveEndpoint(ctx, params)
+}
+
+// EventBridgeEndpointResolver implements EndpointResolverV2 interface for EventBridge.
+type EventBridgeEndpointResolver struct {
+	*MultiServiceEndpointResolver
+}
+
+// ResolveEndpoint for EventBridge.
+func (s *EventBridgeEndpointResolver) ResolveEndpoint(ctx context.Context, params eventbridge.EndpointParameters) (smithyendpoints.Endpoint, error) {
+	// If custom endpoint not found, return default endpoint for the service
+	log := logger.FromContext(ctx)
+	endpoint, ok := s.endpoints[eventbridge.ServiceID]
+
+	if !ok {
+		log.Debug("Custom endpoint not found, using default endpoint")
+		return eventbridge.NewDefaultEndpointResolverV2().ResolveEndpoint(ctx, params)
+	}
+
+	log.Debug("Custom endpoint found, using custom endpoint", "endpoint", endpoint.URL)
+	params.Endpoint = &endpoint.URL
+	params.Region = &endpoint.SigningRegion
+	return eventbridge.NewDefaultEndpointResolverV2().ResolveEndpoint(ctx, params)
+}
+
 // EKSEndpointResolver implements EndpointResolverV2 interface for EKS.
 type EKSEndpointResolver struct {
 	*MultiServiceEndpointResolver
diff --git a/pkg/cloud/interfaces.go b/pkg/cloud/interfaces.go
index 4cb8e3c91..4fd9be6f0 100644
--- a/pkg/cloud/interfaces.go
+++ b/pkg/cloud/interfaces.go
@@ -18,6 +18,8 @@ limitations under the License.
 package cloud
 
 import (
+	"time"
+
 	awsv2 "github.com/aws/aws-sdk-go-v2/aws"
 	awsclient "github.com/aws/aws-sdk-go/aws/client"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
@@ -89,6 +91,9 @@ type ClusterScoper interface {
 	PatchObject() error
 	// Close closes the current scope persisting the cluster configuration and status.
 	Close() error
+
+	// MaxWaitDuration returns time waiting for operation.
+	MaxWaitDuration() time.Duration
 }
 
 // SessionMetadata knows how to extract the information for managing AWS sessions for a resource.
diff --git a/pkg/cloud/metricsv2/metrics.go b/pkg/cloud/metricsv2/metrics.go
index c8620e3da..82187e02a 100644
--- a/pkg/cloud/metricsv2/metrics.go
+++ b/pkg/cloud/metricsv2/metrics.go
@@ -24,6 +24,7 @@ import (
 	"time"
 
 	awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
+	"github.com/aws/aws-sdk-go-v2/aws/retry"
 	"github.com/aws/smithy-go/middleware"
 	smithyhttp "github.com/aws/smithy-go/transport/http"
 	"github.com/prometheus/client_golang/prometheus"
@@ -100,8 +101,11 @@ func WithMiddlewares(controller string, target runtime.Object) func(stack *middl
 		if err := stack.Finalize.Add(getRequestMetricContextMiddleware(), middleware.Before); err != nil {
 			return fmt.Errorf("failed to add request metric context middleware: %w", err)
 		}
-		if err := stack.Finalize.Insert(getAttemptContextMiddleware(), "Retry", middleware.After); err != nil {
-			return fmt.Errorf("failed to add attempt context middleware: %w", err)
+		// Check if the Default Retry Middleware exists.
+		if _, ok := stack.Finalize.Get((*retry.Attempt)(nil).ID()); ok {
+			if err := stack.Finalize.Insert(getAttemptContextMiddleware(), (*retry.Attempt)(nil).ID(), middleware.After); err != nil {
+				return fmt.Errorf("failed to add attempt context middleware: %w", err)
+			}
 		}
 		return stack.Finalize.Add(getRecordAWSPermissionsIssueMiddleware(target), middleware.After)
 	}
diff --git a/pkg/cloud/scope/clients.go b/pkg/cloud/scope/clients.go
index 882e6e45a..345ef62f4 100644
--- a/pkg/cloud/scope/clients.go
+++ b/pkg/cloud/scope/clients.go
@@ -19,8 +19,11 @@ package scope
 import (
 	"github.com/aws/aws-sdk-go-v2/service/autoscaling"
 	"github.com/aws/aws-sdk-go-v2/service/eks"
+	elb "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing"
+	elbv2 "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2"
 	"github.com/aws/aws-sdk-go-v2/service/eventbridge"
 	"github.com/aws/aws-sdk-go-v2/service/iam"
+	rgapi "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi"
 	"github.com/aws/aws-sdk-go-v2/service/s3"
 	"github.com/aws/aws-sdk-go-v2/service/sqs"
 	"github.com/aws/aws-sdk-go-v2/service/ssm"
@@ -29,12 +32,6 @@ import (
 	"github.com/aws/aws-sdk-go/aws/request"
 	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
-	"github.com/aws/aws-sdk-go/service/elb"
-	"github.com/aws/aws-sdk-go/service/elb/elbiface"
-	"github.com/aws/aws-sdk-go/service/elbv2"
-	"github.com/aws/aws-sdk-go/service/elbv2/elbv2iface"
-	"github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi"
-	"github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi/resourcegroupstaggingapiiface"
 	"github.com/aws/aws-sdk-go/service/secretsmanager"
 	"github.com/aws/aws-sdk-go/service/secretsmanager/secretsmanageriface"
 	"github.com/aws/aws-sdk-go/service/sts"
@@ -46,6 +43,7 @@ import (
 	awslogs "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/logs"
 	awsmetrics "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/metrics"
 	awsmetricsv2 "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/metricsv2"
+	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/throttle"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/logger"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/record"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/version"
@@ -86,34 +84,65 @@ func NewEC2Client(scopeUser cloud.ScopeUsage, session cloud.Session, logger logg
 }
 
 // NewELBClient creates a new ELB API client for a given session.
-func NewELBClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) elbiface.ELBAPI {
-	elbClient := elb.New(session.Session(), aws.NewConfig().WithLogLevel(awslogs.GetAWSLogLevel(logger.GetLogger())).WithLogger(awslogs.NewWrapLogr(logger.GetLogger())))
-	elbClient.Handlers.Build.PushFrontNamed(getUserAgentHandler())
-	elbClient.Handlers.Sign.PushFront(session.ServiceLimiter(elb.ServiceID).LimitRequest)
-	elbClient.Handlers.CompleteAttempt.PushFront(awsmetrics.CaptureRequestMetrics(scopeUser.ControllerName()))
-	elbClient.Handlers.CompleteAttempt.PushFront(session.ServiceLimiter(elb.ServiceID).ReviewResponse)
-	elbClient.Handlers.Complete.PushBack(recordAWSPermissionsIssue(target))
-
-	return elbClient
+func NewELBClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) *elb.Client {
+	cfg := session.SessionV2()
+	multiSvcEndpointResolver := endpointsv2.NewMultiServiceEndpointResolver()
+	endpointResolver := &endpointsv2.ELBEndpointResolver{
+		MultiServiceEndpointResolver: multiSvcEndpointResolver,
+	}
+
+	opts := []func(*elb.Options){
+		func(o *elb.Options) {
+			o.Logger = logger.GetAWSLogger()
+			o.ClientLogMode = awslogs.GetAWSLogLevelV2(logger.GetLogger())
+			o.EndpointResolverV2 = endpointResolver
+		},
+		elb.WithAPIOptions(
+			awsmetricsv2.WithMiddlewares(scopeUser.ControllerName(), target),
+			awsmetricsv2.WithCAPAUserAgentMiddleware(),
+			throttle.WithServiceLimiterMiddleware(session.ServiceLimiter(elb.ServiceID)),
+		),
+	}
+
+	return elb.NewFromConfig(cfg, opts...)
 }
 
 // NewELBv2Client creates a new ELB v2 API client for a given session.
-func NewELBv2Client(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) elbv2iface.ELBV2API {
-	elbClient := elbv2.New(session.Session(), aws.NewConfig().WithLogLevel(awslogs.GetAWSLogLevel(logger.GetLogger())).WithLogger(awslogs.NewWrapLogr(logger.GetLogger())))
-	elbClient.Handlers.Build.PushFrontNamed(getUserAgentHandler())
-	elbClient.Handlers.Sign.PushFront(session.ServiceLimiter(elbv2.ServiceID).LimitRequest)
-	elbClient.Handlers.CompleteAttempt.PushFront(awsmetrics.CaptureRequestMetrics(scopeUser.ControllerName()))
-	elbClient.Handlers.CompleteAttempt.PushFront(session.ServiceLimiter(elbv2.ServiceID).ReviewResponse)
-	elbClient.Handlers.Complete.PushBack(recordAWSPermissionsIssue(target))
-
-	return elbClient
+func NewELBv2Client(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) *elbv2.Client {
+	cfg := session.SessionV2()
+	multiSvcEndpointResolver := endpointsv2.NewMultiServiceEndpointResolver()
+	endpointResolver := &endpointsv2.ELBV2EndpointResolver{
+		MultiServiceEndpointResolver: multiSvcEndpointResolver,
+	}
+
+	opts := []func(*elbv2.Options){
+		func(o *elbv2.Options) {
+			o.Logger = logger.GetAWSLogger()
+			o.ClientLogMode = awslogs.GetAWSLogLevelV2(logger.GetLogger())
+			o.EndpointResolverV2 = endpointResolver
+		},
+		elbv2.WithAPIOptions(
+			awsmetricsv2.WithMiddlewares(scopeUser.ControllerName(), target),
+			awsmetricsv2.WithCAPAUserAgentMiddleware(),
+			throttle.WithServiceLimiterMiddleware(session.ServiceLimiter(elbv2.ServiceID)),
+		),
+	}
+
+	return elbv2.NewFromConfig(cfg, opts...)
 }
 
 // NewEventBridgeClient creates a new EventBridge API client for a given session.
 func NewEventBridgeClient(scopeUser cloud.ScopeUsage, session cloud.Session, target runtime.Object) *eventbridge.Client {
 	cfg := session.SessionV2()
+	multiSvcEndpointResolver := endpointsv2.NewMultiServiceEndpointResolver()
+	endpointResolver := &endpointsv2.EventBridgeEndpointResolver{
+		MultiServiceEndpointResolver: multiSvcEndpointResolver,
+	}
 
 	opts := []func(*eventbridge.Options){
+		func(o *eventbridge.Options) {
+			o.EndpointResolverV2 = endpointResolver
+		},
 		eventbridge.WithAPIOptions(
 			awsmetricsv2.WithMiddlewares(scopeUser.ControllerName(), target),
 			awsmetricsv2.WithCAPAUserAgentMiddleware(),
@@ -126,8 +155,15 @@ func NewEventBridgeClient(scopeUser cloud.ScopeUsage, session cloud.Session, tar
 // NewSQSClient creates a new SQS API client for a given session.
 func NewSQSClient(scopeUser cloud.ScopeUsage, session cloud.Session, target runtime.Object) *sqs.Client {
 	cfg := session.SessionV2()
+	multiSvcEndpointResolver := endpointsv2.NewMultiServiceEndpointResolver()
+	endpointResolver := &endpointsv2.SQSEndpointResolver{
+		MultiServiceEndpointResolver: multiSvcEndpointResolver,
+	}
 
 	opts := []func(*sqs.Options){
+		func(o *sqs.Options) {
+			o.EndpointResolverV2 = endpointResolver
+		},
 		sqs.WithAPIOptions(
 			awsmetricsv2.WithMiddlewares(scopeUser.ControllerName(), target),
 			awsmetricsv2.WithCAPAUserAgentMiddleware(),
@@ -140,8 +176,15 @@ func NewSQSClient(scopeUser cloud.ScopeUsage, session cloud.Session, target runt
 // NewGlobalSQSClient for creating a new SQS API client that isn't tied to a cluster.
 func NewGlobalSQSClient(scopeUser cloud.ScopeUsage, session cloud.Session) *sqs.Client {
 	cfg := session.SessionV2()
+	multiSvcEndpointResolver := endpointsv2.NewMultiServiceEndpointResolver()
+	endpointResolver := &endpointsv2.SQSEndpointResolver{
+		MultiServiceEndpointResolver: multiSvcEndpointResolver,
+	}
 
 	opts := []func(*sqs.Options){
+		func(o *sqs.Options) {
+			o.EndpointResolverV2 = endpointResolver
+		},
 		sqs.WithAPIOptions(
 			awsmetricsv2.WithRequestMetricContextMiddleware(),
 			awsmetricsv2.WithCAPAUserAgentMiddleware(),
@@ -152,15 +195,23 @@ func NewGlobalSQSClient(scopeUser cloud.ScopeUsage, session cloud.Session) *sqs.
 }
 
 // NewResourgeTaggingClient creates a new Resource Tagging API client for a given session.
-func NewResourgeTaggingClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) resourcegroupstaggingapiiface.ResourceGroupsTaggingAPIAPI {
-	resourceTagging := resourcegroupstaggingapi.New(session.Session(), aws.NewConfig().WithLogLevel(awslogs.GetAWSLogLevel(logger.GetLogger())).WithLogger(awslogs.NewWrapLogr(logger.GetLogger())))
-	resourceTagging.Handlers.Build.PushFrontNamed(getUserAgentHandler())
-	resourceTagging.Handlers.Sign.PushFront(session.ServiceLimiter(resourceTagging.ServiceID).LimitRequest)
-	resourceTagging.Handlers.CompleteAttempt.PushFront(awsmetrics.CaptureRequestMetrics(scopeUser.ControllerName()))
-	resourceTagging.Handlers.CompleteAttempt.PushFront(session.ServiceLimiter(resourceTagging.ServiceID).ReviewResponse)
-	resourceTagging.Handlers.Complete.PushBack(recordAWSPermissionsIssue(target))
-
-	return resourceTagging
+func NewResourgeTaggingClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) *rgapi.Client {
+	cfg := session.SessionV2()
+	multiSvcEndpointResolver := endpointsv2.NewMultiServiceEndpointResolver()
+	endpointResolver := &endpointsv2.RGAPIEndpointResolver{
+		MultiServiceEndpointResolver: multiSvcEndpointResolver,
+	}
+
+	opts := []func(*rgapi.Options){
+		func(o *rgapi.Options) {
+			o.Logger = logger.GetAWSLogger()
+			o.ClientLogMode = awslogs.GetAWSLogLevelV2(logger.GetLogger())
+			o.EndpointResolverV2 = endpointResolver
+		},
+		rgapi.WithAPIOptions(awsmetricsv2.WithMiddlewares(scopeUser.ControllerName(), target), awsmetricsv2.WithCAPAUserAgentMiddleware()),
+	}
+
+	return rgapi.NewFromConfig(cfg, opts...)
 }
 
 // NewSecretsManagerClient creates a new Secrets API client for a given session..
@@ -283,7 +334,7 @@ func getUserAgentHandler() request.NamedHandler {
 type AWSClients struct {
 	ASG             autoscaling.Client
 	EC2             ec2iface.EC2API
-	ELB             elbiface.ELBAPI
+	ELB             elb.Client
 	SecretsManager  secretsmanageriface.SecretsManagerAPI
-	ResourceTagging resourcegroupstaggingapiiface.ResourceGroupsTaggingAPIAPI
+	ResourceTagging rgapi.Client
 }
diff --git a/pkg/cloud/scope/cluster.go b/pkg/cloud/scope/cluster.go
index 0da00442b..5bb9873d9 100644
--- a/pkg/cloud/scope/cluster.go
+++ b/pkg/cloud/scope/cluster.go
@@ -19,6 +19,7 @@ package scope
 import (
 	"context"
 	"fmt"
+	"time"
 
 	awsv2 "github.com/aws/aws-sdk-go-v2/aws"
 	awsclient "github.com/aws/aws-sdk-go/aws/client"
@@ -48,6 +49,7 @@ type ClusterScopeParams struct {
 	Session                      awsclient.ConfigProvider
 	SessionV2                    awsv2.Config
 	TagUnmanagedNetworkResources bool
+	MaxWaitActiveUpdateDelete    time.Duration
 }
 
 // NewClusterScope creates a new Scope from the supplied parameters.
@@ -72,6 +74,7 @@ func NewClusterScope(params ClusterScopeParams) (*ClusterScope, error) {
 		AWSCluster:                   params.AWSCluster,
 		controllerName:               params.ControllerName,
 		tagUnmanagedNetworkResources: params.TagUnmanagedNetworkResources,
+		maxWaitActiveUpdateDelete:    params.MaxWaitActiveUpdateDelete,
 	}
 
 	session, serviceLimiters, err := sessionForClusterWithRegion(params.Client, clusterScope, params.AWSCluster.Spec.Region, params.Endpoints, params.Logger)
@@ -114,6 +117,7 @@ type ClusterScope struct {
 	controllerName    string
 
 	tagUnmanagedNetworkResources bool
+	maxWaitActiveUpdateDelete    time.Duration
 }
 
 // Network returns the cluster network object.
@@ -385,6 +389,11 @@ func (s *ClusterScope) TagUnmanagedNetworkResources() bool {
 	return s.tagUnmanagedNetworkResources
 }
 
+// MaxWaitDuration returns time waiting for operation.
+func (s *ClusterScope) MaxWaitDuration() time.Duration {
+	return s.maxWaitActiveUpdateDelete
+}
+
 // SetBastionInstance sets the bastion instance in the status of the cluster.
 func (s *ClusterScope) SetBastionInstance(instance *infrav1.Instance) {
 	s.AWSCluster.Status.Bastion = instance
diff --git a/pkg/cloud/scope/managedcontrolplane.go b/pkg/cloud/scope/managedcontrolplane.go
index f01c8a22f..f6335c381 100644
--- a/pkg/cloud/scope/managedcontrolplane.go
+++ b/pkg/cloud/scope/managedcontrolplane.go
@@ -513,3 +513,8 @@ func (s *ManagedControlPlaneScope) UnstructuredControlPlane() (*unstructured.Uns
 func (s *ManagedControlPlaneScope) NodePortIngressRuleCidrBlocks() []string {
 	return nil
 }
+
+// MaxWaitDuration returns time waiting for operation.
+func (s *ManagedControlPlaneScope) MaxWaitDuration() time.Duration {
+	return s.MaxWaitActiveUpdateDelete
+}
diff --git a/pkg/cloud/scope/session.go b/pkg/cloud/scope/session.go
index 534305a6a..163404aa9 100644
--- a/pkg/cloud/scope/session.go
+++ b/pkg/cloud/scope/session.go
@@ -23,15 +23,15 @@ import (
 
 	awsv2 "github.com/aws/aws-sdk-go-v2/aws"
 	"github.com/aws/aws-sdk-go-v2/config"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	elb "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing"
+	elbv2 "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2"
+	"github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi"
+	"github.com/aws/aws-sdk-go-v2/service/secretsmanager"
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/credentials"
 	"github.com/aws/aws-sdk-go/aws/endpoints"
 	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/elb"
-	"github.com/aws/aws-sdk-go/service/elbv2"
-	"github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi"
-	"github.com/aws/aws-sdk-go/service/secretsmanager"
 	"github.com/google/go-cmp/cmp"
 	"github.com/pkg/errors"
 	corev1 "k8s.io/api/core/v1"
diff --git a/pkg/cloud/services/elb/eip.go b/pkg/cloud/services/elb/eip.go
index 27c9ebee7..d83cee9ac 100644
--- a/pkg/cloud/services/elb/eip.go
+++ b/pkg/cloud/services/elb/eip.go
@@ -3,8 +3,9 @@ package elb
 import (
 	"fmt"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/elbv2"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	elbv2 "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2"
+	elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types"
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
 )
@@ -22,11 +23,8 @@ func (s *Service) allocatePublicIpv4AddressFromByoIPPool(input *elbv2.CreateLoad
 	}
 
 	// Only NLB is supported
-	if input.Type == nil {
-		return fmt.Errorf("PublicIpv4Pool is supported only when the Load Balancer type is %q", elbv2.LoadBalancerTypeEnumNetwork)
-	}
-	if *input.Type != string(elbv2.LoadBalancerTypeEnumNetwork) {
-		return fmt.Errorf("PublicIpv4Pool is not supported with Load Balancer type %s. Use Network Load Balancer instead", *input.Type)
+	if input.Type != elbv2types.LoadBalancerTypeEnumNetwork {
+		return fmt.Errorf("PublicIpv4Pool is not supported with Load Balancer type %s. Use Network Load Balancer instead", input.Type)
 	}
 
 	// Custom SubnetMappings should not be defined or overridden by user-defined mapping.
@@ -42,14 +40,14 @@ func (s *Service) allocatePublicIpv4AddressFromByoIPPool(input *elbv2.CreateLoad
 		return fmt.Errorf("number of allocated EIP addresses (%d) from pool %q must match with the subnet count (%d)", len(eips), *s.scope.VPC().GetPublicIpv4Pool(), len(input.Subnets))
 	}
 	for cnt, sb := range input.Subnets {
-		input.SubnetMappings = append(input.SubnetMappings, &elbv2.SubnetMapping{
-			SubnetId:     aws.String(*sb),
+		input.SubnetMappings = append(input.SubnetMappings, elbv2types.SubnetMapping{
+			SubnetId:     aws.String(sb),
 			AllocationId: aws.String(eips[cnt]),
 		})
 	}
 	// Subnets and SubnetMappings are mutual exclusive. Cleaning Subnets when BYO IP is defined,
 	// and SubnetMappings are mounted.
-	input.Subnets = []*string{}
+	input.Subnets = []string{}
 
 	return nil
 }
diff --git a/pkg/cloud/services/elb/errors.go b/pkg/cloud/services/elb/errors.go
index 28a7c4a0b..60a04e43b 100644
--- a/pkg/cloud/services/elb/errors.go
+++ b/pkg/cloud/services/elb/errors.go
@@ -19,8 +19,7 @@ package elb
 import (
 	"net/http"
 
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/service/elb"
+	elbtypes "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing/types"
 	"github.com/pkg/errors"
 
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/awserrors"
@@ -71,7 +70,7 @@ func IsNotFound(err error) bool {
 		return true
 	}
 	if code, ok := awserrors.Code(errors.Cause(err)); ok {
-		if code == elb.ErrCodeAccessPointNotFoundException {
+		if code == (&elbtypes.AccessPointNotFoundException{}).ErrorCode() {
 			return true
 		}
 	}
@@ -93,12 +92,6 @@ func IsConflict(err error) bool {
 	return ReasonForError(err) == http.StatusConflict
 }
 
-// IsSDKError returns true if the error is of type awserr.Error.
-func IsSDKError(err error) (ok bool) {
-	_, ok = errors.Cause(err).(awserr.Error)
-	return
-}
-
 // IsInstanceNotRunning returns true if the error was created by NewInstanceNotRunning.
 func IsInstanceNotRunning(err error) (ok bool) {
 	return ReasonForError(err) == http.StatusTooEarly
diff --git a/pkg/cloud/services/elb/loadbalancer.go b/pkg/cloud/services/elb/loadbalancer.go
index c2265012a..25aefa9b4 100644
--- a/pkg/cloud/services/elb/loadbalancer.go
+++ b/pkg/cloud/services/elb/loadbalancer.go
@@ -23,13 +23,15 @@ import (
 	"strings"
 	"time"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/arn"
-	"github.com/aws/aws-sdk-go/aws/awserr"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/aws/arn"
+	elb "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing"
+	elbtypes "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing/types"
+	elbv2 "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2"
+	elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types"
+	rgapi "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi"
+	rgapitypes "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi/types"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/elb"
-	"github.com/aws/aws-sdk-go/service/elbv2"
-	rgapi "github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi"
 	"github.com/google/go-cmp/cmp"
 	"github.com/pkg/errors"
 	kerrors "k8s.io/apimachinery/pkg/util/errors"
@@ -70,7 +72,7 @@ var cantAttachSGToNLBRegions = sets.New("us-iso-east-1", "us-iso-west-1", "us-is
 type lbReconciler func() error
 
 // ReconcileLoadbalancers reconciles the load balancers for the given cluster.
-func (s *Service) ReconcileLoadbalancers() error {
+func (s *Service) ReconcileLoadbalancers(ctx context.Context) error {
 	s.scope.Debug("Reconciling load balancers")
 
 	var errs []error
@@ -89,14 +91,14 @@ func (s *Service) ReconcileLoadbalancers() error {
 		}
 		switch lbSpec.LoadBalancerType {
 		case infrav1.LoadBalancerTypeClassic:
-			reconciler, err := s.getOrCreateClassicLoadBalancer()
+			reconciler, err := s.getOrCreateClassicLoadBalancer(ctx)
 			if err != nil {
 				errs = append(errs, err)
 			} else {
 				lbReconcilers = append(lbReconcilers, reconciler)
 			}
 		case infrav1.LoadBalancerTypeNLB, infrav1.LoadBalancerTypeALB, infrav1.LoadBalancerTypeELB:
-			reconciler, err := s.getOrCreateV2LB(lbSpec)
+			reconciler, err := s.getOrCreateV2LB(ctx, lbSpec)
 			if err != nil {
 				errs = append(errs, err)
 			} else {
@@ -120,24 +122,24 @@ func (s *Service) ReconcileLoadbalancers() error {
 // getOrCreateV2LB gets an existing load balancer, or creates a new one if it does not exist.
 // It also takes care of generating unique names across namespaces by appending the namespace to the name.
 // It returns a function that reconciles the load balancer.
-func (s *Service) getOrCreateV2LB(lbSpec *infrav1.AWSLoadBalancerSpec) (lbReconciler, error) {
+func (s *Service) getOrCreateV2LB(ctx context.Context, lbSpec *infrav1.AWSLoadBalancerSpec) (lbReconciler, error) {
 	name, err := LBName(s.scope, lbSpec)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to get control plane load balancer name")
 	}
 
 	// Get default api server spec.
-	desiredLB, err := s.getAPIServerLBSpec(name, lbSpec)
+	desiredLB, err := s.getAPIServerLBSpec(ctx, name, lbSpec)
 	if err != nil {
 		return nil, err
 	}
-	lb, err := s.describeLB(name, lbSpec)
+	lb, err := s.describeLB(ctx, name, lbSpec)
 	switch {
 	case IsNotFound(err) && s.scope.ControlPlaneEndpoint().IsValid():
 		// if elb is not found and owner cluster ControlPlaneEndpoint is already populated, then we should not recreate the elb.
 		return nil, errors.Wrapf(err, "no loadbalancer exists for the AWSCluster %s, the cluster has become unrecoverable and should be deleted manually", s.scope.InfraClusterName())
 	case IsNotFound(err):
-		lb, err = s.createLB(desiredLB, lbSpec)
+		lb, err = s.createLB(ctx, desiredLB, lbSpec)
 		if err != nil {
 			s.scope.Error(err, "failed to create LB")
 			return nil, err
@@ -150,17 +152,17 @@ func (s *Service) getOrCreateV2LB(lbSpec *infrav1.AWSLoadBalancerSpec) (lbReconc
 	}
 
 	return func() error {
-		return s.reconcileV2LB(lb, desiredLB, lbSpec)
+		return s.reconcileV2LB(ctx, lb, desiredLB, lbSpec)
 	}, nil
 }
 
-func (s *Service) reconcileV2LB(lb *infrav1.LoadBalancer, desiredLB *infrav1.LoadBalancer, lbSpec *infrav1.AWSLoadBalancerSpec) error {
+func (s *Service) reconcileV2LB(ctx context.Context, lb *infrav1.LoadBalancer, desiredLB *infrav1.LoadBalancer, lbSpec *infrav1.AWSLoadBalancerSpec) error {
 	wReq := &elbv2.DescribeLoadBalancersInput{
-		LoadBalancerArns: aws.StringSlice([]string{lb.ARN}),
+		LoadBalancerArns: []string{lb.ARN},
 	}
 	s.scope.Debug("Waiting for LB to become active", "api-server-lb-name", lb.Name)
 	waitStart := time.Now()
-	if err := s.ELBV2Client.WaitUntilLoadBalancerAvailableWithContext(context.TODO(), wReq); err != nil {
+	if err := s.ELBV2Client.WaitUntilLoadBalancerAvailable(ctx, wReq, s.scope.MaxWaitDuration()); err != nil {
 		s.scope.Error(err, "failed to wait for LB to become available", "time", time.Since(waitStart))
 		return err
 	}
@@ -171,27 +173,27 @@ func (s *Service) reconcileV2LB(lb *infrav1.LoadBalancer, desiredLB *infrav1.Loa
 	if lb.IsManaged(s.scope.Name()) {
 		// Reconcile the target groups and listeners from the spec and the ones currently attached to the load balancer.
 		// Pass in the ARN that AWS gave us, as well as the rest of the desired specification.
-		_, _, err := s.reconcileTargetGroupsAndListeners(lb.ARN, desiredLB, lbSpec)
+		_, _, err := s.reconcileTargetGroupsAndListeners(ctx, lb.ARN, desiredLB, lbSpec)
 		if err != nil {
 			return errors.Wrapf(err, "failed to create target groups/listeners for load balancer %q", lb.Name)
 		}
 
 		if !cmp.Equal(desiredLB.ELBAttributes, lb.ELBAttributes) {
-			if err := s.configureLBAttributes(lb.ARN, desiredLB.ELBAttributes); err != nil {
+			if err := s.configureLBAttributes(ctx, lb.ARN, desiredLB.ELBAttributes); err != nil {
 				return err
 			}
 		}
 
-		if err := s.reconcileV2LBTags(lb, desiredLB.Tags); err != nil {
+		if err := s.reconcileV2LBTags(ctx, lb, desiredLB.Tags); err != nil {
 			return errors.Wrapf(err, "failed to reconcile tags for apiserver load balancer %q", lb.Name)
 		}
 
 		// Reconcile the subnets and availability zones from the desiredLB
 		// and the ones currently attached to the load balancer.
 		if len(lb.SubnetIDs) != len(desiredLB.SubnetIDs) {
-			_, err := s.ELBV2Client.SetSubnets(&elbv2.SetSubnetsInput{
+			_, err := s.ELBV2Client.SetSubnets(ctx, &elbv2.SetSubnetsInput{
 				LoadBalancerArn: &lb.ARN,
-				Subnets:         aws.StringSlice(desiredLB.SubnetIDs),
+				Subnets:         desiredLB.SubnetIDs,
 			})
 			if err != nil {
 				return errors.Wrapf(err, "failed to set subnets for apiserver load balancer '%s'", lb.Name)
@@ -203,9 +205,9 @@ func (s *Service) reconcileV2LB(lb *infrav1.LoadBalancer, desiredLB *infrav1.Loa
 
 		// Reconcile the security groups from the desiredLB and the ones currently attached to the load balancer
 		if shouldReconcileSGs(s.scope, lb, desiredLB.SecurityGroupIDs) {
-			_, err := s.ELBV2Client.SetSecurityGroups(&elbv2.SetSecurityGroupsInput{
+			_, err := s.ELBV2Client.SetSecurityGroups(ctx, &elbv2.SetSecurityGroupsInput{
 				LoadBalancerArn: &lb.ARN,
-				SecurityGroups:  aws.StringSlice(desiredLB.SecurityGroupIDs),
+				SecurityGroups:  desiredLB.SecurityGroupIDs,
 			})
 			if err != nil {
 				return errors.Wrapf(err, "failed to apply security groups to load balancer %q", lb.Name)
@@ -304,7 +306,7 @@ func (s *Service) getAdditionalTargetGroupHealthCheck(ln infrav1.AdditionalListe
 	return healthCheck
 }
 
-func (s *Service) getAPIServerLBSpec(elbName string, lbSpec *infrav1.AWSLoadBalancerSpec) (*infrav1.LoadBalancer, error) {
+func (s *Service) getAPIServerLBSpec(ctx context.Context, elbName string, lbSpec *infrav1.AWSLoadBalancerSpec) (*infrav1.LoadBalancer, error) {
 	var securityGroupIDs []string
 	if lbSpec != nil {
 		securityGroupIDs = append(securityGroupIDs, lbSpec.AdditionalSecurityGroups...)
@@ -387,7 +389,7 @@ func (s *Service) getAPIServerLBSpec(elbName string, lbSpec *infrav1.AWSLoadBala
 		input := &ec2.DescribeSubnetsInput{
 			SubnetIds: aws.StringSlice(lbSpec.Subnets),
 		}
-		out, err := s.EC2Client.DescribeSubnetsWithContext(context.TODO(), input)
+		out, err := s.EC2Client.DescribeSubnetsWithContext(ctx, input)
 		if err != nil {
 			return nil, err
 		}
@@ -421,27 +423,28 @@ func (s *Service) getAPIServerLBSpec(elbName string, lbSpec *infrav1.AWSLoadBala
 	return res, nil
 }
 
-func (s *Service) createLB(spec *infrav1.LoadBalancer, lbSpec *infrav1.AWSLoadBalancerSpec) (*infrav1.LoadBalancer, error) {
-	var t *string
+func (s *Service) createLB(ctx context.Context, spec *infrav1.LoadBalancer, lbSpec *infrav1.AWSLoadBalancerSpec) (*infrav1.LoadBalancer, error) {
+	var t elbv2types.LoadBalancerTypeEnum
+
 	switch lbSpec.LoadBalancerType {
 	case infrav1.LoadBalancerTypeNLB:
-		t = aws.String(elbv2.LoadBalancerTypeEnumNetwork)
+		t = elbv2types.LoadBalancerTypeEnumNetwork
 	case infrav1.LoadBalancerTypeALB:
-		t = aws.String(elbv2.LoadBalancerTypeEnumApplication)
+		t = elbv2types.LoadBalancerTypeEnumApplication
 	case infrav1.LoadBalancerTypeELB:
-		t = aws.String(elbv2.LoadBalancerTypeEnumGateway)
+		t = elbv2types.LoadBalancerTypeEnumGateway
 	}
 	input := &elbv2.CreateLoadBalancerInput{
 		Name:           aws.String(spec.Name),
-		Subnets:        aws.StringSlice(spec.SubnetIDs),
+		Subnets:        spec.SubnetIDs,
 		Tags:           converters.MapToV2Tags(spec.Tags),
-		Scheme:         aws.String(string(spec.Scheme)),
-		SecurityGroups: aws.StringSlice(spec.SecurityGroupIDs),
+		Scheme:         SchemeToSDKScheme(spec.Scheme),
+		SecurityGroups: spec.SecurityGroupIDs,
 		Type:           t,
 	}
 
 	if s.scope.VPC().IsIPv6Enabled() {
-		input.IpAddressType = aws.String("dualstack")
+		input.IpAddressType = elbv2types.IpAddressTypeDualstack
 	}
 
 	// TODO: remove when security groups on NLBs is supported in all regions.
@@ -462,10 +465,10 @@ func (s *Service) createLB(spec *infrav1.LoadBalancer, lbSpec *infrav1.AWSLoadBa
 	// Subnets and SubnetMappings are mutually exclusive. SubnetMappings is set by users or when
 	// BYO Public IPv4 Pool is set.
 	if len(input.SubnetMappings) == 0 {
-		input.Subnets = aws.StringSlice(spec.SubnetIDs)
+		input.Subnets = spec.SubnetIDs
 	}
 
-	out, err := s.ELBV2Client.CreateLoadBalancer(input)
+	out, err := s.ELBV2Client.CreateLoadBalancer(ctx, input)
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed to create load balancer: %v", spec)
 	}
@@ -494,24 +497,21 @@ func (s *Service) createLB(spec *infrav1.LoadBalancer, lbSpec *infrav1.AWSLoadBa
 	return res, nil
 }
 
-func (s *Service) describeLB(name string, lbSpec *infrav1.AWSLoadBalancerSpec) (*infrav1.LoadBalancer, error) {
+func (s *Service) describeLB(ctx context.Context, name string, lbSpec *infrav1.AWSLoadBalancerSpec) (*infrav1.LoadBalancer, error) {
 	input := &elbv2.DescribeLoadBalancersInput{
-		Names: aws.StringSlice([]string{name}),
+		Names: []string{name},
 	}
 
-	out, err := s.ELBV2Client.DescribeLoadBalancers(input)
-	if err != nil {
-		if aerr, ok := err.(awserr.Error); ok {
-			switch aerr.Code() {
-			case elb.ErrCodeAccessPointNotFoundException:
-				return nil, NewNotFound(fmt.Sprintf("no load balancer found with name: %q", name))
-			case elb.ErrCodeDependencyThrottleException:
-				return nil, errors.Wrap(err, "too many requests made to the ELB service")
-			default:
-				return nil, errors.Wrap(err, "unexpected aws error")
-			}
-		} else {
-			return nil, errors.Wrapf(err, "failed to describe load balancer: %s", name)
+	out, err := s.ELBV2Client.DescribeLoadBalancers(ctx, input)
+	smithyErr := awserrors.ParseSmithyError(err)
+	if smithyErr != nil {
+		switch smithyErr.ErrorCode() {
+		case (&elbtypes.AccessPointNotFoundException{}).ErrorCode():
+			return nil, NewNotFound(fmt.Sprintf("no load balancer found with name: %q", name))
+		case (&elbtypes.DependencyThrottleException{}).ErrorCode():
+			return nil, errors.Wrap(err, "too many requests made to the ELB service")
+		default:
+			return nil, errors.Wrap(err, "unexpected aws error")
 		}
 	}
 
@@ -529,20 +529,20 @@ func (s *Service) describeLB(name string, lbSpec *infrav1.AWSLoadBalancerSpec) (
 
 	if lbSpec != nil &&
 		lbSpec.Scheme != nil &&
-		string(*lbSpec.Scheme) != aws.StringValue(out.LoadBalancers[0].Scheme) {
+		SchemeToSDKScheme(*lbSpec.Scheme) != out.LoadBalancers[0].Scheme {
 		return nil, errors.Errorf(
 			"Load balancer names must be unique within a region: %q Load balancer already exists in this region with a different scheme %q",
-			name, *out.LoadBalancers[0].Scheme)
+			name, out.LoadBalancers[0].Scheme)
 	}
 
-	outAtt, err := s.ELBV2Client.DescribeLoadBalancerAttributes(&elbv2.DescribeLoadBalancerAttributesInput{
+	outAtt, err := s.ELBV2Client.DescribeLoadBalancerAttributes(ctx, &elbv2.DescribeLoadBalancerAttributesInput{
 		LoadBalancerArn: out.LoadBalancers[0].LoadBalancerArn,
 	})
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed to describe load balancer %q attributes", name)
 	}
 
-	tags, err := s.describeLBTags(aws.StringValue(out.LoadBalancers[0].LoadBalancerArn))
+	tags, err := s.describeLBTags(ctx, aws.ToString(out.LoadBalancers[0].LoadBalancerArn))
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed to describe load balancer tags")
 	}
@@ -553,7 +553,7 @@ func (s *Service) describeLB(name string, lbSpec *infrav1.AWSLoadBalancerSpec) (
 // getOrCreateClassicLoadBalancer gets an existing classic load balancer, or creates a new one if it does not exist.
 // It also takes care of generating unique names across namespaces by appending the namespace to the name.
 // It returns a function that reconciles the load balancer.
-func (s *Service) getOrCreateClassicLoadBalancer() (lbReconciler, error) {
+func (s *Service) getOrCreateClassicLoadBalancer(ctx context.Context) (lbReconciler, error) {
 	// Generate a default control plane load balancer name. The load balancer name cannot be
 	// generated by the defaulting webhook, because it is derived from the cluster name, and that
 	// name is undefined at defaulting time when generateName is used.
@@ -563,18 +563,18 @@ func (s *Service) getOrCreateClassicLoadBalancer() (lbReconciler, error) {
 	}
 
 	// Get default api server spec.
-	spec, err := s.getAPIServerClassicELBSpec(name)
+	spec, err := s.getAPIServerClassicELBSpec(ctx, name)
 	if err != nil {
 		return nil, err
 	}
 
-	apiELB, err := s.describeClassicELB(spec.Name)
+	apiELB, err := s.describeClassicELB(ctx, spec.Name)
 	switch {
 	case IsNotFound(err) && s.scope.ControlPlaneEndpoint().IsValid():
 		// if elb is not found and owner cluster ControlPlaneEndpoint is already populated, then we should not recreate the elb.
 		return nil, errors.Wrapf(err, "no loadbalancer exists for the AWSCluster %s, the cluster has become unrecoverable and should be deleted manually", s.scope.InfraClusterName())
 	case IsNotFound(err):
-		apiELB, err = s.createClassicELB(spec)
+		apiELB, err = s.createClassicELB(ctx, spec)
 		if err != nil {
 			return nil, err
 		}
@@ -585,14 +585,14 @@ func (s *Service) getOrCreateClassicLoadBalancer() (lbReconciler, error) {
 	}
 
 	return func() error {
-		return s.reconcileClassicLoadBalancer(apiELB, spec)
+		return s.reconcileClassicLoadBalancer(ctx, apiELB, spec)
 	}, nil
 }
 
-func (s *Service) reconcileClassicLoadBalancer(apiELB *infrav1.LoadBalancer, spec *infrav1.LoadBalancer) error {
+func (s *Service) reconcileClassicLoadBalancer(ctx context.Context, apiELB *infrav1.LoadBalancer, spec *infrav1.LoadBalancer) error {
 	if apiELB.IsManaged(s.scope.Name()) {
 		if !cmp.Equal(spec.ClassicElbAttributes, apiELB.ClassicElbAttributes) {
-			err := s.configureAttributes(apiELB.Name, spec.ClassicElbAttributes)
+			err := s.configureAttributes(ctx, apiELB.Name, spec.ClassicElbAttributes)
 			if err != nil {
 				return err
 			}
@@ -603,22 +603,22 @@ func (s *Service) reconcileClassicLoadBalancer(apiELB *infrav1.LoadBalancer, spe
 		// needed or not.
 		if !cmp.Equal(spec.HealthCheck, apiELB.HealthCheck) {
 			s.scope.Debug("Reconciling health check for apiserver load balancer", "health-check", spec.HealthCheck)
-			err := s.configureHealthCheck(apiELB.Name, spec.HealthCheck)
+			err := s.configureHealthCheck(ctx, apiELB.Name, spec.HealthCheck)
 			if err != nil {
 				return err
 			}
 		}
 
-		if err := s.reconcileELBTags(apiELB, spec.Tags); err != nil {
+		if err := s.reconcileELBTags(ctx, apiELB, spec.Tags); err != nil {
 			return errors.Wrapf(err, "failed to reconcile tags for apiserver load balancer %q", apiELB.Name)
 		}
 
 		// Reconcile the subnets and availability zones from the spec
 		// and the ones currently attached to the load balancer.
 		if len(apiELB.SubnetIDs) != len(spec.SubnetIDs) {
-			_, err := s.ELBClient.AttachLoadBalancerToSubnets(&elb.AttachLoadBalancerToSubnetsInput{
+			_, err := s.ELBClient.AttachLoadBalancerToSubnets(ctx, &elb.AttachLoadBalancerToSubnetsInput{
 				LoadBalancerName: &apiELB.Name,
-				Subnets:          aws.StringSlice(spec.SubnetIDs),
+				Subnets:          spec.SubnetIDs,
 			})
 			if err != nil {
 				return errors.Wrapf(err, "failed to attach apiserver load balancer %q to subnets", apiELB.Name)
@@ -627,9 +627,9 @@ func (s *Service) reconcileClassicLoadBalancer(apiELB *infrav1.LoadBalancer, spe
 
 		// Reconcile the security groups from the spec and the ones currently attached to the load balancer
 		if !sets.NewString(apiELB.SecurityGroupIDs...).Equal(sets.NewString(spec.SecurityGroupIDs...)) {
-			_, err := s.ELBClient.ApplySecurityGroupsToLoadBalancer(&elb.ApplySecurityGroupsToLoadBalancerInput{
+			_, err := s.ELBClient.ApplySecurityGroupsToLoadBalancer(ctx, &elb.ApplySecurityGroupsToLoadBalancerInput{
 				LoadBalancerName: &apiELB.Name,
-				SecurityGroups:   aws.StringSlice(spec.SecurityGroupIDs),
+				SecurityGroups:   spec.SecurityGroupIDs,
 			})
 			if err != nil {
 				return errors.Wrapf(err, "failed to apply security groups to load balancer %q", apiELB.Name)
@@ -651,20 +651,20 @@ func (s *Service) reconcileClassicLoadBalancer(apiELB *infrav1.LoadBalancer, spe
 	return nil
 }
 
-func (s *Service) configureHealthCheck(name string, healthCheck *infrav1.ClassicELBHealthCheck) error {
+func (s *Service) configureHealthCheck(ctx context.Context, name string, healthCheck *infrav1.ClassicELBHealthCheck) error {
 	healthCheckInput := &elb.ConfigureHealthCheckInput{
 		LoadBalancerName: aws.String(name),
-		HealthCheck: &elb.HealthCheck{
+		HealthCheck: &elbtypes.HealthCheck{
 			Target:             aws.String(healthCheck.Target),
-			Interval:           aws.Int64(int64(healthCheck.Interval.Seconds())),
-			Timeout:            aws.Int64(int64(healthCheck.Timeout.Seconds())),
-			HealthyThreshold:   aws.Int64(healthCheck.HealthyThreshold),
-			UnhealthyThreshold: aws.Int64(healthCheck.UnhealthyThreshold),
+			Interval:           aws.Int32(int32(healthCheck.Interval.Seconds())),
+			Timeout:            aws.Int32(int32(healthCheck.Timeout.Seconds())),
+			HealthyThreshold:   aws.Int32(int32(healthCheck.HealthyThreshold)),   //#nosec G115
+			UnhealthyThreshold: aws.Int32(int32(healthCheck.UnhealthyThreshold)), //#nosec G115
 		},
 	}
 
 	if err := wait.WaitForWithRetryable(wait.NewBackoff(), func() (bool, error) {
-		if _, err := s.ELBClient.ConfigureHealthCheck(healthCheckInput); err != nil {
+		if _, err := s.ELBClient.ConfigureHealthCheck(ctx, healthCheckInput); err != nil {
 			return false, err
 		}
 		return true, nil
@@ -674,7 +674,7 @@ func (s *Service) configureHealthCheck(name string, healthCheck *infrav1.Classic
 	return nil
 }
 
-func (s *Service) deleteAPIServerELB() error {
+func (s *Service) deleteAPIServerELB(ctx context.Context) error {
 	s.scope.Debug("Deleting control plane load balancer")
 
 	elbName, err := ELBName(s.scope)
@@ -687,7 +687,7 @@ func (s *Service) deleteAPIServerELB() error {
 		return err
 	}
 
-	apiELB, err := s.describeClassicELB(elbName)
+	apiELB, err := s.describeClassicELB(ctx, elbName)
 	if IsNotFound(err) {
 		s.scope.Debug("Control plane load balancer not found, skipping deletion")
 		conditions.MarkFalse(s.scope.InfraCluster(), infrav1.LoadBalancerReadyCondition, clusterv1.DeletedReason, clusterv1.ConditionSeverityInfo, "")
@@ -704,13 +704,13 @@ func (s *Service) deleteAPIServerELB() error {
 	}
 
 	s.scope.Debug("deleting load balancer", "name", elbName)
-	if err := s.deleteClassicELB(elbName); err != nil {
+	if err := s.deleteClassicELB(ctx, elbName); err != nil {
 		conditions.MarkFalse(s.scope.InfraCluster(), infrav1.LoadBalancerReadyCondition, "DeletingFailed", clusterv1.ConditionSeverityWarning, "%s", err.Error())
 		return err
 	}
 
 	if err := wait.WaitForWithRetryable(wait.NewBackoff(), func() (done bool, err error) {
-		_, err = s.describeClassicELB(elbName)
+		_, err = s.describeClassicELB(ctx, elbName)
 		done = IsNotFound(err)
 		return done, nil
 	}); err != nil {
@@ -726,23 +726,23 @@ func (s *Service) deleteAPIServerELB() error {
 // LoadBalancer-type Service on the cluster, there is one ELB. If the Service is deleted before the
 // cluster is deleted, its ELB is deleted; the ELBs found in this function will typically be for
 // Services that were not deleted before the cluster was deleted.
-func (s *Service) deleteAWSCloudProviderELBs() error {
+func (s *Service) deleteAWSCloudProviderELBs(ctx context.Context) error {
 	s.scope.Debug("Deleting AWS cloud provider load balancers (created for LoadBalancer-type Services)")
 
-	elbs, err := s.listAWSCloudProviderOwnedELBs()
+	elbs, err := s.listAWSCloudProviderOwnedELBs(ctx)
 	if err != nil {
 		return err
 	}
 
 	for _, elb := range elbs {
 		s.scope.Debug("Deleting AWS cloud provider load balancer", "arn", elb)
-		if err := s.deleteClassicELB(elb); err != nil {
+		if err := s.deleteClassicELB(ctx, elb); err != nil {
 			return err
 		}
 	}
 
 	if err := wait.WaitForWithRetryable(wait.NewBackoff(), func() (done bool, err error) {
-		elbs, err := s.listAWSCloudProviderOwnedELBs()
+		elbs, err := s.listAWSCloudProviderOwnedELBs(ctx)
 		if err != nil {
 			return false, err
 		}
@@ -756,38 +756,38 @@ func (s *Service) deleteAWSCloudProviderELBs() error {
 }
 
 // DeleteLoadbalancers deletes the load balancers for the given cluster.
-func (s *Service) DeleteLoadbalancers() error {
+func (s *Service) DeleteLoadbalancers(ctx context.Context) error {
 	s.scope.Debug("Deleting load balancers")
 
-	if err := s.deleteAPIServerELB(); err != nil {
+	if err := s.deleteAPIServerELB(ctx); err != nil {
 		return errors.Wrap(err, "failed to delete control plane load balancer")
 	}
 
-	if err := s.deleteAWSCloudProviderELBs(); err != nil {
+	if err := s.deleteAWSCloudProviderELBs(ctx); err != nil {
 		return errors.Wrap(err, "failed to delete AWS cloud provider load balancer(s)")
 	}
 
-	if err := s.deleteExistingNLBs(); err != nil {
+	if err := s.deleteExistingNLBs(ctx); err != nil {
 		return errors.Wrap(err, "failed to delete AWS cloud provider load balancer(s)")
 	}
 
 	return nil
 }
 
-func (s *Service) deleteExistingNLBs() error {
+func (s *Service) deleteExistingNLBs(ctx context.Context) error {
 	errs := make([]error, 0)
 
 	for _, lbSpec := range s.scope.ControlPlaneLoadBalancers() {
 		if lbSpec == nil {
 			continue
 		}
-		errs = append(errs, s.deleteExistingNLB(lbSpec))
+		errs = append(errs, s.deleteExistingNLB(ctx, lbSpec))
 	}
 
 	return kerrors.NewAggregate(errs)
 }
 
-func (s *Service) deleteExistingNLB(lbSpec *infrav1.AWSLoadBalancerSpec) error {
+func (s *Service) deleteExistingNLB(ctx context.Context, lbSpec *infrav1.AWSLoadBalancerSpec) error {
 	name, err := LBName(s.scope, lbSpec)
 	if err != nil {
 		return errors.Wrap(err, "failed to get control plane load balancer name")
@@ -797,7 +797,7 @@ func (s *Service) deleteExistingNLB(lbSpec *infrav1.AWSLoadBalancerSpec) error {
 		return err
 	}
 
-	lb, err := s.describeLB(name, lbSpec)
+	lb, err := s.describeLB(ctx, name, lbSpec)
 	if IsNotFound(err) {
 		return nil
 	}
@@ -810,13 +810,13 @@ func (s *Service) deleteExistingNLB(lbSpec *infrav1.AWSLoadBalancerSpec) error {
 		return nil
 	}
 	s.scope.Debug("deleting load balancer", "name", name)
-	if err := s.deleteLB(lb.ARN); err != nil {
+	if err := s.deleteLB(ctx, lb.ARN); err != nil {
 		conditions.MarkFalse(s.scope.InfraCluster(), infrav1.LoadBalancerReadyCondition, "DeletingFailed", clusterv1.ConditionSeverityWarning, "%s", err.Error())
 		return err
 	}
 
 	if err := wait.WaitForWithRetryable(wait.NewBackoff(), func() (done bool, err error) {
-		_, err = s.describeLB(name, lbSpec)
+		_, err = s.describeLB(ctx, name, lbSpec)
 		done = IsNotFound(err)
 		return done, nil
 	}); err != nil {
@@ -830,17 +830,17 @@ func (s *Service) deleteExistingNLB(lbSpec *infrav1.AWSLoadBalancerSpec) error {
 }
 
 // IsInstanceRegisteredWithAPIServerELB returns true if the instance is already registered with the APIServer ELB.
-func (s *Service) IsInstanceRegisteredWithAPIServerELB(i *infrav1.Instance) (bool, error) {
+func (s *Service) IsInstanceRegisteredWithAPIServerELB(ctx context.Context, i *infrav1.Instance) (bool, error) {
 	name, err := ELBName(s.scope)
 	if err != nil {
 		return false, errors.Wrap(err, "failed to get control plane load balancer name")
 	}
 
 	input := &elb.DescribeLoadBalancersInput{
-		LoadBalancerNames: []*string{aws.String(name)},
+		LoadBalancerNames: []string{name},
 	}
 
-	output, err := s.ELBClient.DescribeLoadBalancers(input)
+	output, err := s.ELBClient.DescribeLoadBalancers(ctx, input)
 	if err != nil {
 		return false, errors.Wrapf(err, "error describing ELB %q", name)
 	}
@@ -849,7 +849,7 @@ func (s *Service) IsInstanceRegisteredWithAPIServerELB(i *infrav1.Instance) (boo
 	}
 
 	for _, registeredInstance := range output.LoadBalancerDescriptions[0].Instances {
-		if aws.StringValue(registeredInstance.InstanceId) == i.ID {
+		if aws.ToString(registeredInstance.InstanceId) == i.ID {
 			return true, nil
 		}
 	}
@@ -858,17 +858,17 @@ func (s *Service) IsInstanceRegisteredWithAPIServerELB(i *infrav1.Instance) (boo
 }
 
 // IsInstanceRegisteredWithAPIServerLB returns true if the instance is already registered with the APIServer LB.
-func (s *Service) IsInstanceRegisteredWithAPIServerLB(i *infrav1.Instance, lb *infrav1.AWSLoadBalancerSpec) ([]string, bool, error) {
+func (s *Service) IsInstanceRegisteredWithAPIServerLB(ctx context.Context, i *infrav1.Instance, lb *infrav1.AWSLoadBalancerSpec) ([]string, bool, error) {
 	name, err := LBName(s.scope, lb)
 	if err != nil {
 		return nil, false, errors.Wrap(err, "failed to get control plane load balancer name")
 	}
 
 	input := &elbv2.DescribeLoadBalancersInput{
-		Names: []*string{aws.String(name)},
+		Names: []string{name},
 	}
 
-	output, err := s.ELBV2Client.DescribeLoadBalancers(input)
+	output, err := s.ELBV2Client.DescribeLoadBalancers(ctx, input)
 	if err != nil {
 		return nil, false, errors.Wrapf(err, "error describing ELB %q", name)
 	}
@@ -880,7 +880,7 @@ func (s *Service) IsInstanceRegisteredWithAPIServerLB(i *infrav1.Instance, lb *i
 		LoadBalancerArn: output.LoadBalancers[0].LoadBalancerArn,
 	}
 
-	targetGroups, err := s.ELBV2Client.DescribeTargetGroups(describeTargetGroupInput)
+	targetGroups, err := s.ELBV2Client.DescribeTargetGroups(ctx, describeTargetGroupInput)
 	if err != nil {
 		return nil, false, errors.Wrapf(err, "error describing ELB's target groups %q", name)
 	}
@@ -890,13 +890,13 @@ func (s *Service) IsInstanceRegisteredWithAPIServerLB(i *infrav1.Instance, lb *i
 		healthInput := &elbv2.DescribeTargetHealthInput{
 			TargetGroupArn: tg.TargetGroupArn,
 		}
-		instanceHealth, err := s.ELBV2Client.DescribeTargetHealth(healthInput)
+		instanceHealth, err := s.ELBV2Client.DescribeTargetHealth(ctx, healthInput)
 		if err != nil {
 			return nil, false, errors.Wrapf(err, "error describing ELB's target groups health %q", name)
 		}
 		for _, id := range instanceHealth.TargetHealthDescriptions {
-			if aws.StringValue(id.Target.Id) == i.ID {
-				targetGroupARNs = append(targetGroupARNs, aws.StringValue(tg.TargetGroupArn))
+			if aws.ToString(id.Target.Id) == i.ID {
+				targetGroupARNs = append(targetGroupARNs, aws.ToString(tg.TargetGroupArn))
 			}
 		}
 	}
@@ -908,12 +908,12 @@ func (s *Service) IsInstanceRegisteredWithAPIServerLB(i *infrav1.Instance, lb *i
 }
 
 // RegisterInstanceWithAPIServerELB registers an instance with a classic ELB.
-func (s *Service) RegisterInstanceWithAPIServerELB(i *infrav1.Instance) error {
+func (s *Service) RegisterInstanceWithAPIServerELB(ctx context.Context, i *infrav1.Instance) error {
 	name, err := ELBName(s.scope)
 	if err != nil {
 		return errors.Wrap(err, "failed to get control plane load balancer name")
 	}
-	out, err := s.describeClassicELB(name)
+	out, err := s.describeClassicELB(ctx, name)
 	if err != nil {
 		return err
 	}
@@ -927,7 +927,7 @@ func (s *Service) RegisterInstanceWithAPIServerELB(i *infrav1.Instance) error {
 	instanceAZ := instanceSubnet.AvailabilityZone
 
 	if s.scope.ControlPlaneLoadBalancer() != nil && len(s.scope.ControlPlaneLoadBalancer().Subnets) > 0 {
-		subnets, err = s.getControlPlaneLoadBalancerSubnets()
+		subnets, err = s.getControlPlaneLoadBalancerSubnets(ctx)
 		if err != nil {
 			return err
 		}
@@ -945,21 +945,21 @@ func (s *Service) RegisterInstanceWithAPIServerELB(i *infrav1.Instance) error {
 	}
 
 	input := &elb.RegisterInstancesWithLoadBalancerInput{
-		Instances:        []*elb.Instance{{InstanceId: aws.String(i.ID)}},
+		Instances:        []elbtypes.Instance{{InstanceId: aws.String(i.ID)}},
 		LoadBalancerName: aws.String(name),
 	}
 
-	_, err = s.ELBClient.RegisterInstancesWithLoadBalancer(input)
+	_, err = s.ELBClient.RegisterInstancesWithLoadBalancer(ctx, input)
 	return err
 }
 
 // RegisterInstanceWithAPIServerLB registers an instance with a LB.
-func (s *Service) RegisterInstanceWithAPIServerLB(instance *infrav1.Instance, lbSpec *infrav1.AWSLoadBalancerSpec) error {
+func (s *Service) RegisterInstanceWithAPIServerLB(ctx context.Context, instance *infrav1.Instance, lbSpec *infrav1.AWSLoadBalancerSpec) error {
 	name, err := LBName(s.scope, lbSpec)
 	if err != nil {
 		return errors.Wrap(err, "failed to get control plane load balancer name")
 	}
-	out, err := s.describeLB(name, lbSpec)
+	out, err := s.describeLB(ctx, name, lbSpec)
 	if err != nil {
 		return err
 	}
@@ -968,7 +968,7 @@ func (s *Service) RegisterInstanceWithAPIServerLB(instance *infrav1.Instance, lb
 		LoadBalancerArn: aws.String(out.ARN),
 	}
 
-	targetGroups, err := s.ELBV2Client.DescribeTargetGroups(describeTargetGroupInput)
+	targetGroups, err := s.ELBV2Client.DescribeTargetGroups(ctx, describeTargetGroupInput)
 	if err != nil {
 		return errors.Wrapf(err, "error describing ELB's target groups %q", name)
 	}
@@ -981,15 +981,15 @@ func (s *Service) RegisterInstanceWithAPIServerLB(instance *infrav1.Instance, lb
 	for _, tg := range targetGroups.TargetGroups {
 		input := &elbv2.RegisterTargetsInput{
 			TargetGroupArn: tg.TargetGroupArn,
-			Targets: []*elbv2.TargetDescription{
+			Targets: []elbv2types.TargetDescription{
 				{
 					Id:   aws.String(instance.ID),
 					Port: tg.Port,
 				},
 			},
 		}
-		if _, err = s.ELBV2Client.RegisterTargets(input); err != nil {
-			return fmt.Errorf("failed to register instance with target group '%s': %w", aws.StringValue(tg.TargetGroupName), err)
+		if _, err = s.ELBV2Client.RegisterTargets(ctx, input); err != nil {
+			return fmt.Errorf("failed to register instance with target group '%s': %w", *tg.TargetGroupName, err)
 		}
 	}
 
@@ -997,13 +997,13 @@ func (s *Service) RegisterInstanceWithAPIServerLB(instance *infrav1.Instance, lb
 }
 
 // getControlPlaneLoadBalancerSubnets retrieves ControlPlaneLoadBalancer subnets information.
-func (s *Service) getControlPlaneLoadBalancerSubnets() (infrav1.Subnets, error) {
+func (s *Service) getControlPlaneLoadBalancerSubnets(ctx context.Context) (infrav1.Subnets, error) {
 	var subnets infrav1.Subnets
 
 	input := &ec2.DescribeSubnetsInput{
 		SubnetIds: aws.StringSlice(s.scope.ControlPlaneLoadBalancer().Subnets),
 	}
-	res, err := s.EC2Client.DescribeSubnetsWithContext(context.TODO(), input)
+	res, err := s.EC2Client.DescribeSubnetsWithContext(ctx, input)
 	if err != nil {
 		return nil, err
 	}
@@ -1021,53 +1021,51 @@ func (s *Service) getControlPlaneLoadBalancerSubnets() (infrav1.Subnets, error)
 }
 
 // DeregisterInstanceFromAPIServerELB de-registers an instance from a classic ELB.
-func (s *Service) DeregisterInstanceFromAPIServerELB(i *infrav1.Instance) error {
+func (s *Service) DeregisterInstanceFromAPIServerELB(ctx context.Context, i *infrav1.Instance) error {
 	name, err := ELBName(s.scope)
 	if err != nil {
 		return errors.Wrap(err, "failed to get control plane load balancer name")
 	}
 
 	input := &elb.DeregisterInstancesFromLoadBalancerInput{
-		Instances:        []*elb.Instance{{InstanceId: aws.String(i.ID)}},
+		Instances:        []elbtypes.Instance{{InstanceId: aws.String(i.ID)}},
 		LoadBalancerName: aws.String(name),
 	}
 
-	_, err = s.ELBClient.DeregisterInstancesFromLoadBalancer(input)
-	if err != nil {
-		if aerr, ok := err.(awserr.Error); ok {
-			switch aerr.Code() {
-			case elb.ErrCodeAccessPointNotFoundException, elb.ErrCodeInvalidEndPointException:
-				// Ignoring LoadBalancerNotFound and InvalidInstance when deregistering
-				return nil
-			default:
-				return err
-			}
+	_, err = s.ELBClient.DeregisterInstancesFromLoadBalancer(ctx, input)
+	smithyErr := awserrors.ParseSmithyError(err)
+	if smithyErr != nil {
+		switch smithyErr.ErrorCode() {
+		case (&elbtypes.AccessPointNotFoundException{}).ErrorCode(), (&elbtypes.InvalidEndPointException{}).ErrorCode():
+			// Ignoring LoadBalancerNotFound and InvalidInstance when deregistering
+			return nil
+		default:
+			return err
 		}
 	}
 	return err
 }
 
 // DeregisterInstanceFromAPIServerLB de-registers an instance from a LB.
-func (s *Service) DeregisterInstanceFromAPIServerLB(targetGroupArn string, i *infrav1.Instance) error {
+func (s *Service) DeregisterInstanceFromAPIServerLB(ctx context.Context, targetGroupArn string, i *infrav1.Instance) error {
 	input := &elbv2.DeregisterTargetsInput{
 		TargetGroupArn: aws.String(targetGroupArn),
-		Targets: []*elbv2.TargetDescription{
+		Targets: []elbv2types.TargetDescription{
 			{
 				Id: aws.String(i.ID),
 			},
 		},
 	}
 
-	_, err := s.ELBV2Client.DeregisterTargets(input)
-	if err != nil {
-		if aerr, ok := err.(awserr.Error); ok {
-			switch aerr.Code() {
-			case elb.ErrCodeAccessPointNotFoundException, elb.ErrCodeInvalidEndPointException:
-				// Ignoring LoadBalancerNotFound and InvalidInstance when deregistering
-				return nil
-			default:
-				return err
-			}
+	_, err := s.ELBV2Client.DeregisterTargets(ctx, input)
+	smithyErr := awserrors.ParseSmithyError(err)
+	if smithyErr != nil {
+		switch smithyErr.ErrorCode() {
+		case (&elbtypes.AccessPointNotFoundException{}).ErrorCode(), (&elbtypes.InvalidEndPointException{}).ErrorCode():
+			// Ignoring LoadBalancerNotFound and InvalidInstance when deregistering
+			return nil
+		default:
+			return err
 		}
 	}
 	return err
@@ -1142,7 +1140,7 @@ func generateHashedELBName(clusterName string) (string, error) {
 	return fmt.Sprintf("%s-%s", shortName, "k8s"), nil
 }
 
-func (s *Service) getAPIServerClassicELBSpec(elbName string) (*infrav1.LoadBalancer, error) {
+func (s *Service) getAPIServerClassicELBSpec(ctx context.Context, elbName string) (*infrav1.LoadBalancer, error) {
 	securityGroupIDs := []string{}
 	controlPlaneLoadBalancer := s.scope.ControlPlaneLoadBalancer()
 	if controlPlaneLoadBalancer != nil && len(controlPlaneLoadBalancer.AdditionalSecurityGroups) != 0 {
@@ -1198,7 +1196,7 @@ func (s *Service) getAPIServerClassicELBSpec(elbName string) (*infrav1.LoadBalan
 		input := &ec2.DescribeSubnetsInput{
 			SubnetIds: aws.StringSlice(s.scope.ControlPlaneLoadBalancer().Subnets),
 		}
-		out, err := s.EC2Client.DescribeSubnetsWithContext(context.TODO(), input)
+		out, err := s.EC2Client.DescribeSubnetsWithContext(ctx, input)
 		if err != nil {
 			return nil, err
 		}
@@ -1232,25 +1230,25 @@ func (s *Service) getAPIServerClassicELBSpec(elbName string) (*infrav1.LoadBalan
 	return res, nil
 }
 
-func (s *Service) createClassicELB(spec *infrav1.LoadBalancer) (*infrav1.LoadBalancer, error) {
+func (s *Service) createClassicELB(ctx context.Context, spec *infrav1.LoadBalancer) (*infrav1.LoadBalancer, error) {
 	input := &elb.CreateLoadBalancerInput{
 		LoadBalancerName: aws.String(spec.Name),
-		Subnets:          aws.StringSlice(spec.SubnetIDs),
-		SecurityGroups:   aws.StringSlice(spec.SecurityGroupIDs),
+		Subnets:          spec.SubnetIDs,
+		SecurityGroups:   spec.SecurityGroupIDs,
 		Scheme:           aws.String(string(spec.Scheme)),
 		Tags:             converters.MapToELBTags(spec.Tags),
 	}
 
 	for _, ln := range spec.ClassicELBListeners {
-		input.Listeners = append(input.Listeners, &elb.Listener{
+		input.Listeners = append(input.Listeners, elbtypes.Listener{
 			Protocol:         aws.String(string(ln.Protocol)),
-			LoadBalancerPort: aws.Int64(ln.Port),
+			LoadBalancerPort: int32(ln.Port), //#nosec G115
 			InstanceProtocol: aws.String(string(ln.InstanceProtocol)),
-			InstancePort:     aws.Int64(ln.InstancePort),
+			InstancePort:     aws.Int32(int32(ln.InstancePort)), //#nosec G115
 		})
 	}
 
-	out, err := s.ELBClient.CreateLoadBalancer(input)
+	out, err := s.ELBClient.CreateLoadBalancer(ctx, input)
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed to create classic load balancer: %v", spec)
 	}
@@ -1267,24 +1265,24 @@ func (s *Service) createClassicELB(spec *infrav1.LoadBalancer) (*infrav1.LoadBal
 	return res, nil
 }
 
-func (s *Service) configureAttributes(name string, attributes infrav1.ClassicELBAttributes) error {
+func (s *Service) configureAttributes(ctx context.Context, name string, attributes infrav1.ClassicELBAttributes) error {
 	attrs := &elb.ModifyLoadBalancerAttributesInput{
 		LoadBalancerName: aws.String(name),
-		LoadBalancerAttributes: &elb.LoadBalancerAttributes{
-			CrossZoneLoadBalancing: &elb.CrossZoneLoadBalancing{
-				Enabled: aws.Bool(attributes.CrossZoneLoadBalancing),
+		LoadBalancerAttributes: &elbtypes.LoadBalancerAttributes{
+			CrossZoneLoadBalancing: &elbtypes.CrossZoneLoadBalancing{
+				Enabled: attributes.CrossZoneLoadBalancing,
 			},
 		},
 	}
 
 	if attributes.IdleTimeout > 0 {
-		attrs.LoadBalancerAttributes.ConnectionSettings = &elb.ConnectionSettings{
-			IdleTimeout: aws.Int64(int64(attributes.IdleTimeout.Seconds())),
+		attrs.LoadBalancerAttributes.ConnectionSettings = &elbtypes.ConnectionSettings{
+			IdleTimeout: aws.Int32(int32(attributes.IdleTimeout.Seconds())),
 		}
 	}
 
 	if err := wait.WaitForWithRetryable(wait.NewBackoff(), func() (bool, error) {
-		if _, err := s.ELBClient.ModifyLoadBalancerAttributes(attrs); err != nil {
+		if _, err := s.ELBClient.ModifyLoadBalancerAttributes(ctx, attrs); err != nil {
 			return false, err
 		}
 		return true, nil
@@ -1295,10 +1293,10 @@ func (s *Service) configureAttributes(name string, attributes infrav1.ClassicELB
 	return nil
 }
 
-func (s *Service) configureLBAttributes(arn string, attributes map[string]*string) error {
-	attrs := make([]*elbv2.LoadBalancerAttribute, 0)
+func (s *Service) configureLBAttributes(ctx context.Context, arn string, attributes map[string]*string) error {
+	attrs := make([]elbv2types.LoadBalancerAttribute, 0)
 	for k, v := range attributes {
-		attrs = append(attrs, &elbv2.LoadBalancerAttribute{
+		attrs = append(attrs, elbv2types.LoadBalancerAttribute{
 			Key:   aws.String(k),
 			Value: v,
 		})
@@ -1310,7 +1308,7 @@ func (s *Service) configureLBAttributes(arn string, attributes map[string]*strin
 	}
 
 	if err := wait.WaitForWithRetryable(wait.NewBackoff(), func() (bool, error) {
-		if _, err := s.ELBV2Client.ModifyLoadBalancerAttributes(modifyInput); err != nil {
+		if _, err := s.ELBV2Client.ModifyLoadBalancerAttributes(ctx, modifyInput); err != nil {
 			return false, err
 		}
 		return true, nil
@@ -1320,12 +1318,12 @@ func (s *Service) configureLBAttributes(arn string, attributes map[string]*strin
 	return nil
 }
 
-func (s *Service) deleteClassicELB(name string) error {
+func (s *Service) deleteClassicELB(ctx context.Context, name string) error {
 	input := &elb.DeleteLoadBalancerInput{
 		LoadBalancerName: aws.String(name),
 	}
 
-	if _, err := s.ELBClient.DeleteLoadBalancer(input); err != nil {
+	if _, err := s.ELBClient.DeleteLoadBalancer(ctx, input); err != nil {
 		return err
 	}
 
@@ -1333,41 +1331,41 @@ func (s *Service) deleteClassicELB(name string) error {
 	return nil
 }
 
-func (s *Service) deleteLB(arn string) error {
+func (s *Service) deleteLB(ctx context.Context, arn string) error {
 	// remove listeners and target groups
 	// Order is important. ClassicELBListeners have to be deleted first.
 	// However, we must first gather the groups because after the listeners are deleted the groups
 	// are no longer associated with the LB, so we can't describe them afterwards.
-	groups, err := s.ELBV2Client.DescribeTargetGroups(&elbv2.DescribeTargetGroupsInput{
+	groups, err := s.ELBV2Client.DescribeTargetGroups(ctx, &elbv2.DescribeTargetGroupsInput{
 		LoadBalancerArn: aws.String(arn),
 	})
 	if err != nil {
 		return fmt.Errorf("failed to gather target groups for LB: %w", err)
 	}
-	listeners, err := s.ELBV2Client.DescribeListeners(&elbv2.DescribeListenersInput{
+	listeners, err := s.ELBV2Client.DescribeListeners(ctx, &elbv2.DescribeListenersInput{
 		LoadBalancerArn: aws.String(arn),
 	})
 	if err != nil {
 		return fmt.Errorf("failed to gather listeners: %w", err)
 	}
 	for _, listener := range listeners.Listeners {
-		s.scope.Debug("deleting listener", "arn", aws.StringValue(listener.ListenerArn))
+		s.scope.Debug("deleting listener", "arn", aws.ToString(listener.ListenerArn))
 		deleteListener := &elbv2.DeleteListenerInput{
 			ListenerArn: listener.ListenerArn,
 		}
-		if _, err := s.ELBV2Client.DeleteListener(deleteListener); err != nil {
-			return fmt.Errorf("failed to delete listener '%s': %w", aws.StringValue(listener.ListenerArn), err)
+		if _, err := s.ELBV2Client.DeleteListener(ctx, deleteListener); err != nil {
+			return fmt.Errorf("failed to delete listener '%s': %w", aws.ToString(listener.ListenerArn), err)
 		}
 	}
 	s.scope.Info("Successfully deleted all associated ClassicELBListeners")
 
 	for _, group := range groups.TargetGroups {
-		s.scope.Debug("deleting target group", "name", aws.StringValue(group.TargetGroupName))
+		s.scope.Debug("deleting target group", "name", aws.ToString(group.TargetGroupName))
 		deleteTargetGroup := &elbv2.DeleteTargetGroupInput{
 			TargetGroupArn: group.TargetGroupArn,
 		}
-		if _, err := s.ELBV2Client.DeleteTargetGroup(deleteTargetGroup); err != nil {
-			return fmt.Errorf("failed to delete target group '%s': %w", aws.StringValue(group.TargetGroupName), err)
+		if _, err := s.ELBV2Client.DeleteTargetGroup(ctx, deleteTargetGroup); err != nil {
+			return fmt.Errorf("failed to delete target group '%s': %w", aws.ToString(group.TargetGroupName), err)
 		}
 	}
 
@@ -1377,7 +1375,7 @@ func (s *Service) deleteLB(arn string) error {
 		LoadBalancerArn: aws.String(arn),
 	}
 
-	if _, err := s.ELBV2Client.DeleteLoadBalancer(deleteLoadBalancerInput); err != nil {
+	if _, err := s.ELBV2Client.DeleteLoadBalancer(ctx, deleteLoadBalancerInput); err != nil {
 		return err
 	}
 
@@ -1385,20 +1383,20 @@ func (s *Service) deleteLB(arn string) error {
 	return nil
 }
 
-func (s *Service) listByTag(tag string) ([]string, error) {
+func (s *Service) listByTag(ctx context.Context, tag string) ([]string, error) {
 	input := rgapi.GetResourcesInput{
-		ResourceTypeFilters: aws.StringSlice([]string{elbResourceType}),
-		TagFilters: []*rgapi.TagFilter{
+		ResourceTypeFilters: []string{elbResourceType},
+		TagFilters: []rgapitypes.TagFilter{
 			{
 				Key:    aws.String(tag),
-				Values: aws.StringSlice([]string{string(infrav1.ResourceLifecycleOwned)}),
+				Values: []string{string(infrav1.ResourceLifecycleOwned)},
 			},
 		},
 	}
 
 	names := []string{}
 
-	err := s.ResourceTaggingClient.GetResourcesPages(&input, func(r *rgapi.GetResourcesOutput, last bool) bool {
+	err := s.ResourceTaggingClient.GetResourcesPages(ctx, &input, func(r *rgapi.GetResourcesOutput) {
 		for _, tagmapping := range r.ResourceTagMappingList {
 			if tagmapping.ResourceARN == nil {
 				continue
@@ -1423,8 +1421,8 @@ func (s *Service) listByTag(tag string) ([]string, error) {
 			}
 			names = append(names, name)
 		}
-		return true
 	})
+
 	if err != nil {
 		record.Eventf(s.scope.InfraCluster(), "FailedListELBsByTag", "Failed to list %s ELB by Tags: %v", s.scope.Name(), err)
 		return nil, errors.Wrapf(err, "failed to list %s ELBs by tag group", s.scope.Name())
@@ -1433,13 +1431,12 @@ func (s *Service) listByTag(tag string) ([]string, error) {
 	return names, nil
 }
 
-func (s *Service) filterByOwnedTag(tagKey string) ([]string, error) {
+func (s *Service) filterByOwnedTag(ctx context.Context, tagKey string) ([]string, error) {
 	var names []string
-	err := s.ELBClient.DescribeLoadBalancersPages(&elb.DescribeLoadBalancersInput{}, func(r *elb.DescribeLoadBalancersOutput, last bool) bool {
+	err := s.ELBClient.DescribeLoadBalancersPages(ctx, &elb.DescribeLoadBalancersInput{}, func(r *elb.DescribeLoadBalancersOutput) {
 		for _, lb := range r.LoadBalancerDescriptions {
 			names = append(names, *lb.LoadBalancerName)
 		}
-		return true
 	})
 	if err != nil {
 		return nil, err
@@ -1452,7 +1449,9 @@ func (s *Service) filterByOwnedTag(tagKey string) ([]string, error) {
 	var ownedElbs []string
 	lbChunks := chunkELBs(names)
 	for _, chunk := range lbChunks {
-		output, err := s.ELBClient.DescribeTags(&elb.DescribeTagsInput{LoadBalancerNames: aws.StringSlice(chunk)})
+		output, err := s.ELBClient.DescribeTags(ctx, &elb.DescribeTagsInput{
+			LoadBalancerNames: chunk,
+		})
 		if err != nil {
 			return nil, err
 		}
@@ -1468,13 +1467,13 @@ func (s *Service) filterByOwnedTag(tagKey string) ([]string, error) {
 	return ownedElbs, nil
 }
 
-func (s *Service) listAWSCloudProviderOwnedELBs() ([]string, error) {
+func (s *Service) listAWSCloudProviderOwnedELBs(ctx context.Context) ([]string, error) {
 	// k8s.io/cluster/<name>, created by k/k cloud provider
 	serviceTag := infrav1.ClusterAWSCloudProviderTagKey(s.scope.Name())
-	arns, err := s.listByTag(serviceTag)
+	arns, err := s.listByTag(ctx, serviceTag)
 	if err != nil {
 		// retry by listing all ELBs as listByTag will fail in air-gapped environments
-		arns, err = s.filterByOwnedTag(serviceTag)
+		arns, err = s.filterByOwnedTag(ctx, serviceTag)
 		if err != nil {
 			return nil, err
 		}
@@ -1483,24 +1482,21 @@ func (s *Service) listAWSCloudProviderOwnedELBs() ([]string, error) {
 	return arns, nil
 }
 
-func (s *Service) describeClassicELB(name string) (*infrav1.LoadBalancer, error) {
+func (s *Service) describeClassicELB(ctx context.Context, name string) (*infrav1.LoadBalancer, error) {
 	input := &elb.DescribeLoadBalancersInput{
-		LoadBalancerNames: aws.StringSlice([]string{name}),
+		LoadBalancerNames: []string{name},
 	}
 
-	out, err := s.ELBClient.DescribeLoadBalancers(input)
-	if err != nil {
-		if aerr, ok := err.(awserr.Error); ok {
-			switch aerr.Code() {
-			case elb.ErrCodeAccessPointNotFoundException:
-				return nil, NewNotFound(fmt.Sprintf("no classic load balancer found with name: %q", name))
-			case elb.ErrCodeDependencyThrottleException:
-				return nil, errors.Wrap(err, "too many requests made to the ELB service")
-			default:
-				return nil, errors.Wrap(err, "unexpected aws error")
-			}
-		} else {
-			return nil, errors.Wrapf(err, "failed to describe classic load balancer: %s", name)
+	out, err := s.ELBClient.DescribeLoadBalancers(ctx, input)
+	smithyErr := awserrors.ParseSmithyError(err)
+	if smithyErr != nil {
+		switch smithyErr.ErrorCode() {
+		case (&elbtypes.AccessPointNotFoundException{}).ErrorCode():
+			return nil, NewNotFound(fmt.Sprintf("no classic load balancer found with name: %q", name))
+		case (&elbtypes.DependencyThrottleException{}).ErrorCode():
+			return nil, errors.Wrap(err, "too many requests made to the ELB service")
+		default:
+			return nil, errors.Wrap(err, "unexpected aws error")
 		}
 	}
 
@@ -1516,30 +1512,30 @@ func (s *Service) describeClassicELB(name string) (*infrav1.LoadBalancer, error)
 
 	if s.scope.ControlPlaneLoadBalancer() != nil &&
 		s.scope.ControlPlaneLoadBalancer().Scheme != nil &&
-		string(*s.scope.ControlPlaneLoadBalancer().Scheme) != aws.StringValue(out.LoadBalancerDescriptions[0].Scheme) {
+		string(*s.scope.ControlPlaneLoadBalancer().Scheme) != aws.ToString(out.LoadBalancerDescriptions[0].Scheme) {
 		return nil, errors.Errorf(
 			"ELB names must be unique within a region: %q ELB already exists in this region with a different scheme %q",
 			name, *out.LoadBalancerDescriptions[0].Scheme)
 	}
 
-	outAtt, err := s.ELBClient.DescribeLoadBalancerAttributes(&elb.DescribeLoadBalancerAttributesInput{
+	outAtt, err := s.ELBClient.DescribeLoadBalancerAttributes(ctx, &elb.DescribeLoadBalancerAttributesInput{
 		LoadBalancerName: aws.String(name),
 	})
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed to describe classic load balancer %q attributes", name)
 	}
 
-	tags, err := s.describeClassicELBTags(name)
+	tags, err := s.describeClassicELBTags(ctx, name)
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed to describe classic load balancer tags")
 	}
 
-	return fromSDKTypeToClassicELB(out.LoadBalancerDescriptions[0], outAtt.LoadBalancerAttributes, tags), nil
+	return fromSDKTypeToClassicELB(&out.LoadBalancerDescriptions[0], outAtt.LoadBalancerAttributes, tags), nil
 }
 
-func (s *Service) describeClassicELBTags(name string) ([]*elb.Tag, error) {
-	output, err := s.ELBClient.DescribeTags(&elb.DescribeTagsInput{
-		LoadBalancerNames: []*string{aws.String(name)},
+func (s *Service) describeClassicELBTags(ctx context.Context, name string) ([]elbtypes.Tag, error) {
+	output, err := s.ELBClient.DescribeTags(ctx, &elb.DescribeTagsInput{
+		LoadBalancerNames: []string{name},
 	})
 	if err != nil {
 		return nil, err
@@ -1552,9 +1548,9 @@ func (s *Service) describeClassicELBTags(name string) ([]*elb.Tag, error) {
 	return output.TagDescriptions[0].Tags, nil
 }
 
-func (s *Service) describeLBTags(arn string) ([]*elbv2.Tag, error) {
-	output, err := s.ELBV2Client.DescribeTags(&elbv2.DescribeTagsInput{
-		ResourceArns: []*string{aws.String(arn)},
+func (s *Service) describeLBTags(ctx context.Context, arn string) ([]elbv2types.Tag, error) {
+	output, err := s.ELBV2Client.DescribeTags(ctx, &elbv2.DescribeTagsInput{
+		ResourceArns: []string{arn},
 	})
 	if err != nil {
 		return nil, err
@@ -1567,13 +1563,13 @@ func (s *Service) describeLBTags(arn string) ([]*elbv2.Tag, error) {
 	return output.TagDescriptions[0].Tags, nil
 }
 
-func (s *Service) reconcileELBTags(lb *infrav1.LoadBalancer, desiredTags map[string]string) error {
+func (s *Service) reconcileELBTags(ctx context.Context, lb *infrav1.LoadBalancer, desiredTags map[string]string) error {
 	addTagsInput := &elb.AddTagsInput{
-		LoadBalancerNames: []*string{aws.String(lb.Name)},
+		LoadBalancerNames: []string{lb.Name},
 	}
 
 	removeTagsInput := &elb.RemoveTagsInput{
-		LoadBalancerNames: []*string{aws.String(lb.Name)},
+		LoadBalancerNames: []string{lb.Name},
 	}
 
 	currentTags := infrav1.Tags(lb.Tags)
@@ -1581,25 +1577,25 @@ func (s *Service) reconcileELBTags(lb *infrav1.LoadBalancer, desiredTags map[str
 	for k, v := range desiredTags {
 		if val, ok := currentTags[k]; !ok || val != v {
 			s.scope.Trace("adding tag to load balancer", "elb-name", lb.Name, "key", k, "value", v)
-			addTagsInput.Tags = append(addTagsInput.Tags, &elb.Tag{Key: aws.String(k), Value: aws.String(v)})
+			addTagsInput.Tags = append(addTagsInput.Tags, elbtypes.Tag{Key: aws.String(k), Value: aws.String(v)})
 		}
 	}
 
 	for k := range currentTags {
 		if _, ok := desiredTags[k]; !ok {
 			s.scope.Trace("removing tag from load balancer", "elb-name", lb.Name, "key", k)
-			removeTagsInput.Tags = append(removeTagsInput.Tags, &elb.TagKeyOnly{Key: aws.String(k)})
+			removeTagsInput.Tags = append(removeTagsInput.Tags, elbtypes.TagKeyOnly{Key: aws.String(k)})
 		}
 	}
 
 	if len(addTagsInput.Tags) > 0 {
-		if _, err := s.ELBClient.AddTags(addTagsInput); err != nil {
+		if _, err := s.ELBClient.AddTags(ctx, addTagsInput); err != nil {
 			return err
 		}
 	}
 
 	if len(removeTagsInput.Tags) > 0 {
-		if _, err := s.ELBClient.RemoveTags(removeTagsInput); err != nil {
+		if _, err := s.ELBClient.RemoveTags(ctx, removeTagsInput); err != nil {
 			return err
 		}
 	}
@@ -1607,13 +1603,13 @@ func (s *Service) reconcileELBTags(lb *infrav1.LoadBalancer, desiredTags map[str
 	return nil
 }
 
-func (s *Service) reconcileV2LBTags(lb *infrav1.LoadBalancer, desiredTags map[string]string) error {
+func (s *Service) reconcileV2LBTags(ctx context.Context, lb *infrav1.LoadBalancer, desiredTags map[string]string) error {
 	addTagsInput := &elbv2.AddTagsInput{
-		ResourceArns: []*string{aws.String(lb.ARN)},
+		ResourceArns: []string{lb.ARN},
 	}
 
 	removeTagsInput := &elbv2.RemoveTagsInput{
-		ResourceArns: []*string{aws.String(lb.ARN)},
+		ResourceArns: []string{lb.ARN},
 	}
 
 	currentTags := infrav1.Tags(lb.Tags)
@@ -1621,25 +1617,25 @@ func (s *Service) reconcileV2LBTags(lb *infrav1.LoadBalancer, desiredTags map[st
 	for k, v := range desiredTags {
 		if val, ok := currentTags[k]; !ok || val != v {
 			s.scope.Trace("adding tag to load balancer", "elb-name", lb.Name, "key", k, "value", v)
-			addTagsInput.Tags = append(addTagsInput.Tags, &elbv2.Tag{Key: aws.String(k), Value: aws.String(v)})
+			addTagsInput.Tags = append(addTagsInput.Tags, elbv2types.Tag{Key: aws.String(k), Value: aws.String(v)})
 		}
 	}
 
 	for k := range currentTags {
 		if _, ok := desiredTags[k]; !ok {
 			s.scope.Trace("removing tag from load balancer", "elb-name", lb.Name, "key", k)
-			removeTagsInput.TagKeys = append(removeTagsInput.TagKeys, aws.String(k))
+			removeTagsInput.TagKeys = append(removeTagsInput.TagKeys, k)
 		}
 	}
 
 	if len(addTagsInput.Tags) > 0 {
-		if _, err := s.ELBV2Client.AddTags(addTagsInput); err != nil {
+		if _, err := s.ELBV2Client.AddTags(ctx, addTagsInput); err != nil {
 			return err
 		}
 	}
 
 	if len(removeTagsInput.TagKeys) > 0 {
-		if _, err := s.ELBV2Client.RemoveTags(removeTagsInput); err != nil {
+		if _, err := s.ELBV2Client.RemoveTags(ctx, removeTagsInput); err != nil {
 			return err
 		}
 	}
@@ -1649,8 +1645,9 @@ func (s *Service) reconcileV2LBTags(lb *infrav1.LoadBalancer, desiredTags map[st
 
 // reconcileTargetGroupsAndListeners reconciles a Load Balancer's defined listeners with corresponding AWS Target Groups and Listeners.
 // These are combined into a single function since they are tightly integrated.
-func (s *Service) reconcileTargetGroupsAndListeners(lbARN string, spec *infrav1.LoadBalancer, lbSpec *infrav1.AWSLoadBalancerSpec) ([]*elbv2.TargetGroup, []*elbv2.Listener, error) {
+func (s *Service) reconcileTargetGroupsAndListeners(ctx context.Context, lbARN string, spec *infrav1.LoadBalancer, lbSpec *infrav1.AWSLoadBalancerSpec) ([]*elbv2types.TargetGroup, []*elbv2types.Listener, error) {
 	existingTargetGroups, err := s.ELBV2Client.DescribeTargetGroups(
+		ctx,
 		&elbv2.DescribeTargetGroupsInput{
 			LoadBalancerArn: aws.String(lbARN),
 		})
@@ -1660,6 +1657,7 @@ func (s *Service) reconcileTargetGroupsAndListeners(lbARN string, spec *infrav1.
 	}
 
 	existingListeners, err := s.ELBV2Client.DescribeListeners(
+		ctx,
 		&elbv2.DescribeListenersInput{
 			LoadBalancerArn: aws.String(lbARN),
 		})
@@ -1667,23 +1665,23 @@ func (s *Service) reconcileTargetGroupsAndListeners(lbARN string, spec *infrav1.
 		s.scope.Error(err, "could not describe listeners for load balancer", "arn", lbARN)
 	}
 
-	createdTargetGroups := make([]*elbv2.TargetGroup, 0, len(spec.ELBListeners))
-	createdListeners := make([]*elbv2.Listener, 0, len(spec.ELBListeners))
+	createdTargetGroups := make([]*elbv2types.TargetGroup, 0, len(spec.ELBListeners))
+	createdListeners := make([]*elbv2types.Listener, 0, len(spec.ELBListeners))
 
 	// TODO(Skarlso): Add options to set up SSL.
 	// https://github.com/kubernetes-sigs/cluster-api-provider-aws/issues/3899
 	for _, ln := range spec.ELBListeners {
-		var group *elbv2.TargetGroup
+		var group *elbv2types.TargetGroup
 		tgSpec := ln.TargetGroup
 		for _, g := range existingTargetGroups.TargetGroups {
-			if isSDKTargetGroupEqualToTargetGroup(g, &tgSpec) {
-				group = g
+			if isSDKTargetGroupEqualToTargetGroup(&g, &tgSpec) {
+				group = &g
 				break
 			}
 		}
 		// create the target group first
 		if group == nil {
-			group, err = s.createTargetGroup(ln, spec.Tags)
+			group, err = s.createTargetGroup(ctx, ln, spec.Tags)
 			if err != nil {
 				return nil, nil, err
 			}
@@ -1692,29 +1690,29 @@ func (s *Service) reconcileTargetGroupsAndListeners(lbARN string, spec *infrav1.
 			if !lbSpec.PreserveClientIP {
 				targetGroupAttributeInput := &elbv2.ModifyTargetGroupAttributesInput{
 					TargetGroupArn: group.TargetGroupArn,
-					Attributes: []*elbv2.TargetGroupAttribute{
+					Attributes: []elbv2types.TargetGroupAttribute{
 						{
 							Key:   aws.String(infrav1.TargetGroupAttributeEnablePreserveClientIP),
 							Value: aws.String("false"),
 						},
 					},
 				}
-				if _, err := s.ELBV2Client.ModifyTargetGroupAttributes(targetGroupAttributeInput); err != nil {
+				if _, err := s.ELBV2Client.ModifyTargetGroupAttributes(ctx, targetGroupAttributeInput); err != nil {
 					return nil, nil, errors.Wrapf(err, "failed to modify target group attribute")
 				}
 			}
 		}
 
-		var listener *elbv2.Listener
+		var listener *elbv2types.Listener
 		for _, l := range existingListeners.Listeners {
 			if len(l.DefaultActions) > 0 && *l.DefaultActions[0].TargetGroupArn == *group.TargetGroupArn {
-				listener = l
+				listener = &l
 				break
 			}
 		}
 
 		if listener == nil {
-			listener, err = s.createListener(ln, group, lbARN, spec.Tags)
+			listener, err = s.createListener(ctx, ln, group, lbARN, spec.Tags)
 			if err != nil {
 				return nil, nil, err
 			}
@@ -1726,21 +1724,21 @@ func (s *Service) reconcileTargetGroupsAndListeners(lbARN string, spec *infrav1.
 }
 
 // createListener creates a single Listener.
-func (s *Service) createListener(ln infrav1.Listener, group *elbv2.TargetGroup, lbARN string, tags map[string]string) (*elbv2.Listener, error) {
+func (s *Service) createListener(ctx context.Context, ln infrav1.Listener, group *elbv2types.TargetGroup, lbARN string, tags map[string]string) (*elbv2types.Listener, error) {
 	listenerInput := &elbv2.CreateListenerInput{
-		DefaultActions: []*elbv2.Action{
+		DefaultActions: []elbv2types.Action{
 			{
 				TargetGroupArn: group.TargetGroupArn,
-				Type:           aws.String(elbv2.ActionTypeEnumForward),
+				Type:           elbv2types.ActionTypeEnumForward,
 			},
 		},
 		LoadBalancerArn: aws.String(lbARN),
-		Port:            aws.Int64(ln.Port),
-		Protocol:        aws.String(string(ln.Protocol)),
+		Port:            aws.Int32(int32(ln.Port)), //#nosec G115
+		Protocol:        elbProtocolToSDKProtocol(ln.Protocol),
 		Tags:            converters.MapToV2Tags(tags),
 	}
 	// Create ClassicELBListeners
-	listener, err := s.ELBV2Client.CreateListener(listenerInput)
+	listener, err := s.ELBV2Client.CreateListener(ctx, listenerInput)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to create listener")
 	}
@@ -1750,47 +1748,50 @@ func (s *Service) createListener(ln infrav1.Listener, group *elbv2.TargetGroup,
 	if len(listener.Listeners) > 1 {
 		return nil, errors.New("more than one listener created; expected only one")
 	}
-	return listener.Listeners[0], nil
+	return &listener.Listeners[0], nil
 }
 
 // createTargetGroup creates a single Target Group.
-func (s *Service) createTargetGroup(ln infrav1.Listener, tags map[string]string) (*elbv2.TargetGroup, error) {
+func (s *Service) createTargetGroup(ctx context.Context, ln infrav1.Listener, tags map[string]string) (*elbv2types.TargetGroup, error) {
 	targetGroupInput := &elbv2.CreateTargetGroupInput{
 		Name:                       aws.String(ln.TargetGroup.Name),
-		Port:                       aws.Int64(ln.TargetGroup.Port),
-		Protocol:                   aws.String(ln.TargetGroup.Protocol.String()),
+		Port:                       aws.Int32(int32(ln.TargetGroup.Port)), //#nosec G115
+		Protocol:                   elbProtocolToSDKProtocol(ln.TargetGroup.Protocol),
 		VpcId:                      aws.String(ln.TargetGroup.VpcID),
 		Tags:                       converters.MapToV2Tags(tags),
-		HealthCheckIntervalSeconds: aws.Int64(infrav1.DefaultAPIServerHealthCheckIntervalSec),
-		HealthCheckTimeoutSeconds:  aws.Int64(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
-		HealthyThresholdCount:      aws.Int64(infrav1.DefaultAPIServerHealthThresholdCount),
-		UnhealthyThresholdCount:    aws.Int64(infrav1.DefaultAPIServerUnhealthThresholdCount),
+		HealthCheckIntervalSeconds: aws.Int32(infrav1.DefaultAPIServerHealthCheckIntervalSec),
+		HealthCheckTimeoutSeconds:  aws.Int32(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
+		HealthyThresholdCount:      aws.Int32(infrav1.DefaultAPIServerHealthThresholdCount),
+		UnhealthyThresholdCount:    aws.Int32(infrav1.DefaultAPIServerUnhealthThresholdCount),
 	}
 	if s.scope.VPC().IsIPv6Enabled() {
-		targetGroupInput.IpAddressType = aws.String("ipv6")
+		targetGroupInput.IpAddressType = elbv2types.TargetGroupIpAddressTypeEnumIpv6
 	}
 	if ln.TargetGroup.HealthCheck != nil {
 		targetGroupInput.HealthCheckEnabled = aws.Bool(true)
-		targetGroupInput.HealthCheckProtocol = ln.TargetGroup.HealthCheck.Protocol
+
+		if ln.TargetGroup.HealthCheck.Protocol != nil {
+			targetGroupInput.HealthCheckProtocol = elbv2types.ProtocolEnum(strings.ToUpper(aws.ToString(ln.TargetGroup.HealthCheck.Protocol)))
+		}
 		targetGroupInput.HealthCheckPort = ln.TargetGroup.HealthCheck.Port
 		if ln.TargetGroup.HealthCheck.Path != nil {
 			targetGroupInput.HealthCheckPath = ln.TargetGroup.HealthCheck.Path
 		}
 		if ln.TargetGroup.HealthCheck.IntervalSeconds != nil {
-			targetGroupInput.HealthCheckIntervalSeconds = ln.TargetGroup.HealthCheck.IntervalSeconds
+			targetGroupInput.HealthCheckIntervalSeconds = aws.Int32(int32(*ln.TargetGroup.HealthCheck.IntervalSeconds)) //#nosec G115
 		}
 		if ln.TargetGroup.HealthCheck.TimeoutSeconds != nil {
-			targetGroupInput.HealthCheckTimeoutSeconds = ln.TargetGroup.HealthCheck.TimeoutSeconds
+			targetGroupInput.HealthCheckTimeoutSeconds = aws.Int32(int32(*ln.TargetGroup.HealthCheck.TimeoutSeconds)) //#nosec G115
 		}
 		if ln.TargetGroup.HealthCheck.ThresholdCount != nil {
-			targetGroupInput.HealthyThresholdCount = ln.TargetGroup.HealthCheck.ThresholdCount
+			targetGroupInput.HealthyThresholdCount = aws.Int32(int32(*ln.TargetGroup.HealthCheck.ThresholdCount)) //#nosec G115
 		}
 		if ln.TargetGroup.HealthCheck.UnhealthyThresholdCount != nil {
-			targetGroupInput.UnhealthyThresholdCount = ln.TargetGroup.HealthCheck.UnhealthyThresholdCount
+			targetGroupInput.UnhealthyThresholdCount = aws.Int32(int32(*ln.TargetGroup.HealthCheck.UnhealthyThresholdCount)) //#nosec G115
 		}
 	}
 	s.scope.Debug("creating target group", "group", targetGroupInput, "listener", ln)
-	group, err := s.ELBV2Client.CreateTargetGroup(targetGroupInput)
+	group, err := s.ELBV2Client.CreateTargetGroup(ctx, targetGroupInput)
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed to create target group for load balancer")
 	}
@@ -1800,7 +1801,7 @@ func (s *Service) createTargetGroup(ln infrav1.Listener, tags map[string]string)
 	if len(group.TargetGroups) > 1 {
 		return nil, errors.New("more than one target group created; expected only one")
 	}
-	return group.TargetGroups[0], nil
+	return &group.TargetGroups[0], nil
 }
 
 func (s *Service) getHealthCheckTarget() string {
@@ -1815,13 +1816,13 @@ func (s *Service) getHealthCheckTarget() string {
 	return fmt.Sprintf("%v:%d", protocol, infrav1.DefaultAPIServerPort)
 }
 
-func fromSDKTypeToClassicELB(v *elb.LoadBalancerDescription, attrs *elb.LoadBalancerAttributes, tags []*elb.Tag) *infrav1.LoadBalancer {
+func fromSDKTypeToClassicELB(v *elbtypes.LoadBalancerDescription, attrs *elbtypes.LoadBalancerAttributes, tags []elbtypes.Tag) *infrav1.LoadBalancer {
 	res := &infrav1.LoadBalancer{
-		Name:             aws.StringValue(v.LoadBalancerName),
+		Name:             aws.ToString(v.LoadBalancerName),
 		Scheme:           infrav1.ELBScheme(*v.Scheme),
-		SubnetIDs:        aws.StringValueSlice(v.Subnets),
-		SecurityGroupIDs: aws.StringValueSlice(v.SecurityGroups),
-		DNSName:          aws.StringValue(v.DNSName),
+		SubnetIDs:        v.Subnets,
+		SecurityGroupIDs: v.SecurityGroups,
+		DNSName:          aws.ToString(v.DNSName),
 		Tags:             converters.ELBTagsToMap(tags),
 		LoadBalancerType: infrav1.LoadBalancerTypeClassic,
 	}
@@ -1830,26 +1831,26 @@ func fromSDKTypeToClassicELB(v *elb.LoadBalancerDescription, attrs *elb.LoadBala
 		res.ClassicElbAttributes.IdleTimeout = time.Duration(*attrs.ConnectionSettings.IdleTimeout) * time.Second
 	}
 
-	res.ClassicElbAttributes.CrossZoneLoadBalancing = aws.BoolValue(attrs.CrossZoneLoadBalancing.Enabled)
+	res.ClassicElbAttributes.CrossZoneLoadBalancing = attrs.CrossZoneLoadBalancing.Enabled
 
 	return res
 }
 
-func fromSDKTypeToLB(v *elbv2.LoadBalancer, attrs []*elbv2.LoadBalancerAttribute, tags []*elbv2.Tag) *infrav1.LoadBalancer {
-	subnetIDs := make([]*string, len(v.AvailabilityZones))
-	availabilityZones := make([]*string, len(v.AvailabilityZones))
+func fromSDKTypeToLB(v elbv2types.LoadBalancer, attrs []elbv2types.LoadBalancerAttribute, tags []elbv2types.Tag) *infrav1.LoadBalancer {
+	subnetIDs := make([]string, len(v.AvailabilityZones))
+	availabilityZones := make([]string, len(v.AvailabilityZones))
 	for i, az := range v.AvailabilityZones {
-		subnetIDs[i] = az.SubnetId
-		availabilityZones[i] = az.ZoneName
+		subnetIDs[i] = aws.ToString(az.SubnetId)
+		availabilityZones[i] = aws.ToString(az.ZoneName)
 	}
 	res := &infrav1.LoadBalancer{
-		ARN:               aws.StringValue(v.LoadBalancerArn),
-		Name:              aws.StringValue(v.LoadBalancerName),
-		Scheme:            infrav1.ELBScheme(aws.StringValue(v.Scheme)),
-		SubnetIDs:         aws.StringValueSlice(subnetIDs),
-		SecurityGroupIDs:  aws.StringValueSlice(v.SecurityGroups),
-		AvailabilityZones: aws.StringValueSlice(availabilityZones),
-		DNSName:           aws.StringValue(v.DNSName),
+		ARN:               aws.ToString(v.LoadBalancerArn),
+		Name:              aws.ToString(v.LoadBalancerName),
+		Scheme:            infrav1.ELBScheme(v.Scheme),
+		SubnetIDs:         subnetIDs,
+		SecurityGroupIDs:  v.SecurityGroups,
+		AvailabilityZones: availabilityZones,
+		DNSName:           aws.ToString(v.DNSName),
 		Tags:              converters.V2TagsToMap(tags),
 	}
 
@@ -1894,7 +1895,7 @@ func shouldReconcileSGs(scope scope.ELBScope, lb *infrav1.LoadBalancer, specSGs
 }
 
 // isSDKTargetGroupEqualToTargetGroup checks if a given AWS SDK target group matches a target group spec.
-func isSDKTargetGroupEqualToTargetGroup(elbTG *elbv2.TargetGroup, spec *infrav1.TargetGroupSpec) bool {
+func isSDKTargetGroupEqualToTargetGroup(elbTG *elbv2types.TargetGroup, spec *infrav1.TargetGroupSpec) bool {
 	// We can't check only the target group's name because it's randomly generated every time we get a spec
 	// But CAPA-created target groups are guaranteed to have the "apiserver-target-" or "additional-listener-" prefix.
 	switch {
@@ -1910,5 +1911,68 @@ func isSDKTargetGroupEqualToTargetGroup(elbTG *elbv2.TargetGroup, spec *infrav1.
 		// Not created by CAPA
 		return false
 	}
-	return ptr.Deref(elbTG.Port, 0) == spec.Port && strings.EqualFold(*elbTG.Protocol, spec.Protocol.String())
+	return int64(ptr.Deref(elbTG.Port, 0)) == spec.Port && strings.EqualFold(string(elbTG.Protocol), spec.Protocol.String())
+}
+
+// SchemeToSDKScheme converts infrav1.ELBScheme to elbv2types.LoadBalancerSchemeEnum.
+func SchemeToSDKScheme(scheme infrav1.ELBScheme) elbv2types.LoadBalancerSchemeEnum {
+	if scheme == infrav1.ELBSchemeInternetFacing {
+		return elbv2types.LoadBalancerSchemeEnumInternetFacing
+	}
+	return elbv2types.LoadBalancerSchemeEnumInternal
+}
+
+func elbProtocolToSDKProtocol(protocol infrav1.ELBProtocol) elbv2types.ProtocolEnum {
+	if protocol == infrav1.ELBProtocolSSL {
+		return elbv2types.ProtocolEnumTls
+	}
+	return elbv2types.ProtocolEnum(protocol)
+}
+
+// WaitUntilLoadBalancerAvailable is a blocking function to wait until LoadBalancerV2 is Available.
+func (c *ELBV2Client) WaitUntilLoadBalancerAvailable(ctx context.Context, input *elbv2.DescribeLoadBalancersInput, maxWait time.Duration) error {
+	waiter := elbv2.NewLoadBalancerAvailableWaiter(c, func(o *elbv2.LoadBalancerAvailableWaiterOptions) {
+		o.LogWaitAttempts = true
+	})
+
+	return waiter.Wait(ctx, input, maxWait)
+}
+
+// GetResourcesPages implementation of SDK V2.
+func (c *ResourceGroupsTaggingAPIClient) GetResourcesPages(ctx context.Context, input *rgapi.GetResourcesInput, fn func(*rgapi.GetResourcesOutput)) error {
+	paginator := rgapi.NewGetResourcesPaginator(c, input)
+	for paginator.HasMorePages() {
+		r, err := paginator.NextPage(ctx)
+		if err != nil {
+			return err
+		}
+		fn(r)
+	}
+	return nil
+}
+
+// DescribeLoadBalancersPages implementation of SDK V2.
+func (c *ELBClient) DescribeLoadBalancersPages(ctx context.Context, input *elb.DescribeLoadBalancersInput, fn func(*elb.DescribeLoadBalancersOutput)) error {
+	paginator := elb.NewDescribeLoadBalancersPaginator(c, input)
+	for paginator.HasMorePages() {
+		r, err := paginator.NextPage(ctx)
+		if err != nil {
+			return err
+		}
+		fn(r)
+	}
+	return nil
+}
+
+// DescribeLoadBalancersPages implementation of SDK V2.
+func (c *ELBV2Client) DescribeLoadBalancersPages(ctx context.Context, input *elbv2.DescribeLoadBalancersInput, fn func(*elbv2.DescribeLoadBalancersOutput)) error {
+	paginator := elbv2.NewDescribeLoadBalancersPaginator(c, input)
+	for paginator.HasMorePages() {
+		r, err := paginator.NextPage(ctx)
+		if err != nil {
+			return err
+		}
+		fn(r)
+	}
+	return nil
 }
diff --git a/pkg/cloud/services/elb/service.go b/pkg/cloud/services/elb/service.go
index 709329001..09c50e615 100644
--- a/pkg/cloud/services/elb/service.go
+++ b/pkg/cloud/services/elb/service.go
@@ -18,10 +18,13 @@ limitations under the License.
 package elb
 
 import (
+	"context"
+	"time"
+
+	elb "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing"
+	elbv2 "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2"
+	rgapi "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi"
 	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
-	"github.com/aws/aws-sdk-go/service/elb/elbiface"
-	"github.com/aws/aws-sdk-go/service/elbv2/elbv2iface"
-	"github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi/resourcegroupstaggingapiiface"
 
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/network"
@@ -33,20 +36,99 @@ import (
 type Service struct {
 	scope                 scope.ELBScope
 	EC2Client             ec2iface.EC2API
-	ELBClient             elbiface.ELBAPI
-	ELBV2Client           elbv2iface.ELBV2API
-	ResourceTaggingClient resourcegroupstaggingapiiface.ResourceGroupsTaggingAPIAPI
+	ELBClient             ELBAPI
+	ELBV2Client           ELBV2API
+	ResourceTaggingClient ResourceGroupsTaggingAPIAPI
 	netService            *network.Service
 }
 
+// ELBAPI is the subset of the AWS ELB API used by CAPA.
+type ELBAPI interface {
+	// Subset of AWS ELB API
+	AddTags(ctx context.Context, params *elb.AddTagsInput, optFns ...func(*elb.Options)) (*elb.AddTagsOutput, error)
+	ApplySecurityGroupsToLoadBalancer(ctx context.Context, params *elb.ApplySecurityGroupsToLoadBalancerInput, optFns ...func(*elb.Options)) (*elb.ApplySecurityGroupsToLoadBalancerOutput, error)
+	AttachLoadBalancerToSubnets(ctx context.Context, params *elb.AttachLoadBalancerToSubnetsInput, optFns ...func(*elb.Options)) (*elb.AttachLoadBalancerToSubnetsOutput, error)
+	ConfigureHealthCheck(ctx context.Context, params *elb.ConfigureHealthCheckInput, optFns ...func(*elb.Options)) (*elb.ConfigureHealthCheckOutput, error)
+	CreateLoadBalancer(ctx context.Context, params *elb.CreateLoadBalancerInput, optFns ...func(*elb.Options)) (*elb.CreateLoadBalancerOutput, error)
+	DeleteLoadBalancer(ctx context.Context, params *elb.DeleteLoadBalancerInput, optFns ...func(*elb.Options)) (*elb.DeleteLoadBalancerOutput, error)
+	DeregisterInstancesFromLoadBalancer(ctx context.Context, params *elb.DeregisterInstancesFromLoadBalancerInput, optFns ...func(*elb.Options)) (*elb.DeregisterInstancesFromLoadBalancerOutput, error)
+	DescribeLoadBalancerAttributes(ctx context.Context, params *elb.DescribeLoadBalancerAttributesInput, optFns ...func(*elb.Options)) (*elb.DescribeLoadBalancerAttributesOutput, error)
+	DescribeLoadBalancers(ctx context.Context, params *elb.DescribeLoadBalancersInput, optFns ...func(*elb.Options)) (*elb.DescribeLoadBalancersOutput, error)
+	DescribeTags(ctx context.Context, params *elb.DescribeTagsInput, optFns ...func(*elb.Options)) (*elb.DescribeTagsOutput, error)
+	ModifyLoadBalancerAttributes(ctx context.Context, params *elb.ModifyLoadBalancerAttributesInput, optFns ...func(*elb.Options)) (*elb.ModifyLoadBalancerAttributesOutput, error)
+	RemoveTags(ctx context.Context, params *elb.RemoveTagsInput, optFns ...func(*elb.Options)) (*elb.RemoveTagsOutput, error)
+	RegisterInstancesWithLoadBalancer(ctx context.Context, params *elb.RegisterInstancesWithLoadBalancerInput, optFns ...func(*elb.Options)) (*elb.RegisterInstancesWithLoadBalancerOutput, error)
+
+	// CAPA Custom function
+	DescribeLoadBalancersPages(ctx context.Context, input *elb.DescribeLoadBalancersInput, fn func(*elb.DescribeLoadBalancersOutput)) error
+}
+
+// ELBV2API is the subset of the AWS ELBV2 API used by CAPA.
+type ELBV2API interface {
+	// Subset of AWS ELBV2 API
+	AddTags(ctx context.Context, params *elbv2.AddTagsInput, optFns ...func(*elbv2.Options)) (*elbv2.AddTagsOutput, error)
+	CreateListener(ctx context.Context, params *elbv2.CreateListenerInput, optFns ...func(*elbv2.Options)) (*elbv2.CreateListenerOutput, error)
+	CreateLoadBalancer(ctx context.Context, params *elbv2.CreateLoadBalancerInput, optFns ...func(*elbv2.Options)) (*elbv2.CreateLoadBalancerOutput, error)
+	CreateTargetGroup(ctx context.Context, params *elbv2.CreateTargetGroupInput, optFns ...func(*elbv2.Options)) (*elbv2.CreateTargetGroupOutput, error)
+	DeleteListener(ctx context.Context, params *elbv2.DeleteListenerInput, optFns ...func(*elbv2.Options)) (*elbv2.DeleteListenerOutput, error)
+	DeleteLoadBalancer(ctx context.Context, params *elbv2.DeleteLoadBalancerInput, optFns ...func(*elbv2.Options)) (*elbv2.DeleteLoadBalancerOutput, error)
+	DeleteTargetGroup(ctx context.Context, params *elbv2.DeleteTargetGroupInput, optFns ...func(*elbv2.Options)) (*elbv2.DeleteTargetGroupOutput, error)
+	DeregisterTargets(ctx context.Context, params *elbv2.DeregisterTargetsInput, optFns ...func(*elbv2.Options)) (*elbv2.DeregisterTargetsOutput, error)
+	DescribeListeners(ctx context.Context, params *elbv2.DescribeListenersInput, optFns ...func(*elbv2.Options)) (*elbv2.DescribeListenersOutput, error)
+	DescribeLoadBalancerAttributes(ctx context.Context, params *elbv2.DescribeLoadBalancerAttributesInput, optFns ...func(*elbv2.Options)) (*elbv2.DescribeLoadBalancerAttributesOutput, error)
+	DescribeLoadBalancers(ctx context.Context, params *elbv2.DescribeLoadBalancersInput, optFns ...func(*elbv2.Options)) (*elbv2.DescribeLoadBalancersOutput, error)
+	DescribeTags(ctx context.Context, params *elbv2.DescribeTagsInput, optFns ...func(*elbv2.Options)) (*elbv2.DescribeTagsOutput, error)
+	DescribeTargetGroups(ctx context.Context, params *elbv2.DescribeTargetGroupsInput, optFns ...func(*elbv2.Options)) (*elbv2.DescribeTargetGroupsOutput, error)
+	DescribeTargetHealth(ctx context.Context, params *elbv2.DescribeTargetHealthInput, optFns ...func(*elbv2.Options)) (*elbv2.DescribeTargetHealthOutput, error)
+	ModifyListener(ctx context.Context, params *elbv2.ModifyListenerInput, optFns ...func(*elbv2.Options)) (*elbv2.ModifyListenerOutput, error)
+	ModifyLoadBalancerAttributes(ctx context.Context, params *elbv2.ModifyLoadBalancerAttributesInput, optFns ...func(*elbv2.Options)) (*elbv2.ModifyLoadBalancerAttributesOutput, error)
+	ModifyTargetGroupAttributes(ctx context.Context, params *elbv2.ModifyTargetGroupAttributesInput, optFns ...func(*elbv2.Options)) (*elbv2.ModifyTargetGroupAttributesOutput, error)
+	RegisterTargets(ctx context.Context, params *elbv2.RegisterTargetsInput, optFns ...func(*elbv2.Options)) (*elbv2.RegisterTargetsOutput, error)
+	RemoveTags(ctx context.Context, params *elbv2.RemoveTagsInput, optFns ...func(*elbv2.Options)) (*elbv2.RemoveTagsOutput, error)
+	SetSecurityGroups(ctx context.Context, params *elbv2.SetSecurityGroupsInput, optFns ...func(*elbv2.Options)) (*elbv2.SetSecurityGroupsOutput, error)
+	SetSubnets(ctx context.Context, params *elbv2.SetSubnetsInput, optFns ...func(*elbv2.Options)) (*elbv2.SetSubnetsOutput, error)
+
+	// CAPA Custom function
+	DescribeLoadBalancersPages(ctx context.Context, input *elbv2.DescribeLoadBalancersInput, fn func(*elbv2.DescribeLoadBalancersOutput)) error
+	WaitUntilLoadBalancerAvailable(ctx context.Context, input *elbv2.DescribeLoadBalancersInput, maxWait time.Duration) error
+}
+
+// ResourceGroupsTaggingAPIAPI is the subset of the AWS ResourceGroupsTaggingAPI API used by CAPA.
+type ResourceGroupsTaggingAPIAPI interface {
+	GetResources(ctx context.Context, params *rgapi.GetResourcesInput, optFns ...func(*rgapi.Options)) (*rgapi.GetResourcesOutput, error)
+
+	GetResourcesPages(ctx context.Context, input *rgapi.GetResourcesInput, fn func(*rgapi.GetResourcesOutput)) error
+}
+
+// ELBClient is a wrapper over elb.Client for implementing custom methods of ELBAPI.
+type ELBClient struct {
+	*elb.Client
+}
+
+// ELBV2Client is a wrapper over elbv2.Client for implementing custom methods of ELBV2API.
+type ELBV2Client struct {
+	*elbv2.Client
+}
+
+// ResourceGroupsTaggingAPIClient is a wrapper over rgapi.Client for implementing custom methods of ResourceGroupsTaggingAPI.
+type ResourceGroupsTaggingAPIClient struct {
+	*rgapi.Client
+}
+
 // NewService returns a new service given the api clients.
 func NewService(elbScope scope.ELBScope) *Service {
 	return &Service{
-		scope:                 elbScope,
-		EC2Client:             scope.NewEC2Client(elbScope, elbScope, elbScope, elbScope.InfraCluster()),
-		ELBClient:             scope.NewELBClient(elbScope, elbScope, elbScope, elbScope.InfraCluster()),
-		ELBV2Client:           scope.NewELBv2Client(elbScope, elbScope, elbScope, elbScope.InfraCluster()),
-		ResourceTaggingClient: scope.NewResourgeTaggingClient(elbScope, elbScope, elbScope, elbScope.InfraCluster()),
-		netService:            network.NewService(elbScope.(scope.NetworkScope)),
+		scope:     elbScope,
+		EC2Client: scope.NewEC2Client(elbScope, elbScope, elbScope, elbScope.InfraCluster()),
+		ELBClient: &ELBClient{
+			Client: scope.NewELBClient(elbScope, elbScope, elbScope, elbScope.InfraCluster()),
+		},
+		ELBV2Client: &ELBV2Client{
+			Client: scope.NewELBv2Client(elbScope, elbScope, elbScope, elbScope.InfraCluster()),
+		},
+		ResourceTaggingClient: &ResourceGroupsTaggingAPIClient{
+			Client: scope.NewResourgeTaggingClient(elbScope, elbScope, elbScope, elbScope.InfraCluster()),
+		},
+		netService: network.NewService(elbScope.(scope.NetworkScope)),
 	}
 }
diff --git a/pkg/cloud/services/gc/cleanup.go b/pkg/cloud/services/gc/cleanup.go
index 27fe88600..7bbafaaf5 100644
--- a/pkg/cloud/services/gc/cleanup.go
+++ b/pkg/cloud/services/gc/cleanup.go
@@ -22,9 +22,10 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/arn"
-	rgapi "github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/aws/arn"
+	rgapi "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi"
+	rgapitypes "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi/types"
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/annotations"
@@ -100,15 +101,15 @@ func (s *Service) defaultGetResources(ctx context.Context) ([]*AWSResource, erro
 
 	awsInput := rgapi.GetResourcesInput{
 		ResourceTypeFilters: nil,
-		TagFilters: []*rgapi.TagFilter{
+		TagFilters: []rgapitypes.TagFilter{
 			{
 				Key:    aws.String(serviceTag),
-				Values: []*string{aws.String(string(infrav1.ResourceLifecycleOwned))},
+				Values: []string{string(infrav1.ResourceLifecycleOwned)},
 			},
 		},
 	}
 
-	awsOutput, err := s.resourceTaggingClient.GetResourcesWithContext(ctx, &awsInput)
+	awsOutput, err := s.resourceTaggingClient.GetResources(ctx, &awsInput)
 	if err != nil {
 		return nil, fmt.Errorf("getting tagged resources: %w", err)
 	}
diff --git a/pkg/cloud/services/gc/compose.go b/pkg/cloud/services/gc/compose.go
index 08e0b5969..f910bef41 100644
--- a/pkg/cloud/services/gc/compose.go
+++ b/pkg/cloud/services/gc/compose.go
@@ -19,7 +19,7 @@ package gc
 import (
 	"fmt"
 
-	"github.com/aws/aws-sdk-go/aws/arn"
+	"github.com/aws/aws-sdk-go-v2/aws/arn"
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
 )
diff --git a/pkg/cloud/services/gc/loadbalancer.go b/pkg/cloud/services/gc/loadbalancer.go
index d649aaa2a..2d9e7d64c 100644
--- a/pkg/cloud/services/gc/loadbalancer.go
+++ b/pkg/cloud/services/gc/loadbalancer.go
@@ -21,9 +21,9 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/elb"
-	"github.com/aws/aws-sdk-go/service/elbv2"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	elb "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing"
+	elbv2 "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2"
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/converters"
@@ -80,7 +80,7 @@ func (s *Service) deleteTargetGroups(ctx context.Context, resources []*AWSResour
 }
 
 func (s *Service) isELBResourceToDelete(resource *AWSResource, resourceName string) bool {
-	if !s.isMatchingResource(resource, elb.ServiceName, resourceName) {
+	if !s.isMatchingResource(resource, elbService, resourceName) {
 		return false
 	}
 
@@ -98,7 +98,7 @@ func (s *Service) deleteLoadBalancerV2(ctx context.Context, lbARN string) error
 	}
 
 	s.scope.Debug("Deleting v2 load balancer", "arn", lbARN)
-	if _, err := s.elbv2Client.DeleteLoadBalancerWithContext(ctx, &input); err != nil {
+	if _, err := s.elbv2Client.DeleteLoadBalancer(ctx, &input); err != nil {
 		return fmt.Errorf("deleting v2 load balancer: %w", err)
 	}
 
@@ -111,7 +111,7 @@ func (s *Service) deleteLoadBalancer(ctx context.Context, name string) error {
 	}
 
 	s.scope.Debug("Deleting classic load balancer", "name", name)
-	if _, err := s.elbClient.DeleteLoadBalancerWithContext(ctx, &input); err != nil {
+	if _, err := s.elbClient.DeleteLoadBalancer(ctx, &input); err != nil {
 		return fmt.Errorf("deleting classic load balancer: %w", err)
 	}
 
@@ -124,7 +124,7 @@ func (s *Service) deleteTargetGroup(ctx context.Context, targetGroupARN string)
 	}
 
 	s.scope.Debug("Deleting target group", "arn", targetGroupARN)
-	if _, err := s.elbv2Client.DeleteTargetGroupWithContext(ctx, &input); err != nil {
+	if _, err := s.elbv2Client.DeleteTargetGroup(ctx, &input); err != nil {
 		return fmt.Errorf("deleting target group: %w", err)
 	}
 
@@ -134,14 +134,13 @@ func (s *Service) deleteTargetGroup(ctx context.Context, targetGroupARN string)
 // describeLoadBalancers gets all elastic LBs.
 func (s *Service) describeLoadBalancers(ctx context.Context) ([]string, error) {
 	var names []string
-	err := s.elbClient.DescribeLoadBalancersPagesWithContext(ctx, &elb.DescribeLoadBalancersInput{}, func(r *elb.DescribeLoadBalancersOutput, last bool) bool {
+	err := s.elbClient.DescribeLoadBalancersPages(ctx, &elb.DescribeLoadBalancersInput{}, func(r *elb.DescribeLoadBalancersOutput) {
 		for _, lb := range r.LoadBalancerDescriptions {
 			names = append(names, *lb.LoadBalancerName)
 		}
-		return true
 	})
 	if err != nil {
-		return nil, fmt.Errorf("describe load balancer error: %w", err)
+		return nil, err
 	}
 
 	return names, nil
@@ -150,21 +149,20 @@ func (s *Service) describeLoadBalancers(ctx context.Context) ([]string, error) {
 // describeLoadBalancersV2 gets all network and application LBs.
 func (s *Service) describeLoadBalancersV2(ctx context.Context) ([]string, error) {
 	var arns []string
-	err := s.elbv2Client.DescribeLoadBalancersPagesWithContext(ctx, &elbv2.DescribeLoadBalancersInput{}, func(r *elbv2.DescribeLoadBalancersOutput, last bool) bool {
+	err := s.elbv2Client.DescribeLoadBalancersPages(ctx, &elbv2.DescribeLoadBalancersInput{}, func(r *elbv2.DescribeLoadBalancersOutput) {
 		for _, lb := range r.LoadBalancers {
 			arns = append(arns, *lb.LoadBalancerArn)
 		}
-		return true
 	})
 	if err != nil {
-		return nil, fmt.Errorf("describe load balancer v2 error: %w", err)
+		return nil, err
 	}
 
 	return arns, nil
 }
 
 func (s *Service) describeTargetgroups(ctx context.Context) ([]string, error) {
-	groups, err := s.elbv2Client.DescribeTargetGroupsWithContext(ctx, &elbv2.DescribeTargetGroupsInput{})
+	groups, err := s.elbv2Client.DescribeTargetGroups(ctx, &elbv2.DescribeTargetGroupsInput{})
 	if err != nil {
 		return nil, fmt.Errorf("describe target groups error: %w", err)
 	}
@@ -214,7 +212,7 @@ func (s *Service) filterProviderOwnedLB(ctx context.Context, names []string) ([]
 	var resources []*AWSResource
 	lbChunks := chunkResources(names)
 	for _, chunk := range lbChunks {
-		output, err := s.elbClient.DescribeTagsWithContext(ctx, &elb.DescribeTagsInput{LoadBalancerNames: aws.StringSlice(chunk)})
+		output, err := s.elbClient.DescribeTags(ctx, &elb.DescribeTagsInput{LoadBalancerNames: chunk})
 		if err != nil {
 			return nil, fmt.Errorf("describe tags of loadbalancers: %w", err)
 		}
@@ -243,7 +241,7 @@ func (s *Service) filterProviderOwnedLBV2(ctx context.Context, arns []string) ([
 	var resources []*AWSResource
 	lbChunks := chunkResources(arns)
 	for _, chunk := range lbChunks {
-		output, err := s.elbv2Client.DescribeTagsWithContext(ctx, &elbv2.DescribeTagsInput{ResourceArns: aws.StringSlice(chunk)})
+		output, err := s.elbv2Client.DescribeTags(ctx, &elbv2.DescribeTagsInput{ResourceArns: chunk})
 		if err != nil {
 			return nil, fmt.Errorf("describe tags of v2 loadbalancers: %w", err)
 		}
diff --git a/pkg/cloud/services/gc/options.go b/pkg/cloud/services/gc/options.go
index 445977bcd..75beb67e3 100644
--- a/pkg/cloud/services/gc/options.go
+++ b/pkg/cloud/services/gc/options.go
@@ -18,30 +18,29 @@ package gc
 
 import (
 	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
-	"github.com/aws/aws-sdk-go/service/elb/elbiface"
-	"github.com/aws/aws-sdk-go/service/elbv2/elbv2iface"
-	"github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi/resourcegroupstaggingapiiface"
+
+	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/elb"
 )
 
 // ServiceOption is an option for creating the service.
 type ServiceOption func(*Service)
 
 // withELBClient is an option for specifying a AWS ELB Client.
-func withELBClient(client elbiface.ELBAPI) ServiceOption {
+func withELBClient(client elb.ELBAPI) ServiceOption {
 	return func(s *Service) {
 		s.elbClient = client
 	}
 }
 
 // withELBv2Client is an option for specifying a AWS ELBv2 Client.
-func withELBv2Client(client elbv2iface.ELBV2API) ServiceOption {
+func withELBv2Client(client elb.ELBV2API) ServiceOption {
 	return func(s *Service) {
 		s.elbv2Client = client
 	}
 }
 
 // withResourceTaggingClient is an option for specifying a AWS Resource Tagging Client.
-func withResourceTaggingClient(client resourcegroupstaggingapiiface.ResourceGroupsTaggingAPIAPI) ServiceOption {
+func withResourceTaggingClient(client elb.ResourceGroupsTaggingAPIAPI) ServiceOption {
 	return func(s *Service) {
 		s.resourceTaggingClient = client
 	}
diff --git a/pkg/cloud/services/gc/service.go b/pkg/cloud/services/gc/service.go
index 27b48d653..2eda2f695 100644
--- a/pkg/cloud/services/gc/service.go
+++ b/pkg/cloud/services/gc/service.go
@@ -20,22 +20,20 @@ package gc
 import (
 	"context"
 
-	"github.com/aws/aws-sdk-go/aws/arn"
+	"github.com/aws/aws-sdk-go-v2/aws/arn"
 	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
-	"github.com/aws/aws-sdk-go/service/elb/elbiface"
-	"github.com/aws/aws-sdk-go/service/elbv2/elbv2iface"
-	"github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi/resourcegroupstaggingapiiface"
 
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope"
+	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/elb"
 )
 
 // Service is used to perform operations against a tenant/workload/child cluster.
 type Service struct {
 	scope                 cloud.ClusterScoper
-	elbClient             elbiface.ELBAPI
-	elbv2Client           elbv2iface.ELBV2API
-	resourceTaggingClient resourcegroupstaggingapiiface.ResourceGroupsTaggingAPIAPI
+	elbClient             elb.ELBAPI
+	elbv2Client           elb.ELBV2API
+	resourceTaggingClient elb.ResourceGroupsTaggingAPIAPI
 	ec2Client             ec2iface.EC2API
 	cleanupFuncs          ResourceCleanupFuncs
 	collectFuncs          ResourceCollectFuncs
@@ -44,13 +42,19 @@ type Service struct {
 // NewService creates a new Service.
 func NewService(clusterScope cloud.ClusterScoper, opts ...ServiceOption) *Service {
 	svc := &Service{
-		scope:                 clusterScope,
-		elbClient:             scope.NewELBClient(clusterScope, clusterScope, clusterScope, clusterScope.InfraCluster()),
-		elbv2Client:           scope.NewELBv2Client(clusterScope, clusterScope, clusterScope, clusterScope.InfraCluster()),
-		resourceTaggingClient: scope.NewResourgeTaggingClient(clusterScope, clusterScope, clusterScope, clusterScope.InfraCluster()),
-		ec2Client:             scope.NewEC2Client(clusterScope, clusterScope, clusterScope, clusterScope.InfraCluster()),
-		cleanupFuncs:          ResourceCleanupFuncs{},
-		collectFuncs:          ResourceCollectFuncs{},
+		scope: clusterScope,
+		elbClient: &elb.ELBClient{
+			Client: scope.NewELBClient(clusterScope, clusterScope, clusterScope, clusterScope.InfraCluster()),
+		},
+		elbv2Client: &elb.ELBV2Client{
+			Client: scope.NewELBv2Client(clusterScope, clusterScope, clusterScope, clusterScope.InfraCluster()),
+		},
+		resourceTaggingClient: &elb.ResourceGroupsTaggingAPIClient{
+			Client: scope.NewResourgeTaggingClient(clusterScope, clusterScope, clusterScope, clusterScope.InfraCluster()),
+		},
+		ec2Client:    scope.NewEC2Client(clusterScope, clusterScope, clusterScope, clusterScope.InfraCluster()),
+		cleanupFuncs: ResourceCleanupFuncs{},
+		collectFuncs: ResourceCollectFuncs{},
 	}
 	addDefaultCleanupFuncs(svc)
 
diff --git a/pkg/cloud/services/interfaces.go b/pkg/cloud/services/interfaces.go
index 2641f0eec..385572d10 100644
--- a/pkg/cloud/services/interfaces.go
+++ b/pkg/cloud/services/interfaces.go
@@ -112,14 +112,14 @@ type SecretInterface interface {
 // ELBInterface encapsulates the methods exposed to the cluster and machine
 // controller.
 type ELBInterface interface {
-	DeleteLoadbalancers() error
-	ReconcileLoadbalancers() error
-	IsInstanceRegisteredWithAPIServerELB(i *infrav1.Instance) (bool, error)
-	IsInstanceRegisteredWithAPIServerLB(i *infrav1.Instance, lb *infrav1.AWSLoadBalancerSpec) ([]string, bool, error)
-	DeregisterInstanceFromAPIServerELB(i *infrav1.Instance) error
-	DeregisterInstanceFromAPIServerLB(targetGroupArn string, i *infrav1.Instance) error
-	RegisterInstanceWithAPIServerELB(i *infrav1.Instance) error
-	RegisterInstanceWithAPIServerLB(i *infrav1.Instance, lb *infrav1.AWSLoadBalancerSpec) error
+	DeleteLoadbalancers(ctx context.Context) error
+	ReconcileLoadbalancers(ctx context.Context) error
+	IsInstanceRegisteredWithAPIServerELB(ctx context.Context, i *infrav1.Instance) (bool, error)
+	IsInstanceRegisteredWithAPIServerLB(ctx context.Context, i *infrav1.Instance, lb *infrav1.AWSLoadBalancerSpec) ([]string, bool, error)
+	DeregisterInstanceFromAPIServerELB(ctx context.Context, i *infrav1.Instance) error
+	DeregisterInstanceFromAPIServerLB(ctx context.Context, targetGroupArn string, i *infrav1.Instance) error
+	RegisterInstanceWithAPIServerELB(ctx context.Context, i *infrav1.Instance) error
+	RegisterInstanceWithAPIServerLB(ctx context.Context, i *infrav1.Instance, lb *infrav1.AWSLoadBalancerSpec) error
 }
 
 // NetworkInterface encapsulates the methods exposed to the cluster
diff --git a/pkg/cloud/services/mock_services/elb_interface_mock.go b/pkg/cloud/services/mock_services/elb_interface_mock.go
index 0af85fb04..118cadf53 100644
--- a/pkg/cloud/services/mock_services/elb_interface_mock.go
+++ b/pkg/cloud/services/mock_services/elb_interface_mock.go
@@ -21,6 +21,7 @@ limitations under the License.
 package mock_services
 
 import (
+	context "context"
 	reflect "reflect"
 
 	gomock "github.com/golang/mock/gomock"
@@ -51,66 +52,66 @@ func (m *MockELBInterface) EXPECT() *MockELBInterfaceMockRecorder {
 }
 
 // DeleteLoadbalancers mocks base method.
-func (m *MockELBInterface) DeleteLoadbalancers() error {
+func (m *MockELBInterface) DeleteLoadbalancers(arg0 context.Context) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLoadbalancers")
+	ret := m.ctrl.Call(m, "DeleteLoadbalancers", arg0)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // DeleteLoadbalancers indicates an expected call of DeleteLoadbalancers.
-func (mr *MockELBInterfaceMockRecorder) DeleteLoadbalancers() *gomock.Call {
+func (mr *MockELBInterfaceMockRecorder) DeleteLoadbalancers(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadbalancers", reflect.TypeOf((*MockELBInterface)(nil).DeleteLoadbalancers))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadbalancers", reflect.TypeOf((*MockELBInterface)(nil).DeleteLoadbalancers), arg0)
 }
 
 // DeregisterInstanceFromAPIServerELB mocks base method.
-func (m *MockELBInterface) DeregisterInstanceFromAPIServerELB(arg0 *v1beta2.Instance) error {
+func (m *MockELBInterface) DeregisterInstanceFromAPIServerELB(arg0 context.Context, arg1 *v1beta2.Instance) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeregisterInstanceFromAPIServerELB", arg0)
+	ret := m.ctrl.Call(m, "DeregisterInstanceFromAPIServerELB", arg0, arg1)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // DeregisterInstanceFromAPIServerELB indicates an expected call of DeregisterInstanceFromAPIServerELB.
-func (mr *MockELBInterfaceMockRecorder) DeregisterInstanceFromAPIServerELB(arg0 interface{}) *gomock.Call {
+func (mr *MockELBInterfaceMockRecorder) DeregisterInstanceFromAPIServerELB(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterInstanceFromAPIServerELB", reflect.TypeOf((*MockELBInterface)(nil).DeregisterInstanceFromAPIServerELB), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterInstanceFromAPIServerELB", reflect.TypeOf((*MockELBInterface)(nil).DeregisterInstanceFromAPIServerELB), arg0, arg1)
 }
 
 // DeregisterInstanceFromAPIServerLB mocks base method.
-func (m *MockELBInterface) DeregisterInstanceFromAPIServerLB(arg0 string, arg1 *v1beta2.Instance) error {
+func (m *MockELBInterface) DeregisterInstanceFromAPIServerLB(arg0 context.Context, arg1 string, arg2 *v1beta2.Instance) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeregisterInstanceFromAPIServerLB", arg0, arg1)
+	ret := m.ctrl.Call(m, "DeregisterInstanceFromAPIServerLB", arg0, arg1, arg2)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // DeregisterInstanceFromAPIServerLB indicates an expected call of DeregisterInstanceFromAPIServerLB.
-func (mr *MockELBInterfaceMockRecorder) DeregisterInstanceFromAPIServerLB(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockELBInterfaceMockRecorder) DeregisterInstanceFromAPIServerLB(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterInstanceFromAPIServerLB", reflect.TypeOf((*MockELBInterface)(nil).DeregisterInstanceFromAPIServerLB), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterInstanceFromAPIServerLB", reflect.TypeOf((*MockELBInterface)(nil).DeregisterInstanceFromAPIServerLB), arg0, arg1, arg2)
 }
 
 // IsInstanceRegisteredWithAPIServerELB mocks base method.
-func (m *MockELBInterface) IsInstanceRegisteredWithAPIServerELB(arg0 *v1beta2.Instance) (bool, error) {
+func (m *MockELBInterface) IsInstanceRegisteredWithAPIServerELB(arg0 context.Context, arg1 *v1beta2.Instance) (bool, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "IsInstanceRegisteredWithAPIServerELB", arg0)
+	ret := m.ctrl.Call(m, "IsInstanceRegisteredWithAPIServerELB", arg0, arg1)
 	ret0, _ := ret[0].(bool)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // IsInstanceRegisteredWithAPIServerELB indicates an expected call of IsInstanceRegisteredWithAPIServerELB.
-func (mr *MockELBInterfaceMockRecorder) IsInstanceRegisteredWithAPIServerELB(arg0 interface{}) *gomock.Call {
+func (mr *MockELBInterfaceMockRecorder) IsInstanceRegisteredWithAPIServerELB(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsInstanceRegisteredWithAPIServerELB", reflect.TypeOf((*MockELBInterface)(nil).IsInstanceRegisteredWithAPIServerELB), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsInstanceRegisteredWithAPIServerELB", reflect.TypeOf((*MockELBInterface)(nil).IsInstanceRegisteredWithAPIServerELB), arg0, arg1)
 }
 
 // IsInstanceRegisteredWithAPIServerLB mocks base method.
-func (m *MockELBInterface) IsInstanceRegisteredWithAPIServerLB(arg0 *v1beta2.Instance, arg1 *v1beta2.AWSLoadBalancerSpec) ([]string, bool, error) {
+func (m *MockELBInterface) IsInstanceRegisteredWithAPIServerLB(arg0 context.Context, arg1 *v1beta2.Instance, arg2 *v1beta2.AWSLoadBalancerSpec) ([]string, bool, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "IsInstanceRegisteredWithAPIServerLB", arg0, arg1)
+	ret := m.ctrl.Call(m, "IsInstanceRegisteredWithAPIServerLB", arg0, arg1, arg2)
 	ret0, _ := ret[0].([]string)
 	ret1, _ := ret[1].(bool)
 	ret2, _ := ret[2].(error)
@@ -118,49 +119,49 @@ func (m *MockELBInterface) IsInstanceRegisteredWithAPIServerLB(arg0 *v1beta2.Ins
 }
 
 // IsInstanceRegisteredWithAPIServerLB indicates an expected call of IsInstanceRegisteredWithAPIServerLB.
-func (mr *MockELBInterfaceMockRecorder) IsInstanceRegisteredWithAPIServerLB(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockELBInterfaceMockRecorder) IsInstanceRegisteredWithAPIServerLB(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsInstanceRegisteredWithAPIServerLB", reflect.TypeOf((*MockELBInterface)(nil).IsInstanceRegisteredWithAPIServerLB), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsInstanceRegisteredWithAPIServerLB", reflect.TypeOf((*MockELBInterface)(nil).IsInstanceRegisteredWithAPIServerLB), arg0, arg1, arg2)
 }
 
 // ReconcileLoadbalancers mocks base method.
-func (m *MockELBInterface) ReconcileLoadbalancers() error {
+func (m *MockELBInterface) ReconcileLoadbalancers(arg0 context.Context) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReconcileLoadbalancers")
+	ret := m.ctrl.Call(m, "ReconcileLoadbalancers", arg0)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // ReconcileLoadbalancers indicates an expected call of ReconcileLoadbalancers.
-func (mr *MockELBInterfaceMockRecorder) ReconcileLoadbalancers() *gomock.Call {
+func (mr *MockELBInterfaceMockRecorder) ReconcileLoadbalancers(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileLoadbalancers", reflect.TypeOf((*MockELBInterface)(nil).ReconcileLoadbalancers))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileLoadbalancers", reflect.TypeOf((*MockELBInterface)(nil).ReconcileLoadbalancers), arg0)
 }
 
 // RegisterInstanceWithAPIServerELB mocks base method.
-func (m *MockELBInterface) RegisterInstanceWithAPIServerELB(arg0 *v1beta2.Instance) error {
+func (m *MockELBInterface) RegisterInstanceWithAPIServerELB(arg0 context.Context, arg1 *v1beta2.Instance) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RegisterInstanceWithAPIServerELB", arg0)
+	ret := m.ctrl.Call(m, "RegisterInstanceWithAPIServerELB", arg0, arg1)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // RegisterInstanceWithAPIServerELB indicates an expected call of RegisterInstanceWithAPIServerELB.
-func (mr *MockELBInterfaceMockRecorder) RegisterInstanceWithAPIServerELB(arg0 interface{}) *gomock.Call {
+func (mr *MockELBInterfaceMockRecorder) RegisterInstanceWithAPIServerELB(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInstanceWithAPIServerELB", reflect.TypeOf((*MockELBInterface)(nil).RegisterInstanceWithAPIServerELB), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInstanceWithAPIServerELB", reflect.TypeOf((*MockELBInterface)(nil).RegisterInstanceWithAPIServerELB), arg0, arg1)
 }
 
 // RegisterInstanceWithAPIServerLB mocks base method.
-func (m *MockELBInterface) RegisterInstanceWithAPIServerLB(arg0 *v1beta2.Instance, arg1 *v1beta2.AWSLoadBalancerSpec) error {
+func (m *MockELBInterface) RegisterInstanceWithAPIServerLB(arg0 context.Context, arg1 *v1beta2.Instance, arg2 *v1beta2.AWSLoadBalancerSpec) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RegisterInstanceWithAPIServerLB", arg0, arg1)
+	ret := m.ctrl.Call(m, "RegisterInstanceWithAPIServerLB", arg0, arg1, arg2)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // RegisterInstanceWithAPIServerLB indicates an expected call of RegisterInstanceWithAPIServerLB.
-func (mr *MockELBInterfaceMockRecorder) RegisterInstanceWithAPIServerLB(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockELBInterfaceMockRecorder) RegisterInstanceWithAPIServerLB(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInstanceWithAPIServerLB", reflect.TypeOf((*MockELBInterface)(nil).RegisterInstanceWithAPIServerLB), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInstanceWithAPIServerLB", reflect.TypeOf((*MockELBInterface)(nil).RegisterInstanceWithAPIServerLB), arg0, arg1, arg2)
 }
diff --git a/pkg/cloud/throttle/throttle.go b/pkg/cloud/throttle/throttle.go
index 128bb121a..5e3532317 100644
--- a/pkg/cloud/throttle/throttle.go
+++ b/pkg/cloud/throttle/throttle.go
@@ -172,7 +172,12 @@ func getServiceLimiterMiddleware(limiter *ServiceLimiter) middleware.FinalizeMid
 
 		out, metadata, err := handler.HandleFinalize(ctx, input)
 		smithyErr := awserrors.ParseSmithyError(err)
-		limiter.ReviewResponseV2(ctx, smithyErr.ErrorCode())
+
+		if smithyErr != nil {
+			limiter.ReviewResponseV2(ctx, smithyErr.ErrorCode())
+			return out, metadata, err
+		}
+
 		return out, metadata, err
 	})
 }



Test patch:
diff --git a/controllers/awscluster_controller_test.go b/controllers/awscluster_controller_test.go
index f5af06044..d245b7230 100644
--- a/controllers/awscluster_controller_test.go
+++ b/controllers/awscluster_controller_test.go
@@ -21,9 +21,10 @@ import (
 	"testing"
 	"time"
 
-	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	elb "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing"
+	elbtypes "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing/types"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/elb"
 	"github.com/golang/mock/gomock"
 	. "github.com/onsi/gomega"
 	"github.com/pkg/errors"
@@ -1379,26 +1380,26 @@ func mockedCallsForMissingEverything(m *mocks.MockEC2APIMockRecorder, e *mocks.M
 		SubnetId:     aws.String("subnet-2"),
 	})).Return(&ec2.AssociateRouteTableOutput{}, nil)
 
-	e.DescribeLoadBalancers(gomock.Eq(&elb.DescribeLoadBalancersInput{
-		LoadBalancerNames: aws.StringSlice([]string{"test-cluster-apiserver"}),
+	e.DescribeLoadBalancers(gomock.Any(), gomock.Eq(&elb.DescribeLoadBalancersInput{
+		LoadBalancerNames: []string{"test-cluster-apiserver"},
 	})).Return(&elb.DescribeLoadBalancersOutput{
-		LoadBalancerDescriptions: []*elb.LoadBalancerDescription{},
+		LoadBalancerDescriptions: []elbtypes.LoadBalancerDescription{},
 	}, nil)
 
-	e.CreateLoadBalancer(gomock.Eq(&elb.CreateLoadBalancerInput{
-		Listeners: []*elb.Listener{
+	e.CreateLoadBalancer(gomock.Any(), gomock.Eq(&elb.CreateLoadBalancerInput{
+		Listeners: []elbtypes.Listener{
 			{
-				InstancePort:     aws.Int64(6443),
+				InstancePort:     aws.Int32(6443),
 				InstanceProtocol: aws.String("TCP"),
-				LoadBalancerPort: aws.Int64(6443),
+				LoadBalancerPort: 6443,
 				Protocol:         aws.String("TCP"),
 			},
 		},
 		LoadBalancerName: aws.String("test-cluster-apiserver"),
 		Scheme:           aws.String("internet-facing"),
-		SecurityGroups:   aws.StringSlice([]string{"sg-apiserver-lb"}),
-		Subnets:          aws.StringSlice([]string{"subnet-2"}),
-		Tags: []*elb.Tag{
+		SecurityGroups:   []string{"sg-apiserver-lb"},
+		Subnets:          []string{"subnet-2"},
+		Tags: []elbtypes.Tag{
 			{
 				Key:   aws.String("Name"),
 				Value: aws.String("test-cluster-apiserver"),
@@ -1416,14 +1417,14 @@ func mockedCallsForMissingEverything(m *mocks.MockEC2APIMockRecorder, e *mocks.M
 		DNSName: aws.String("unittest24.de"),
 	}, nil)
 
-	e.ConfigureHealthCheck(gomock.Eq(&elb.ConfigureHealthCheckInput{
+	e.ConfigureHealthCheck(gomock.Any(), gomock.Eq(&elb.ConfigureHealthCheckInput{
 		LoadBalancerName: aws.String("test-cluster-apiserver"),
-		HealthCheck: &elb.HealthCheck{
+		HealthCheck: &elbtypes.HealthCheck{
 			Target:             aws.String("TCP:6443"),
-			Interval:           aws.Int64(10),
-			Timeout:            aws.Int64(5),
-			HealthyThreshold:   aws.Int64(5),
-			UnhealthyThreshold: aws.Int64(3),
+			Interval:           aws.Int32(10),
+			Timeout:            aws.Int32(5),
+			HealthyThreshold:   aws.Int32(5),
+			UnhealthyThreshold: aws.Int32(3),
 		},
 	})).Return(&elb.ConfigureHealthCheckOutput{}, nil)
 }
diff --git a/controllers/awscluster_controller_unit_test.go b/controllers/awscluster_controller_unit_test.go
index 944d302da..6c89b0508 100644
--- a/controllers/awscluster_controller_unit_test.go
+++ b/controllers/awscluster_controller_unit_test.go
@@ -196,7 +196,7 @@ func TestAWSClusterReconcileOperations(t *testing.T) {
 				g := NewWithT(t)
 				runningCluster := func() {
 					ec2Svc.EXPECT().ReconcileBastion().Return(nil)
-					elbSvc.EXPECT().ReconcileLoadbalancers().Return(nil)
+					elbSvc.EXPECT().ReconcileLoadbalancers(gomock.Any()).Return(nil)
 					networkSvc.EXPECT().ReconcileNetwork().Return(nil)
 					sgSvc.EXPECT().ReconcileSecurityGroups().Return(nil)
 				}
@@ -252,7 +252,7 @@ func TestAWSClusterReconcileOperations(t *testing.T) {
 				g := NewWithT(t)
 				runningCluster := func() {
 					ec2Svc.EXPECT().ReconcileBastion().Return(nil)
-					elbSvc.EXPECT().ReconcileLoadbalancers().Return(nil)
+					elbSvc.EXPECT().ReconcileLoadbalancers(gomock.Any()).Return(nil)
 					networkSvc.EXPECT().ReconcileNetwork().Return(nil)
 					sgSvc.EXPECT().ReconcileSecurityGroups().Return(nil)
 				}
@@ -352,7 +352,7 @@ func TestAWSClusterReconcileOperations(t *testing.T) {
 					networkSvc.EXPECT().ReconcileNetwork().Return(nil)
 					sgSvc.EXPECT().ReconcileSecurityGroups().Return(nil)
 					ec2Svc.EXPECT().ReconcileBastion().Return(nil)
-					elbSvc.EXPECT().ReconcileLoadbalancers().Return(expectedErr)
+					elbSvc.EXPECT().ReconcileLoadbalancers(gomock.Any()).Return(expectedErr)
 				}
 				csClient := setup(t, &awsCluster)
 				defer teardown()
@@ -376,7 +376,7 @@ func TestAWSClusterReconcileOperations(t *testing.T) {
 					networkSvc.EXPECT().ReconcileNetwork().Return(nil)
 					sgSvc.EXPECT().ReconcileSecurityGroups().Return(nil)
 					ec2Svc.EXPECT().ReconcileBastion().Return(nil)
-					elbSvc.EXPECT().ReconcileLoadbalancers().Return(nil)
+					elbSvc.EXPECT().ReconcileLoadbalancers(gomock.Any()).Return(nil)
 				}
 				csClient := setup(t, &awsCluster)
 				defer teardown()
@@ -399,7 +399,7 @@ func TestAWSClusterReconcileOperations(t *testing.T) {
 		t.Run("Reconcile success", func(t *testing.T) {
 			deleteCluster := func() {
 				ec2Svc.EXPECT().DeleteBastion().Return(nil)
-				elbSvc.EXPECT().DeleteLoadbalancers().Return(nil)
+				elbSvc.EXPECT().DeleteLoadbalancers(gomock.Any()).Return(nil)
 				networkSvc.EXPECT().DeleteNetwork().Return(nil)
 				sgSvc.EXPECT().DeleteSecurityGroups().Return(nil)
 			}
@@ -429,7 +429,7 @@ func TestAWSClusterReconcileOperations(t *testing.T) {
 				g := NewWithT(t)
 				deleteCluster := func() {
 					t.Helper()
-					elbSvc.EXPECT().DeleteLoadbalancers().Return(expectedErr)
+					elbSvc.EXPECT().DeleteLoadbalancers(gomock.Any()).Return(expectedErr)
 					ec2Svc.EXPECT().DeleteBastion().Return(nil)
 					networkSvc.EXPECT().DeleteNetwork().Return(nil)
 					sgSvc.EXPECT().DeleteSecurityGroups().Return(nil)
@@ -455,7 +455,7 @@ func TestAWSClusterReconcileOperations(t *testing.T) {
 				g := NewWithT(t)
 				deleteCluster := func() {
 					ec2Svc.EXPECT().DeleteBastion().Return(expectedErr)
-					elbSvc.EXPECT().DeleteLoadbalancers().Return(nil)
+					elbSvc.EXPECT().DeleteLoadbalancers(gomock.Any()).Return(nil)
 					networkSvc.EXPECT().DeleteNetwork().Return(nil)
 					sgSvc.EXPECT().DeleteSecurityGroups().Return(nil)
 				}
@@ -480,7 +480,7 @@ func TestAWSClusterReconcileOperations(t *testing.T) {
 				g := NewWithT(t)
 				deleteCluster := func() {
 					ec2Svc.EXPECT().DeleteBastion().Return(nil)
-					elbSvc.EXPECT().DeleteLoadbalancers().Return(nil)
+					elbSvc.EXPECT().DeleteLoadbalancers(gomock.Any()).Return(nil)
 					sgSvc.EXPECT().DeleteSecurityGroups().Return(expectedErr)
 					networkSvc.EXPECT().DeleteNetwork().Return(nil)
 				}
@@ -505,7 +505,7 @@ func TestAWSClusterReconcileOperations(t *testing.T) {
 				g := NewWithT(t)
 				deleteCluster := func() {
 					ec2Svc.EXPECT().DeleteBastion().Return(nil)
-					elbSvc.EXPECT().DeleteLoadbalancers().Return(nil)
+					elbSvc.EXPECT().DeleteLoadbalancers(gomock.Any()).Return(nil)
 					sgSvc.EXPECT().DeleteSecurityGroups().Return(nil)
 					networkSvc.EXPECT().DeleteNetwork().Return(expectedErr)
 				}
diff --git a/controllers/awsmachine_controller_test.go b/controllers/awsmachine_controller_test.go
index f7687ca0d..d9e2cecc2 100644
--- a/controllers/awsmachine_controller_test.go
+++ b/controllers/awsmachine_controller_test.go
@@ -22,9 +22,9 @@ import (
 	"testing"
 	"time"
 
+	elb "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing"
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/elb"
 	"github.com/golang/mock/gomock"
 	. "github.com/onsi/gomega"
 	"github.com/pkg/errors"
@@ -255,8 +255,8 @@ func TestAWSMachineReconcilerIntegrationTests(t *testing.T) {
 		expect := func(m *mocks.MockEC2APIMockRecorder, s *mock_services.MockSecretInterfaceMockRecorder, e *mocks.MockELBAPIMockRecorder) {
 			mockedCreateInstanceCalls(m)
 			mockedCreateSecretCall(s)
-			e.DescribeLoadBalancers(gomock.Eq(&elb.DescribeLoadBalancersInput{
-				LoadBalancerNames: aws.StringSlice([]string{"test-cluster-apiserver"}),
+			e.DescribeLoadBalancers(ctx, gomock.Eq(&elb.DescribeLoadBalancersInput{
+				LoadBalancerNames: []string{"test-cluster-apiserver"},
 			})).
 				Return(&elb.DescribeLoadBalancersOutput{}, nil)
 		}
diff --git a/controllers/awsmachine_controller_unit_test.go b/controllers/awsmachine_controller_unit_test.go
index c4166a50d..099eaebf0 100644
--- a/controllers/awsmachine_controller_unit_test.go
+++ b/controllers/awsmachine_controller_unit_test.go
@@ -663,7 +663,7 @@ func TestAWSMachineReconciler(t *testing.T) {
 					return elbSvc
 				}
 
-				elbSvc.EXPECT().IsInstanceRegisteredWithAPIServerELB(gomock.Any()).Return(true, nil)
+				elbSvc.EXPECT().IsInstanceRegisteredWithAPIServerELB(gomock.Any(), gomock.Any()).Return(true, nil)
 				secretSvc.EXPECT().UserData(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, nil).Times(1)
 				secretSvc.EXPECT().Create(gomock.Any(), gomock.Any()).Return("test", int32(1), nil).Times(1)
 				ec2Svc.EXPECT().GetInstanceSecurityGroups(gomock.Any()).Return(map[string][]string{"eid": {}}, nil).Times(1)
@@ -688,8 +688,8 @@ func TestAWSMachineReconciler(t *testing.T) {
 					return elbSvc
 				}
 
-				elbSvc.EXPECT().IsInstanceRegisteredWithAPIServerELB(gomock.Any()).Return(false, nil)
-				elbSvc.EXPECT().RegisterInstanceWithAPIServerELB(gomock.Any()).Return(nil)
+				elbSvc.EXPECT().IsInstanceRegisteredWithAPIServerELB(gomock.Any(), gomock.Any()).Return(false, nil)
+				elbSvc.EXPECT().RegisterInstanceWithAPIServerELB(gomock.Any(), gomock.Any()).Return(nil)
 				secretSvc.EXPECT().UserData(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, nil).Times(1)
 				secretSvc.EXPECT().Create(gomock.Any(), gomock.Any()).Return("test", int32(1), nil).Times(1)
 				ec2Svc.EXPECT().GetInstanceSecurityGroups(gomock.Any()).Return(map[string][]string{"eid": {}}, nil).Times(1)
@@ -787,7 +787,7 @@ func TestAWSMachineReconciler(t *testing.T) {
 
 				ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil)
 				ec2Svc.EXPECT().GetRunningInstanceByTags(gomock.Any()).Return(nil, nil)
-				elbSvc.EXPECT().IsInstanceRegisteredWithAPIServerELB(gomock.Any()).Return(false, errors.New("error describing ELB"))
+				elbSvc.EXPECT().IsInstanceRegisteredWithAPIServerELB(gomock.Any(), gomock.Any()).Return(false, errors.New("error describing ELB"))
 				secretSvc.EXPECT().UserData(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, nil).Times(1)
 				secretSvc.EXPECT().Create(gomock.Any(), gomock.Any()).Return("test", int32(1), nil).Times(1)
 
@@ -813,8 +813,8 @@ func TestAWSMachineReconciler(t *testing.T) {
 
 				ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil)
 				ec2Svc.EXPECT().GetRunningInstanceByTags(gomock.Any()).Return(nil, nil)
-				elbSvc.EXPECT().IsInstanceRegisteredWithAPIServerELB(gomock.Any()).Return(false, nil)
-				elbSvc.EXPECT().RegisterInstanceWithAPIServerELB(gomock.Any()).Return(errors.New("failed to attach ELB"))
+				elbSvc.EXPECT().IsInstanceRegisteredWithAPIServerELB(gomock.Any(), gomock.Any()).Return(false, nil)
+				elbSvc.EXPECT().RegisterInstanceWithAPIServerELB(gomock.Any(), gomock.Any()).Return(errors.New("failed to attach ELB"))
 				secretSvc.EXPECT().Create(gomock.Any(), gomock.Any()).Return("test", int32(1), nil).Times(1)
 				secretSvc.EXPECT().UserData(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, nil).Times(1)
 
@@ -1831,7 +1831,7 @@ func TestAWSMachineReconciler(t *testing.T) {
 					ec2Svc.EXPECT().GetRunningInstanceByTags(gomock.Any()).Return(&infrav1.Instance{
 						State: infrav1.InstanceStateTerminated,
 					}, nil)
-					elbSvc.EXPECT().IsInstanceRegisteredWithAPIServerELB(gomock.Any()).Return(false, errors.New("error describing ELB"))
+					elbSvc.EXPECT().IsInstanceRegisteredWithAPIServerELB(gomock.Any(), gomock.Any()).Return(false, errors.New("error describing ELB"))
 
 					_, err := reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
 					g.Expect(err).ToNot(BeNil())
@@ -1856,7 +1856,7 @@ func TestAWSMachineReconciler(t *testing.T) {
 					ec2Svc.EXPECT().GetRunningInstanceByTags(gomock.Any()).Return(&infrav1.Instance{
 						State: infrav1.InstanceStateTerminated,
 					}, nil)
-					elbSvc.EXPECT().IsInstanceRegisteredWithAPIServerELB(gomock.Any()).Return(false, nil)
+					elbSvc.EXPECT().IsInstanceRegisteredWithAPIServerELB(gomock.Any(), gomock.Any()).Return(false, nil)
 
 					_, err := reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
 					g.Expect(err).To(BeNil())
@@ -1881,8 +1881,8 @@ func TestAWSMachineReconciler(t *testing.T) {
 				ec2Svc.EXPECT().GetRunningInstanceByTags(gomock.Any()).Return(&infrav1.Instance{
 					State: infrav1.InstanceStateTerminated,
 				}, nil)
-				elbSvc.EXPECT().IsInstanceRegisteredWithAPIServerELB(gomock.Any()).Return(true, nil)
-				elbSvc.EXPECT().DeregisterInstanceFromAPIServerELB(gomock.Any()).Return(nil)
+				elbSvc.EXPECT().IsInstanceRegisteredWithAPIServerELB(gomock.Any(), gomock.Any()).Return(true, nil)
+				elbSvc.EXPECT().DeregisterInstanceFromAPIServerELB(gomock.Any(), gomock.Any()).Return(nil)
 
 				_, err := reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
 				g.Expect(err).To(BeNil())
@@ -1904,8 +1904,8 @@ func TestAWSMachineReconciler(t *testing.T) {
 				ec2Svc.EXPECT().GetRunningInstanceByTags(gomock.Any()).Return(&infrav1.Instance{
 					State: infrav1.InstanceStateTerminated,
 				}, nil)
-				elbSvc.EXPECT().IsInstanceRegisteredWithAPIServerELB(gomock.Any()).Return(true, nil)
-				elbSvc.EXPECT().DeregisterInstanceFromAPIServerELB(gomock.Any()).Return(errors.New("Duplicate access point name for load balancer"))
+				elbSvc.EXPECT().IsInstanceRegisteredWithAPIServerELB(gomock.Any(), gomock.Any()).Return(true, nil)
+				elbSvc.EXPECT().DeregisterInstanceFromAPIServerELB(gomock.Any(), gomock.Any()).Return(errors.New("Duplicate access point name for load balancer"))
 
 				_, err := reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
 				g.Expect(err).ToNot(BeNil())
diff --git a/controllers/helpers_test.go b/controllers/helpers_test.go
index 6e38590cd..d68669c40 100644
--- a/controllers/helpers_test.go
+++ b/controllers/helpers_test.go
@@ -16,12 +16,16 @@ limitations under the License.
 package controllers
 
 import (
+	"context"
 	"sort"
 	"testing"
+	"time"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/elb"
-	"github.com/aws/aws-sdk-go/service/elbv2"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	elb "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing"
+	elbtypes "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing/types"
+	elbv2 "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2"
+	elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types"
 	"github.com/golang/mock/gomock"
 	"github.com/google/go-cmp/cmp"
 	. "github.com/onsi/gomega"
@@ -29,6 +33,7 @@ import (
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope"
+	elbService "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/elb"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/test/helpers"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/test/mocks"
 	clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
@@ -42,26 +47,26 @@ var (
 	lbArn           = aws.String("loadbalancer::arn")
 	tgArn           = aws.String("arn::target-group")
 	describeLBInput = &elb.DescribeLoadBalancersInput{
-		LoadBalancerNames: aws.StringSlice([]string{"test-cluster-apiserver"}),
+		LoadBalancerNames: []string{"test-cluster-apiserver"},
 	}
 	describeLBAttributesInput = &elb.DescribeLoadBalancerAttributesInput{
 		LoadBalancerName: lbName,
 	}
 	describeLBOutput = &elb.DescribeLoadBalancersOutput{
-		LoadBalancerDescriptions: []*elb.LoadBalancerDescription{
+		LoadBalancerDescriptions: []elbtypes.LoadBalancerDescription{
 			{
 				Scheme:            aws.String(string(infrav1.ELBSchemeInternetFacing)),
-				Subnets:           []*string{aws.String("subnet-1")},
-				AvailabilityZones: []*string{aws.String("us-east-1a")},
+				Subnets:           []string{"subnet-1"},
+				AvailabilityZones: []string{"us-east-1a"},
 				VPCId:             aws.String("vpc-exists"),
 			},
 		},
 	}
 	describeLBOutputV2 = &elbv2.DescribeLoadBalancersOutput{
-		LoadBalancers: []*elbv2.LoadBalancer{
+		LoadBalancers: []elbv2types.LoadBalancer{
 			{
-				Scheme: aws.String(string(infrav1.ELBSchemeInternetFacing)),
-				AvailabilityZones: []*elbv2.AvailabilityZone{
+				Scheme: elbService.SchemeToSDKScheme(infrav1.ELBSchemeInternetFacing),
+				AvailabilityZones: []elbv2types.AvailabilityZone{
 					{
 						SubnetId: aws.String("subnet-1"),
 						ZoneName: aws.String("us-east-1a"),
@@ -74,7 +79,7 @@ var (
 		},
 	}
 	describeLBAttributesOutputV2 = &elbv2.DescribeLoadBalancerAttributesOutput{
-		Attributes: []*elbv2.LoadBalancerAttribute{
+		Attributes: []elbv2types.LoadBalancerAttribute{
 			{
 				Key:   aws.String("cross-zone"),
 				Value: aws.String("true"),
@@ -82,13 +87,13 @@ var (
 		},
 	}
 	describeLBAttributesOutput = &elb.DescribeLoadBalancerAttributesOutput{
-		LoadBalancerAttributes: &elb.LoadBalancerAttributes{
-			CrossZoneLoadBalancing: &elb.CrossZoneLoadBalancing{
-				Enabled: aws.Bool(false),
+		LoadBalancerAttributes: &elbtypes.LoadBalancerAttributes{
+			CrossZoneLoadBalancing: &elbtypes.CrossZoneLoadBalancing{
+				Enabled: false,
 			},
 		},
 	}
-	expectedTags = []*elb.Tag{
+	expectedTags = []elbtypes.Tag{
 		{
 			Key:   aws.String("Name"),
 			Value: lbName,
@@ -102,7 +107,7 @@ var (
 			Value: aws.String("apiserver"),
 		},
 	}
-	expectedV2Tags = []*elbv2.Tag{
+	expectedV2Tags = []elbv2types.Tag{
 		{
 			Key:   aws.String("Name"),
 			Value: lbName,
@@ -116,6 +121,7 @@ var (
 			Value: aws.String("apiserver"),
 		},
 	}
+	maxWaitActiveUpdateDelete = time.Minute
 )
 
 func expectAWSClusterConditions(g *WithT, m *infrav1.AWSCluster, expected []conditionAssertion) {
@@ -182,91 +188,92 @@ func getClusterScope(awsCluster infrav1.AWSCluster) (*scope.ClusterScope, error)
 			},
 			AWSCluster:                   &awsCluster,
 			TagUnmanagedNetworkResources: true,
+			MaxWaitActiveUpdateDelete:    maxWaitActiveUpdateDelete,
 		},
 	)
 }
 
 func mockedCreateLBCalls(t *testing.T, m *mocks.MockELBAPIMockRecorder, withHealthCheckUpdate bool) {
 	t.Helper()
-	m.DescribeLoadBalancers(gomock.Eq(describeLBInput)).
+	m.DescribeLoadBalancers(gomock.Any(), gomock.Eq(describeLBInput)).
 		Return(describeLBOutput, nil).MinTimes(1)
-	m.DescribeLoadBalancerAttributes(gomock.Eq(describeLBAttributesInput)).
+	m.DescribeLoadBalancerAttributes(gomock.Any(), gomock.Eq(describeLBAttributesInput)).
 		Return(describeLBAttributesOutput, nil)
-	m.DescribeTags(&elb.DescribeTagsInput{LoadBalancerNames: aws.StringSlice([]string{*lbName})}).Return(
+	m.DescribeTags(gomock.Any(), &elb.DescribeTagsInput{LoadBalancerNames: []string{*lbName}}).Return(
 		&elb.DescribeTagsOutput{
-			TagDescriptions: []*elb.TagDescription{
+			TagDescriptions: []elbtypes.TagDescription{
 				{
 					LoadBalancerName: lbName,
-					Tags: []*elb.Tag{{
+					Tags: []elbtypes.Tag{{
 						Key:   aws.String(infrav1.ClusterTagKey("test-cluster-apiserver")),
 						Value: aws.String(string(infrav1.ResourceLifecycleOwned)),
 					}},
 				},
 			},
 		}, nil)
-	m.ModifyLoadBalancerAttributes(gomock.Eq(&elb.ModifyLoadBalancerAttributesInput{
-		LoadBalancerAttributes: &elb.LoadBalancerAttributes{
-			ConnectionSettings:     &elb.ConnectionSettings{IdleTimeout: aws.Int64(600)},
-			CrossZoneLoadBalancing: &elb.CrossZoneLoadBalancing{Enabled: aws.Bool(false)},
+	m.ModifyLoadBalancerAttributes(gomock.Any(), gomock.Eq(&elb.ModifyLoadBalancerAttributesInput{
+		LoadBalancerAttributes: &elbtypes.LoadBalancerAttributes{
+			ConnectionSettings:     &elbtypes.ConnectionSettings{IdleTimeout: aws.Int32(600)},
+			CrossZoneLoadBalancing: &elbtypes.CrossZoneLoadBalancing{Enabled: false},
 		},
 		LoadBalancerName: aws.String(""),
 	})).MaxTimes(1)
 
 	if withHealthCheckUpdate {
-		m.ConfigureHealthCheck(gomock.Any()).MaxTimes(1)
+		m.ConfigureHealthCheck(gomock.Any(), gomock.Any()).MaxTimes(1)
 	}
 
-	m.AddTags(gomock.AssignableToTypeOf(&elb.AddTagsInput{})).Return(&elb.AddTagsOutput{}, nil).Do(
-		func(actual *elb.AddTagsInput) {
-			sortTagsByKey := func(tags []*elb.Tag) {
+	m.AddTags(gomock.Any(), gomock.AssignableToTypeOf(&elb.AddTagsInput{})).Return(&elb.AddTagsOutput{}, nil).Do(
+		func(ctx context.Context, actual *elb.AddTagsInput, optFns ...func(*elb.Options)) {
+			sortTagsByKey := func(tags []elbtypes.Tag) {
 				sort.Slice(tags, func(i, j int) bool {
 					return *(tags[i].Key) < *(tags[j].Key)
 				})
 			}
 
 			sortTagsByKey(actual.Tags)
-			if !cmp.Equal(expectedTags, actual.Tags) {
+			if !cmp.Equal(expectedTags, actual.Tags, cmp.AllowUnexported(elbtypes.Tag{})) {
 				t.Fatalf("Actual AddTagsInput did not match expected, Actual : %v, Expected: %v", actual.Tags, expectedTags)
 			}
 		}).AnyTimes()
-	m.RemoveTags(gomock.Eq(&elb.RemoveTagsInput{
-		LoadBalancerNames: aws.StringSlice([]string{""}),
-		Tags: []*elb.TagKeyOnly{
+	m.RemoveTags(gomock.Any(), gomock.Eq(&elb.RemoveTagsInput{
+		LoadBalancerNames: []string{""},
+		Tags: []elbtypes.TagKeyOnly{
 			{
 				Key: aws.String("sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster-apiserver"),
 			},
 		},
 	})).MaxTimes(1)
-	m.ApplySecurityGroupsToLoadBalancer(gomock.Eq(&elb.ApplySecurityGroupsToLoadBalancerInput{
+	m.ApplySecurityGroupsToLoadBalancer(gomock.Any(), gomock.Eq(&elb.ApplySecurityGroupsToLoadBalancerInput{
 		LoadBalancerName: aws.String(""),
-		SecurityGroups:   aws.StringSlice([]string{"sg-apiserver-lb"}),
+		SecurityGroups:   []string{"sg-apiserver-lb"},
 	})).MaxTimes(1)
-	m.RegisterInstancesWithLoadBalancer(gomock.Eq(&elb.RegisterInstancesWithLoadBalancerInput{Instances: []*elb.Instance{{InstanceId: aws.String("two")}}, LoadBalancerName: lbName})).MaxTimes(1)
+	m.RegisterInstancesWithLoadBalancer(gomock.Any(), gomock.Eq(&elb.RegisterInstancesWithLoadBalancerInput{Instances: []elbtypes.Instance{{InstanceId: aws.String("two")}}, LoadBalancerName: lbName})).MaxTimes(1)
 }
 
 func mockedCreateLBV2Calls(t *testing.T, m *mocks.MockELBV2APIMockRecorder) {
 	t.Helper()
-	m.DescribeLoadBalancers(gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-		Names: []*string{lbName},
+	m.DescribeLoadBalancers(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
+		Names: []string{aws.ToString(lbName)},
 	})).
 		Return(describeLBOutputV2, nil).MinTimes(1)
-	m.DescribeLoadBalancerAttributes(gomock.Eq(&elbv2.DescribeLoadBalancerAttributesInput{
+	m.DescribeLoadBalancerAttributes(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancerAttributesInput{
 		LoadBalancerArn: lbArn,
 	})).Return(describeLBAttributesOutputV2, nil)
-	m.DescribeTags(&elbv2.DescribeTagsInput{ResourceArns: []*string{lbArn}}).Return(
+	m.DescribeTags(gomock.Any(), &elbv2.DescribeTagsInput{ResourceArns: []string{aws.ToString(lbArn)}}).Return(
 		&elbv2.DescribeTagsOutput{
-			TagDescriptions: []*elbv2.TagDescription{
+			TagDescriptions: []elbv2types.TagDescription{
 				{
 					ResourceArn: lbArn,
-					Tags: []*elbv2.Tag{{
+					Tags: []elbv2types.Tag{{
 						Key:   aws.String(infrav1.ClusterTagKey("test-cluster-apiserver")),
 						Value: aws.String(string(infrav1.ResourceLifecycleOwned)),
 					}},
 				},
 			},
 		}, nil)
-	m.ModifyLoadBalancerAttributes(gomock.Eq(&elbv2.ModifyLoadBalancerAttributesInput{
-		Attributes: []*elbv2.LoadBalancerAttribute{
+	m.ModifyLoadBalancerAttributes(gomock.Any(), gomock.Eq(&elbv2.ModifyLoadBalancerAttributesInput{
+		Attributes: []elbv2types.LoadBalancerAttribute{
 			{
 				Key:   aws.String(infrav1.LoadBalancerAttributeEnableLoadBalancingCrossZone),
 				Value: aws.String("false"),
@@ -274,58 +281,58 @@ func mockedCreateLBV2Calls(t *testing.T, m *mocks.MockELBV2APIMockRecorder) {
 		},
 		LoadBalancerArn: lbArn,
 	})).MaxTimes(1)
-	m.AddTags(gomock.AssignableToTypeOf(&elbv2.AddTagsInput{})).Return(&elbv2.AddTagsOutput{}, nil).Do(
-		func(actual *elbv2.AddTagsInput) {
-			sortTagsByKey := func(tags []*elbv2.Tag) {
+	m.AddTags(gomock.Any(), gomock.AssignableToTypeOf(&elbv2.AddTagsInput{})).Return(&elbv2.AddTagsOutput{}, nil).Do(
+		func(ctx context.Context, actual *elbv2.AddTagsInput, optFns ...func(*elbv2.Options)) {
+			sortTagsByKey := func(tags []elbv2types.Tag) {
 				sort.Slice(tags, func(i, j int) bool {
 					return *(tags[i].Key) < *(tags[j].Key)
 				})
 			}
 
 			sortTagsByKey(actual.Tags)
-			if !cmp.Equal(expectedV2Tags, actual.Tags) {
+			if !cmp.Equal(expectedV2Tags, actual.Tags, cmp.AllowUnexported(elbv2types.Tag{})) {
 				t.Fatalf("Actual AddTagsInput did not match expected, Actual : %v, Expected: %v", actual.Tags, expectedV2Tags)
 			}
 		}).AnyTimes()
-	m.RemoveTags(gomock.Eq(&elbv2.RemoveTagsInput{
-		ResourceArns: []*string{lbArn},
-		TagKeys:      []*string{aws.String("sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster-apiserver")},
+	m.RemoveTags(gomock.Any(), gomock.Eq(&elbv2.RemoveTagsInput{
+		ResourceArns: []string{aws.ToString(lbArn)},
+		TagKeys:      []string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster-apiserver"},
 	})).MaxTimes(1)
-	m.SetSecurityGroups(gomock.Eq(&elbv2.SetSecurityGroupsInput{
+	m.SetSecurityGroups(gomock.Any(), gomock.Eq(&elbv2.SetSecurityGroupsInput{
 		LoadBalancerArn: lbArn,
-		SecurityGroups:  aws.StringSlice([]string{"sg-apiserver-lb"}),
-	})).MaxTimes(1)
-	m.WaitUntilLoadBalancerAvailableWithContext(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-		LoadBalancerArns: []*string{lbArn},
+		SecurityGroups:  []string{"sg-apiserver-lb"},
 	})).MaxTimes(1)
+	m.WaitUntilLoadBalancerAvailable(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
+		LoadBalancerArns: []string{aws.ToString(lbArn)},
+	}), maxWaitActiveUpdateDelete).MaxTimes(1)
 }
 
 func mockedDescribeTargetGroupsCall(t *testing.T, m *mocks.MockELBV2APIMockRecorder) {
 	t.Helper()
-	m.DescribeTargetGroups(gomock.Eq(&elbv2.DescribeTargetGroupsInput{
+	m.DescribeTargetGroups(gomock.Any(), gomock.Eq(&elbv2.DescribeTargetGroupsInput{
 		LoadBalancerArn: lbArn,
 	})).
 		Return(&elbv2.DescribeTargetGroupsOutput{
 			NextMarker: new(string),
-			TargetGroups: []*elbv2.TargetGroup{
+			TargetGroups: []elbv2types.TargetGroup{
 				{
 					HealthCheckEnabled:         aws.Bool(true),
-					HealthCheckIntervalSeconds: new(int64),
+					HealthCheckIntervalSeconds: new(int32),
 					HealthCheckPath:            new(string),
 					HealthCheckPort:            new(string),
-					HealthCheckProtocol:        new(string),
-					HealthCheckTimeoutSeconds:  new(int64),
-					HealthyThresholdCount:      new(int64),
-					IpAddressType:              new(string),
-					LoadBalancerArns:           []*string{lbArn},
-					Matcher:                    &elbv2.Matcher{},
-					Port:                       new(int64),
-					Protocol:                   new(string),
+					HealthCheckProtocol:        elbv2types.ProtocolEnumTcp,
+					HealthCheckTimeoutSeconds:  new(int32),
+					HealthyThresholdCount:      new(int32),
+					IpAddressType:              elbv2types.TargetGroupIpAddressTypeEnumIpv4,
+					LoadBalancerArns:           []string{aws.ToString(lbArn)},
+					Matcher:                    &elbv2types.Matcher{},
+					Port:                       new(int32),
+					Protocol:                   elbv2types.ProtocolEnumTcp,
 					ProtocolVersion:            new(string),
 					TargetGroupArn:             tgArn,
 					TargetGroupName:            new(string),
-					TargetType:                 new(string),
-					UnhealthyThresholdCount:    new(int64),
+					TargetType:                 elbv2types.TargetTypeEnumIp,
+					UnhealthyThresholdCount:    new(int32),
 					VpcId:                      new(string),
 				},
 			},
@@ -334,18 +341,18 @@ func mockedDescribeTargetGroupsCall(t *testing.T, m *mocks.MockELBV2APIMockRecor
 
 func mockedCreateTargetGroupCall(t *testing.T, m *mocks.MockELBV2APIMockRecorder) {
 	t.Helper()
-	m.CreateTargetGroup(helpers.PartialMatchCreateTargetGroupInput(t, &elbv2.CreateTargetGroupInput{
+	m.CreateTargetGroup(gomock.Any(), helpers.PartialMatchCreateTargetGroupInput(t, &elbv2.CreateTargetGroupInput{
 		HealthCheckEnabled:         aws.Bool(true),
-		HealthCheckIntervalSeconds: aws.Int64(infrav1.DefaultAPIServerHealthCheckIntervalSec),
+		HealthCheckIntervalSeconds: aws.Int32(infrav1.DefaultAPIServerHealthCheckIntervalSec),
 		HealthCheckPort:            aws.String(infrav1.DefaultAPIServerPortString),
-		HealthCheckProtocol:        aws.String("TCP"),
-		HealthCheckTimeoutSeconds:  aws.Int64(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
-		HealthyThresholdCount:      aws.Int64(infrav1.DefaultAPIServerHealthThresholdCount),
+		HealthCheckProtocol:        elbv2types.ProtocolEnumTcp,
+		HealthCheckTimeoutSeconds:  aws.Int32(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
+		HealthyThresholdCount:      aws.Int32(infrav1.DefaultAPIServerHealthThresholdCount),
 		// Note: this is treated as a prefix with the partial matcher.
 		Name:     aws.String("apiserver-target"),
-		Port:     aws.Int64(infrav1.DefaultAPIServerPort),
-		Protocol: aws.String("TCP"),
-		Tags: []*elbv2.Tag{
+		Port:     aws.Int32(infrav1.DefaultAPIServerPort),
+		Protocol: elbv2types.ProtocolEnumTcp,
+		Tags: []elbv2types.Tag{
 			{
 				Key:   aws.String("Name"),
 				Value: aws.String("bar-apiserver"),
@@ -359,23 +366,23 @@ func mockedCreateTargetGroupCall(t *testing.T, m *mocks.MockELBV2APIMockRecorder
 				Value: aws.String("apiserver"),
 			},
 		},
-		UnhealthyThresholdCount: aws.Int64(infrav1.DefaultAPIServerUnhealthThresholdCount),
+		UnhealthyThresholdCount: aws.Int32(infrav1.DefaultAPIServerUnhealthThresholdCount),
 		VpcId:                   aws.String("vpc-exists"),
 	})).Return(&elbv2.CreateTargetGroupOutput{
-		TargetGroups: []*elbv2.TargetGroup{{
+		TargetGroups: []elbv2types.TargetGroup{{
 			HealthCheckEnabled:         aws.Bool(true),
-			HealthCheckIntervalSeconds: aws.Int64(infrav1.DefaultAPIServerHealthCheckIntervalSec),
+			HealthCheckIntervalSeconds: aws.Int32(infrav1.DefaultAPIServerHealthCheckIntervalSec),
 			HealthCheckPort:            aws.String(infrav1.DefaultAPIServerPortString),
-			HealthCheckProtocol:        aws.String("TCP"),
-			HealthCheckTimeoutSeconds:  aws.Int64(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
-			HealthyThresholdCount:      aws.Int64(infrav1.DefaultAPIServerHealthThresholdCount),
-			LoadBalancerArns:           []*string{lbArn},
-			Matcher:                    &elbv2.Matcher{},
-			Port:                       aws.Int64(infrav1.DefaultAPIServerPort),
-			Protocol:                   aws.String("TCP"),
+			HealthCheckProtocol:        elbv2types.ProtocolEnumTcp,
+			HealthCheckTimeoutSeconds:  aws.Int32(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
+			HealthyThresholdCount:      aws.Int32(infrav1.DefaultAPIServerHealthThresholdCount),
+			LoadBalancerArns:           []string{aws.ToString(lbArn)},
+			Matcher:                    &elbv2types.Matcher{},
+			Port:                       aws.Int32(infrav1.DefaultAPIServerPort),
+			Protocol:                   elbv2types.ProtocolEnumTcp,
 			TargetGroupArn:             tgArn,
 			TargetGroupName:            aws.String("apiserver-target"),
-			UnhealthyThresholdCount:    aws.Int64(infrav1.DefaultAPIServerUnhealthThresholdCount),
+			UnhealthyThresholdCount:    aws.Int32(infrav1.DefaultAPIServerUnhealthThresholdCount),
 			VpcId:                      aws.String("vpc-exists"),
 		}},
 	}, nil)
@@ -383,9 +390,9 @@ func mockedCreateTargetGroupCall(t *testing.T, m *mocks.MockELBV2APIMockRecorder
 
 func mockedModifyTargetGroupAttributes(t *testing.T, m *mocks.MockELBV2APIMockRecorder) {
 	t.Helper()
-	m.ModifyTargetGroupAttributes(gomock.Eq(&elbv2.ModifyTargetGroupAttributesInput{
+	m.ModifyTargetGroupAttributes(gomock.Any(), gomock.Eq(&elbv2.ModifyTargetGroupAttributesInput{
 		TargetGroupArn: tgArn,
-		Attributes: []*elbv2.TargetGroupAttribute{
+		Attributes: []elbv2types.TargetGroupAttribute{
 			{
 				Key:   aws.String(infrav1.TargetGroupAttributeEnablePreserveClientIP),
 				Value: aws.String("false"),
@@ -396,12 +403,12 @@ func mockedModifyTargetGroupAttributes(t *testing.T, m *mocks.MockELBV2APIMockRe
 
 func mockedDescribeListenersCall(t *testing.T, m *mocks.MockELBV2APIMockRecorder) {
 	t.Helper()
-	m.DescribeListeners(gomock.Eq(&elbv2.DescribeListenersInput{
+	m.DescribeListeners(gomock.Any(), gomock.Eq(&elbv2.DescribeListenersInput{
 		LoadBalancerArn: lbArn,
 	})).
 		Return(&elbv2.DescribeListenersOutput{
-			Listeners: []*elbv2.Listener{{
-				DefaultActions: []*elbv2.Action{{
+			Listeners: []elbv2types.Listener{{
+				DefaultActions: []elbv2types.Action{{
 					TargetGroupArn: aws.String("arn::targetgroup-not-found"),
 				}},
 				ListenerArn:     aws.String("arn::listener"),
@@ -412,17 +419,17 @@ func mockedDescribeListenersCall(t *testing.T, m *mocks.MockELBV2APIMockRecorder
 
 func mockedCreateListenerCall(t *testing.T, m *mocks.MockELBV2APIMockRecorder) {
 	t.Helper()
-	m.CreateListener(gomock.Eq(&elbv2.CreateListenerInput{
-		DefaultActions: []*elbv2.Action{
+	m.CreateListener(gomock.Any(), gomock.Eq(&elbv2.CreateListenerInput{
+		DefaultActions: []elbv2types.Action{
 			{
 				TargetGroupArn: tgArn,
-				Type:           aws.String(elbv2.ActionTypeEnumForward),
+				Type:           elbv2types.ActionTypeEnumForward,
 			},
 		},
 		LoadBalancerArn: lbArn,
-		Port:            aws.Int64(infrav1.DefaultAPIServerPort),
-		Protocol:        aws.String("TCP"),
-		Tags: []*elbv2.Tag{
+		Port:            aws.Int32(infrav1.DefaultAPIServerPort),
+		Protocol:        elbv2types.ProtocolEnumTcp,
+		Tags: []elbv2types.Tag{
 			{
 				Key:   aws.String("Name"),
 				Value: aws.String("test-cluster-apiserver"),
@@ -437,17 +444,17 @@ func mockedCreateListenerCall(t *testing.T, m *mocks.MockELBV2APIMockRecorder) {
 			},
 		},
 	})).Return(&elbv2.CreateListenerOutput{
-		Listeners: []*elbv2.Listener{
+		Listeners: []elbv2types.Listener{
 			{
-				DefaultActions: []*elbv2.Action{
+				DefaultActions: []elbv2types.Action{
 					{
 						TargetGroupArn: tgArn,
-						Type:           aws.String(elbv2.ActionTypeEnumForward),
+						Type:           elbv2types.ActionTypeEnumForward,
 					},
 				},
 				ListenerArn: aws.String("listener::arn"),
-				Port:        aws.Int64(infrav1.DefaultAPIServerPort),
-				Protocol:    aws.String("TCP"),
+				Port:        aws.Int32(infrav1.DefaultAPIServerPort),
+				Protocol:    elbv2types.ProtocolEnumTcp,
 			},
 		},
 	}, nil)
@@ -455,14 +462,14 @@ func mockedCreateListenerCall(t *testing.T, m *mocks.MockELBV2APIMockRecorder) {
 
 func mockedDeleteLBCalls(expectV2Call bool, mv2 *mocks.MockELBV2APIMockRecorder, m *mocks.MockELBAPIMockRecorder) {
 	if expectV2Call {
-		mv2.DescribeLoadBalancers(gomock.Any()).Return(describeLBOutputV2, nil)
-		mv2.DescribeLoadBalancerAttributes(gomock.Any()).
+		mv2.DescribeLoadBalancers(gomock.Any(), gomock.Any()).Return(describeLBOutputV2, nil)
+		mv2.DescribeLoadBalancerAttributes(gomock.Any(), gomock.Any()).
 			Return(describeLBAttributesOutputV2, nil).MaxTimes(1)
-		mv2.DescribeTags(gomock.Any()).Return(
+		mv2.DescribeTags(gomock.Any(), gomock.Any()).Return(
 			&elbv2.DescribeTagsOutput{
-				TagDescriptions: []*elbv2.TagDescription{
+				TagDescriptions: []elbv2types.TagDescription{
 					{
-						Tags: []*elbv2.Tag{
+						Tags: []elbv2types.Tag{
 							{
 								Key:   aws.String("name"),
 								Value: lbName,
@@ -471,27 +478,27 @@ func mockedDeleteLBCalls(expectV2Call bool, mv2 *mocks.MockELBV2APIMockRecorder,
 					},
 				},
 			}, nil).MaxTimes(1)
-		mv2.DescribeTargetGroups(gomock.Any()).Return(&elbv2.DescribeTargetGroupsOutput{}, nil)
-		mv2.DescribeListeners(gomock.Any()).Return(&elbv2.DescribeListenersOutput{}, nil)
-		mv2.DeleteLoadBalancer(gomock.Eq(&elbv2.DeleteLoadBalancerInput{LoadBalancerArn: lbArn})).
+		mv2.DescribeTargetGroups(gomock.Any(), gomock.Any()).Return(&elbv2.DescribeTargetGroupsOutput{}, nil)
+		mv2.DescribeListeners(gomock.Any(), gomock.Any()).Return(&elbv2.DescribeListenersOutput{}, nil)
+		mv2.DeleteLoadBalancer(gomock.Any(), gomock.Eq(&elbv2.DeleteLoadBalancerInput{LoadBalancerArn: lbArn})).
 			Return(&elbv2.DeleteLoadBalancerOutput{}, nil).MaxTimes(1)
-		mv2.DescribeLoadBalancers(gomock.Any()).Return(&elbv2.DescribeLoadBalancersOutput{}, nil)
+		mv2.DescribeLoadBalancers(gomock.Any(), gomock.Any()).Return(&elbv2.DescribeLoadBalancersOutput{}, nil)
 	}
-	m.DescribeLoadBalancers(gomock.Eq(describeLBInput)).
+	m.DescribeLoadBalancers(gomock.Any(), gomock.Eq(describeLBInput)).
 		Return(describeLBOutput, nil)
-	m.DescribeLoadBalancers(gomock.Eq(describeLBInput)).
+	m.DescribeLoadBalancers(gomock.Any(), gomock.Eq(describeLBInput)).
 		Return(&elb.DescribeLoadBalancersOutput{}, nil).AnyTimes()
-	m.DescribeTags(&elb.DescribeTagsInput{LoadBalancerNames: aws.StringSlice([]string{*lbName})}).Return(
+	m.DescribeTags(gomock.Any(), &elb.DescribeTagsInput{LoadBalancerNames: []string{*lbName}}).Return(
 		&elb.DescribeTagsOutput{
-			TagDescriptions: []*elb.TagDescription{
+			TagDescriptions: []elbtypes.TagDescription{
 				{
 					LoadBalancerName: lbName,
 				},
 			},
 		}, nil).MaxTimes(1)
-	m.DescribeLoadBalancerAttributes(gomock.Eq(describeLBAttributesInput)).
+	m.DescribeLoadBalancerAttributes(gomock.Any(), gomock.Eq(describeLBAttributesInput)).
 		Return(describeLBAttributesOutput, nil).MaxTimes(1)
-	m.DeleteLoadBalancer(gomock.Eq(&elb.DeleteLoadBalancerInput{LoadBalancerName: lbName})).
+	m.DeleteLoadBalancer(gomock.Any(), gomock.Eq(&elb.DeleteLoadBalancerInput{LoadBalancerName: lbName})).
 		Return(&elb.DeleteLoadBalancerOutput{}, nil).MaxTimes(1)
-	m.DescribeLoadBalancersPages(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+	m.DescribeLoadBalancersPages(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
 }
diff --git a/pkg/cloud/services/elb/loadbalancer_test.go b/pkg/cloud/services/elb/loadbalancer_test.go
index 7a578fd7d..805167b3b 100644
--- a/pkg/cloud/services/elb/loadbalancer_test.go
+++ b/pkg/cloud/services/elb/loadbalancer_test.go
@@ -22,13 +22,16 @@ import (
 	"reflect"
 	"strings"
 	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
+	"time"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	elb "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing"
+	elbtypes "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing/types"
+	elbv2 "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2"
+	elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types"
+	rgapi "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi"
+	rgapitypes "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi/types"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/elb"
-	"github.com/aws/aws-sdk-go/service/elbv2"
-	rgapi "github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi"
 	"github.com/golang/mock/gomock"
 	"github.com/google/go-cmp/cmp"
 	. "github.com/onsi/gomega"
@@ -58,6 +61,8 @@ var stubInfraV1TargetGroupSpecAPI = infrav1.TargetGroupSpec{
 	},
 }
 
+const maxWaitActiveUpdateDelete = time.Minute
+
 func TestELBName(t *testing.T) {
 	tests := []struct {
 		name       string
@@ -268,6 +273,8 @@ func TestGetAPIServerClassicELBSpecControlPlaneLoadBalancer(t *testing.T) {
 		},
 	}
 
+	ctx := context.TODO()
+
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			g := NewWithT(t)
@@ -304,7 +311,7 @@ func TestGetAPIServerClassicELBSpecControlPlaneLoadBalancer(t *testing.T) {
 				EC2Client: ec2Mock,
 			}
 
-			spec, err := s.getAPIServerClassicELBSpec(clusterScope.Name())
+			spec, err := s.getAPIServerClassicELBSpec(ctx, clusterScope.Name())
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -428,6 +435,8 @@ func TestGetAPIServerV2ELBSpecControlPlaneLoadBalancer(t *testing.T) {
 		},
 	}
 
+	ctx := context.TODO()
+
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			g := NewWithT(t)
@@ -464,7 +473,7 @@ func TestGetAPIServerV2ELBSpecControlPlaneLoadBalancer(t *testing.T) {
 				EC2Client: ec2Mock,
 			}
 
-			spec, err := s.getAPIServerLBSpec(clusterScope.Name(), clusterScope.ControlPlaneLoadBalancer())
+			spec, err := s.getAPIServerLBSpec(ctx, clusterScope.Name(), clusterScope.ControlPlaneLoadBalancer())
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -510,34 +519,34 @@ func TestRegisterInstanceWithAPIServerELB(t *testing.T) {
 				},
 			},
 			elbAPIMocks: func(m *mocks.MockELBAPIMockRecorder) {
-				m.DescribeLoadBalancers(gomock.Eq(&elb.DescribeLoadBalancersInput{
-					LoadBalancerNames: aws.StringSlice([]string{elbName}),
+				m.DescribeLoadBalancers(gomock.Any(), gomock.Eq(&elb.DescribeLoadBalancersInput{
+					LoadBalancerNames: []string{elbName},
 				})).
 					Return(&elb.DescribeLoadBalancersOutput{
-						LoadBalancerDescriptions: []*elb.LoadBalancerDescription{
+						LoadBalancerDescriptions: []elbtypes.LoadBalancerDescription{
 							{
 								LoadBalancerName: aws.String(elbName),
 								Scheme:           aws.String(string(infrav1.ELBSchemeInternetFacing)),
-								Subnets:          []*string{aws.String(clusterSubnetID)},
+								Subnets:          []string{clusterSubnetID},
 							},
 						},
 					}, nil)
-				m.DescribeLoadBalancerAttributes(gomock.Eq(&elb.DescribeLoadBalancerAttributesInput{
+				m.DescribeLoadBalancerAttributes(gomock.Any(), gomock.Eq(&elb.DescribeLoadBalancerAttributesInput{
 					LoadBalancerName: aws.String(elbName),
 				})).
 					Return(&elb.DescribeLoadBalancerAttributesOutput{
-						LoadBalancerAttributes: &elb.LoadBalancerAttributes{
-							CrossZoneLoadBalancing: &elb.CrossZoneLoadBalancing{
-								Enabled: aws.Bool(false),
+						LoadBalancerAttributes: &elbtypes.LoadBalancerAttributes{
+							CrossZoneLoadBalancing: &elbtypes.CrossZoneLoadBalancing{
+								Enabled: false,
 							},
 						},
 					}, nil)
-				m.DescribeTags(&elb.DescribeTagsInput{LoadBalancerNames: []*string{aws.String(elbName)}}).Return(
+				m.DescribeTags(gomock.Any(), &elb.DescribeTagsInput{LoadBalancerNames: []string{elbName}}).Return(
 					&elb.DescribeTagsOutput{
-						TagDescriptions: []*elb.TagDescription{
+						TagDescriptions: []elbtypes.TagDescription{
 							{
 								LoadBalancerName: aws.String(elbName),
-								Tags: []*elb.Tag{{
+								Tags: []elbtypes.Tag{{
 									Key:   aws.String(infrav1.ClusterTagKey(clusterName)),
 									Value: aws.String(string(infrav1.ResourceLifecycleOwned)),
 								}},
@@ -545,12 +554,12 @@ func TestRegisterInstanceWithAPIServerELB(t *testing.T) {
 						},
 					}, nil)
 
-				m.RegisterInstancesWithLoadBalancer(gomock.Eq(&elb.RegisterInstancesWithLoadBalancerInput{
-					Instances:        []*elb.Instance{{InstanceId: aws.String(instanceID)}},
+				m.RegisterInstancesWithLoadBalancer(gomock.Any(), gomock.Eq(&elb.RegisterInstancesWithLoadBalancerInput{
+					Instances:        []elbtypes.Instance{{InstanceId: aws.String(instanceID)}},
 					LoadBalancerName: aws.String(elbName),
 				})).
 					Return(&elb.RegisterInstancesWithLoadBalancerOutput{
-						Instances: []*elb.Instance{{InstanceId: aws.String(instanceID)}},
+						Instances: []elbtypes.Instance{{InstanceId: aws.String(instanceID)}},
 					}, nil)
 			},
 			ec2Mocks: func(m *mocks.MockEC2APIMockRecorder) {},
@@ -579,34 +588,34 @@ func TestRegisterInstanceWithAPIServerELB(t *testing.T) {
 				},
 			},
 			elbAPIMocks: func(m *mocks.MockELBAPIMockRecorder) {
-				m.DescribeLoadBalancers(gomock.Eq(&elb.DescribeLoadBalancersInput{
-					LoadBalancerNames: aws.StringSlice([]string{elbName}),
+				m.DescribeLoadBalancers(gomock.Any(), gomock.Eq(&elb.DescribeLoadBalancersInput{
+					LoadBalancerNames: []string{elbName},
 				})).
 					Return(&elb.DescribeLoadBalancersOutput{
-						LoadBalancerDescriptions: []*elb.LoadBalancerDescription{
+						LoadBalancerDescriptions: []elbtypes.LoadBalancerDescription{
 							{
 								Scheme:            aws.String(string(infrav1.ELBSchemeInternetFacing)),
-								Subnets:           []*string{aws.String(elbSubnetID)},
-								AvailabilityZones: []*string{aws.String(az)},
+								Subnets:           []string{elbSubnetID},
+								AvailabilityZones: []string{az},
 							},
 						},
 					}, nil)
-				m.DescribeLoadBalancerAttributes(gomock.Eq(&elb.DescribeLoadBalancerAttributesInput{
+				m.DescribeLoadBalancerAttributes(gomock.Any(), gomock.Eq(&elb.DescribeLoadBalancerAttributesInput{
 					LoadBalancerName: aws.String(elbName),
 				})).
 					Return(&elb.DescribeLoadBalancerAttributesOutput{
-						LoadBalancerAttributes: &elb.LoadBalancerAttributes{
-							CrossZoneLoadBalancing: &elb.CrossZoneLoadBalancing{
-								Enabled: aws.Bool(false),
+						LoadBalancerAttributes: &elbtypes.LoadBalancerAttributes{
+							CrossZoneLoadBalancing: &elbtypes.CrossZoneLoadBalancing{
+								Enabled: false,
 							},
 						},
 					}, nil)
-				m.DescribeTags(&elb.DescribeTagsInput{LoadBalancerNames: []*string{aws.String(elbName)}}).Return(
+				m.DescribeTags(gomock.Any(), &elb.DescribeTagsInput{LoadBalancerNames: []string{elbName}}).Return(
 					&elb.DescribeTagsOutput{
-						TagDescriptions: []*elb.TagDescription{
+						TagDescriptions: []elbtypes.TagDescription{
 							{
 								LoadBalancerName: aws.String(elbName),
-								Tags: []*elb.Tag{{
+								Tags: []elbtypes.Tag{{
 									Key:   aws.String(infrav1.ClusterTagKey(clusterName)),
 									Value: aws.String(string(infrav1.ResourceLifecycleOwned)),
 								}},
@@ -614,12 +623,12 @@ func TestRegisterInstanceWithAPIServerELB(t *testing.T) {
 						},
 					}, nil)
 
-				m.RegisterInstancesWithLoadBalancer(gomock.Eq(&elb.RegisterInstancesWithLoadBalancerInput{
-					Instances:        []*elb.Instance{{InstanceId: aws.String(instanceID)}},
+				m.RegisterInstancesWithLoadBalancer(gomock.Any(), gomock.Eq(&elb.RegisterInstancesWithLoadBalancerInput{
+					Instances:        []elbtypes.Instance{{InstanceId: aws.String(instanceID)}},
 					LoadBalancerName: aws.String(elbName),
 				})).
 					Return(&elb.RegisterInstancesWithLoadBalancerOutput{
-						Instances: []*elb.Instance{{InstanceId: aws.String(instanceID)}},
+						Instances: []elbtypes.Instance{{InstanceId: aws.String(instanceID)}},
 					}, nil)
 			},
 			ec2Mocks: func(m *mocks.MockEC2APIMockRecorder) {
@@ -662,34 +671,34 @@ func TestRegisterInstanceWithAPIServerELB(t *testing.T) {
 				},
 			},
 			elbAPIMocks: func(m *mocks.MockELBAPIMockRecorder) {
-				m.DescribeLoadBalancers(gomock.Eq(&elb.DescribeLoadBalancersInput{
-					LoadBalancerNames: aws.StringSlice([]string{elbName}),
+				m.DescribeLoadBalancers(gomock.Any(), gomock.Eq(&elb.DescribeLoadBalancersInput{
+					LoadBalancerNames: []string{elbName},
 				})).
 					Return(&elb.DescribeLoadBalancersOutput{
-						LoadBalancerDescriptions: []*elb.LoadBalancerDescription{
+						LoadBalancerDescriptions: []elbtypes.LoadBalancerDescription{
 							{
 								Scheme:            aws.String(string(infrav1.ELBSchemeInternetFacing)),
-								Subnets:           []*string{aws.String(elbSubnetID)},
-								AvailabilityZones: []*string{aws.String(differentAZ)},
+								Subnets:           []string{elbSubnetID},
+								AvailabilityZones: []string{differentAZ},
 							},
 						},
 					}, nil)
-				m.DescribeLoadBalancerAttributes(gomock.Eq(&elb.DescribeLoadBalancerAttributesInput{
+				m.DescribeLoadBalancerAttributes(gomock.Any(), gomock.Eq(&elb.DescribeLoadBalancerAttributesInput{
 					LoadBalancerName: aws.String(elbName),
 				})).
 					Return(&elb.DescribeLoadBalancerAttributesOutput{
-						LoadBalancerAttributes: &elb.LoadBalancerAttributes{
-							CrossZoneLoadBalancing: &elb.CrossZoneLoadBalancing{
-								Enabled: aws.Bool(false),
+						LoadBalancerAttributes: &elbtypes.LoadBalancerAttributes{
+							CrossZoneLoadBalancing: &elbtypes.CrossZoneLoadBalancing{
+								Enabled: false,
 							},
 						},
 					}, nil)
-				m.DescribeTags(&elb.DescribeTagsInput{LoadBalancerNames: []*string{aws.String(elbName)}}).Return(
+				m.DescribeTags(gomock.Any(), &elb.DescribeTagsInput{LoadBalancerNames: []string{elbName}}).Return(
 					&elb.DescribeTagsOutput{
-						TagDescriptions: []*elb.TagDescription{
+						TagDescriptions: []elbtypes.TagDescription{
 							{
 								LoadBalancerName: aws.String(elbName),
-								Tags: []*elb.Tag{{
+								Tags: []elbtypes.Tag{{
 									Key:   aws.String(infrav1.ClusterTagKey(clusterName)),
 									Value: aws.String(string(infrav1.ResourceLifecycleOwned)),
 								}},
@@ -726,6 +735,8 @@ func TestRegisterInstanceWithAPIServerELB(t *testing.T) {
 		},
 	}
 
+	ctx := context.TODO()
+
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			mockCtrl := gomock.NewController(t)
@@ -767,7 +778,7 @@ func TestRegisterInstanceWithAPIServerELB(t *testing.T) {
 				ELBClient: elbAPIMocks,
 			}
 
-			err = s.RegisterInstanceWithAPIServerELB(instance)
+			err = s.RegisterInstanceWithAPIServerELB(ctx, instance)
 			tc.check(t, err)
 		})
 	}
@@ -812,16 +823,16 @@ func TestRegisterInstanceWithAPIServerNLB(t *testing.T) {
 				},
 			},
 			elbV2APIMocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.DescribeLoadBalancers(gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-					Names: aws.StringSlice([]string{elbName}),
+				m.DescribeLoadBalancers(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
+					Names: []string{elbName},
 				})).
 					Return(&elbv2.DescribeLoadBalancersOutput{
-						LoadBalancers: []*elbv2.LoadBalancer{
+						LoadBalancers: []elbv2types.LoadBalancer{
 							{
 								LoadBalancerArn:  aws.String(elbArn),
 								LoadBalancerName: aws.String(elbName),
-								Scheme:           aws.String(string(infrav1.ELBSchemeInternetFacing)),
-								AvailabilityZones: []*elbv2.AvailabilityZone{
+								Scheme:           SchemeToSDKScheme(infrav1.ELBSchemeInternetFacing),
+								AvailabilityZones: []elbv2types.AvailabilityZone{
 									{
 										SubnetId: aws.String(clusterSubnetID),
 									},
@@ -829,52 +840,52 @@ func TestRegisterInstanceWithAPIServerNLB(t *testing.T) {
 							},
 						},
 					}, nil)
-				m.DescribeLoadBalancerAttributes(gomock.Eq(&elbv2.DescribeLoadBalancerAttributesInput{
+				m.DescribeLoadBalancerAttributes(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancerAttributesInput{
 					LoadBalancerArn: aws.String(elbArn),
 				})).
 					Return(&elbv2.DescribeLoadBalancerAttributesOutput{
-						Attributes: []*elbv2.LoadBalancerAttribute{
+						Attributes: []elbv2types.LoadBalancerAttribute{
 							{
 								Key:   aws.String("load_balancing.cross_zone.enabled"),
 								Value: aws.String("true"),
 							},
 						},
 					}, nil)
-				m.DescribeTags(&elbv2.DescribeTagsInput{ResourceArns: []*string{aws.String(elbArn)}}).Return(
+				m.DescribeTags(gomock.Any(), &elbv2.DescribeTagsInput{ResourceArns: []string{elbArn}}).Return(
 					&elbv2.DescribeTagsOutput{
-						TagDescriptions: []*elbv2.TagDescription{
+						TagDescriptions: []elbv2types.TagDescription{
 							{
 								ResourceArn: aws.String(elbArn),
-								Tags: []*elbv2.Tag{{
+								Tags: []elbv2types.Tag{{
 									Key:   aws.String(infrav1.ClusterTagKey(clusterName)),
 									Value: aws.String(string(infrav1.ResourceLifecycleOwned)),
 								}},
 							},
 						},
 					}, nil)
-				m.DescribeTargetGroups(&elbv2.DescribeTargetGroupsInput{
+				m.DescribeTargetGroups(gomock.Any(), &elbv2.DescribeTargetGroupsInput{
 					LoadBalancerArn: aws.String(elbArn),
 				}).Return(&elbv2.DescribeTargetGroupsOutput{
-					TargetGroups: []*elbv2.TargetGroup{
+					TargetGroups: []elbv2types.TargetGroup{
 						{
 							HealthCheckEnabled:  aws.Bool(true),
 							HealthCheckPort:     aws.String(infrav1.DefaultAPIServerPortString),
-							HealthCheckProtocol: aws.String("TCP"),
-							LoadBalancerArns:    aws.StringSlice([]string{elbArn}),
-							Port:                aws.Int64(infrav1.DefaultAPIServerPort),
-							Protocol:            aws.String("TCP"),
+							HealthCheckProtocol: elbv2types.ProtocolEnumTcp,
+							LoadBalancerArns:    []string{elbArn},
+							Port:                aws.Int32(infrav1.DefaultAPIServerPort),
+							Protocol:            elbv2types.ProtocolEnumTcp,
 							TargetGroupArn:      aws.String(tgArn),
 							TargetGroupName:     aws.String("something-generated"),
 							VpcId:               aws.String("vpc-id"),
 						},
 					},
 				}, nil)
-				m.RegisterTargets(gomock.Eq(&elbv2.RegisterTargetsInput{
+				m.RegisterTargets(gomock.Any(), gomock.Eq(&elbv2.RegisterTargetsInput{
 					TargetGroupArn: aws.String(tgArn),
-					Targets: []*elbv2.TargetDescription{
+					Targets: []elbv2types.TargetDescription{
 						{
 							Id:   aws.String(instanceID),
-							Port: aws.Int64(infrav1.DefaultAPIServerPort),
+							Port: aws.Int32(infrav1.DefaultAPIServerPort),
 						},
 					},
 				})).Return(&elbv2.RegisterTargetsOutput{}, nil)
@@ -915,16 +926,16 @@ func TestRegisterInstanceWithAPIServerNLB(t *testing.T) {
 				},
 			},
 			elbV2APIMocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.DescribeLoadBalancers(gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-					Names: aws.StringSlice([]string{elbName}),
+				m.DescribeLoadBalancers(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
+					Names: []string{elbName},
 				})).
 					Return(&elbv2.DescribeLoadBalancersOutput{
-						LoadBalancers: []*elbv2.LoadBalancer{
+						LoadBalancers: []elbv2types.LoadBalancer{
 							{
 								LoadBalancerArn:  aws.String(elbArn),
 								LoadBalancerName: aws.String(elbName),
-								Scheme:           aws.String(string(infrav1.ELBSchemeInternetFacing)),
-								AvailabilityZones: []*elbv2.AvailabilityZone{
+								Scheme:           SchemeToSDKScheme(infrav1.ELBSchemeInternetFacing),
+								AvailabilityZones: []elbv2types.AvailabilityZone{
 									{
 										SubnetId: aws.String(clusterSubnetID),
 									},
@@ -932,40 +943,40 @@ func TestRegisterInstanceWithAPIServerNLB(t *testing.T) {
 							},
 						},
 					}, nil)
-				m.DescribeLoadBalancerAttributes(gomock.Eq(&elbv2.DescribeLoadBalancerAttributesInput{
+				m.DescribeLoadBalancerAttributes(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancerAttributesInput{
 					LoadBalancerArn: aws.String(elbArn),
 				})).
 					Return(&elbv2.DescribeLoadBalancerAttributesOutput{
-						Attributes: []*elbv2.LoadBalancerAttribute{
+						Attributes: []elbv2types.LoadBalancerAttribute{
 							{
 								Key:   aws.String("load_balancing.cross_zone.enabled"),
 								Value: aws.String("true"),
 							},
 						},
 					}, nil)
-				m.DescribeTags(&elbv2.DescribeTagsInput{ResourceArns: []*string{aws.String(elbArn)}}).Return(
+				m.DescribeTags(gomock.Any(), &elbv2.DescribeTagsInput{ResourceArns: []string{elbArn}}).Return(
 					&elbv2.DescribeTagsOutput{
-						TagDescriptions: []*elbv2.TagDescription{
+						TagDescriptions: []elbv2types.TagDescription{
 							{
 								ResourceArn: aws.String(elbArn),
-								Tags: []*elbv2.Tag{{
+								Tags: []elbv2types.Tag{{
 									Key:   aws.String(infrav1.ClusterTagKey(clusterName)),
 									Value: aws.String(string(infrav1.ResourceLifecycleOwned)),
 								}},
 							},
 						},
 					}, nil)
-				m.DescribeTargetGroups(&elbv2.DescribeTargetGroupsInput{
+				m.DescribeTargetGroups(gomock.Any(), &elbv2.DescribeTargetGroupsInput{
 					LoadBalancerArn: aws.String(elbArn),
 				}).Return(&elbv2.DescribeTargetGroupsOutput{
-					TargetGroups: []*elbv2.TargetGroup{
+					TargetGroups: []elbv2types.TargetGroup{
 						{
 							HealthCheckEnabled:  aws.Bool(true),
 							HealthCheckPort:     aws.String(infrav1.DefaultAPIServerPortString),
-							HealthCheckProtocol: aws.String("TCP"),
-							LoadBalancerArns:    aws.StringSlice([]string{elbArn}),
-							Port:                aws.Int64(infrav1.DefaultAPIServerPort),
-							Protocol:            aws.String("TCP"),
+							HealthCheckProtocol: elbv2types.ProtocolEnumTcp,
+							LoadBalancerArns:    []string{elbArn},
+							Port:                aws.Int32(infrav1.DefaultAPIServerPort),
+							Protocol:            elbv2types.ProtocolEnumTcp,
 							TargetGroupArn:      aws.String(tgArn),
 							TargetGroupName:     aws.String("something-generated"),
 							VpcId:               aws.String("vpc-id"),
@@ -973,10 +984,10 @@ func TestRegisterInstanceWithAPIServerNLB(t *testing.T) {
 						{
 							HealthCheckEnabled:  aws.Bool(true),
 							HealthCheckPort:     aws.String("443"),
-							HealthCheckProtocol: aws.String("TCP"),
-							LoadBalancerArns:    aws.StringSlice([]string{elbArn}),
-							Port:                aws.Int64(443),
-							Protocol:            aws.String("TCP"),
+							HealthCheckProtocol: elbv2types.ProtocolEnumTcp,
+							LoadBalancerArns:    []string{elbArn},
+							Port:                aws.Int32(443),
+							Protocol:            elbv2types.ProtocolEnumTcp,
 							TargetGroupArn:      aws.String("target-group::arn::443"),
 							TargetGroupName:     aws.String("something-generated-443"),
 							VpcId:               aws.String("vpc-id"),
@@ -984,40 +995,40 @@ func TestRegisterInstanceWithAPIServerNLB(t *testing.T) {
 						{
 							HealthCheckEnabled:  aws.Bool(true),
 							HealthCheckPort:     aws.String("8443"),
-							HealthCheckProtocol: aws.String("TCP"),
-							LoadBalancerArns:    aws.StringSlice([]string{elbArn}),
-							Port:                aws.Int64(8443),
-							Protocol:            aws.String("TCP"),
+							HealthCheckProtocol: elbv2types.ProtocolEnumTcp,
+							LoadBalancerArns:    []string{elbArn},
+							Port:                aws.Int32(8443),
+							Protocol:            elbv2types.ProtocolEnumTcp,
 							TargetGroupArn:      aws.String("target-group::arn::8443"),
 							TargetGroupName:     aws.String("something-generated-8443"),
 							VpcId:               aws.String("vpc-id"),
 						},
 					},
 				}, nil)
-				m.RegisterTargets(gomock.Eq(&elbv2.RegisterTargetsInput{
+				m.RegisterTargets(gomock.Any(), gomock.Eq(&elbv2.RegisterTargetsInput{
 					TargetGroupArn: aws.String(tgArn),
-					Targets: []*elbv2.TargetDescription{
+					Targets: []elbv2types.TargetDescription{
 						{
 							Id:   aws.String(instanceID),
-							Port: aws.Int64(infrav1.DefaultAPIServerPort),
+							Port: aws.Int32(infrav1.DefaultAPIServerPort),
 						},
 					},
 				})).Return(&elbv2.RegisterTargetsOutput{}, nil)
-				m.RegisterTargets(gomock.Eq(&elbv2.RegisterTargetsInput{
+				m.RegisterTargets(gomock.Any(), gomock.Eq(&elbv2.RegisterTargetsInput{
 					TargetGroupArn: aws.String("target-group::arn::443"),
-					Targets: []*elbv2.TargetDescription{
+					Targets: []elbv2types.TargetDescription{
 						{
 							Id:   aws.String(instanceID),
-							Port: aws.Int64(443),
+							Port: aws.Int32(443),
 						},
 					},
 				})).Return(&elbv2.RegisterTargetsOutput{}, nil)
-				m.RegisterTargets(gomock.Eq(&elbv2.RegisterTargetsInput{
+				m.RegisterTargets(gomock.Any(), gomock.Eq(&elbv2.RegisterTargetsInput{
 					TargetGroupArn: aws.String("target-group::arn::8443"),
-					Targets: []*elbv2.TargetDescription{
+					Targets: []elbv2types.TargetDescription{
 						{
 							Id:   aws.String(instanceID),
-							Port: aws.Int64(8443),
+							Port: aws.Int32(8443),
 						},
 					},
 				})).Return(&elbv2.RegisterTargetsOutput{}, nil)
@@ -1049,16 +1060,16 @@ func TestRegisterInstanceWithAPIServerNLB(t *testing.T) {
 				},
 			},
 			elbV2APIMocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.DescribeLoadBalancers(gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-					Names: aws.StringSlice([]string{elbName}),
+				m.DescribeLoadBalancers(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
+					Names: []string{elbName},
 				})).
 					Return(&elbv2.DescribeLoadBalancersOutput{
-						LoadBalancers: []*elbv2.LoadBalancer{
+						LoadBalancers: []elbv2types.LoadBalancer{
 							{
 								LoadBalancerArn:  aws.String(elbArn),
 								LoadBalancerName: aws.String(elbName),
-								Scheme:           aws.String(string(infrav1.ELBSchemeInternetFacing)),
-								AvailabilityZones: []*elbv2.AvailabilityZone{
+								Scheme:           SchemeToSDKScheme(infrav1.ELBSchemeInternetFacing),
+								AvailabilityZones: []elbv2types.AvailabilityZone{
 									{
 										SubnetId: aws.String(clusterSubnetID),
 									},
@@ -1066,30 +1077,30 @@ func TestRegisterInstanceWithAPIServerNLB(t *testing.T) {
 							},
 						},
 					}, nil)
-				m.DescribeLoadBalancerAttributes(gomock.Eq(&elbv2.DescribeLoadBalancerAttributesInput{
+				m.DescribeLoadBalancerAttributes(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancerAttributesInput{
 					LoadBalancerArn: aws.String(elbArn),
 				})).
 					Return(&elbv2.DescribeLoadBalancerAttributesOutput{
-						Attributes: []*elbv2.LoadBalancerAttribute{
+						Attributes: []elbv2types.LoadBalancerAttribute{
 							{
 								Key:   aws.String("load_balancing.cross_zone.enabled"),
 								Value: aws.String("true"),
 							},
 						},
 					}, nil)
-				m.DescribeTags(&elbv2.DescribeTagsInput{ResourceArns: []*string{aws.String(elbArn)}}).Return(
+				m.DescribeTags(gomock.Any(), &elbv2.DescribeTagsInput{ResourceArns: []string{elbArn}}).Return(
 					&elbv2.DescribeTagsOutput{
-						TagDescriptions: []*elbv2.TagDescription{
+						TagDescriptions: []elbv2types.TagDescription{
 							{
 								ResourceArn: aws.String(elbArn),
-								Tags: []*elbv2.Tag{{
+								Tags: []elbv2types.Tag{{
 									Key:   aws.String(infrav1.ClusterTagKey(clusterName)),
 									Value: aws.String(string(infrav1.ResourceLifecycleOwned)),
 								}},
 							},
 						},
 					}, nil)
-				m.DescribeTargetGroups(&elbv2.DescribeTargetGroupsInput{
+				m.DescribeTargetGroups(gomock.Any(), &elbv2.DescribeTargetGroupsInput{
 					LoadBalancerArn: aws.String(elbArn),
 				}).Return(&elbv2.DescribeTargetGroupsOutput{}, nil)
 			},
@@ -1108,6 +1119,8 @@ func TestRegisterInstanceWithAPIServerNLB(t *testing.T) {
 		},
 	}
 
+	ctx := context.TODO()
+
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			mockCtrl := gomock.NewController(t)
@@ -1149,7 +1162,7 @@ func TestRegisterInstanceWithAPIServerNLB(t *testing.T) {
 				ELBV2Client: elbV2APIMocks,
 			}
 
-			err = s.RegisterInstanceWithAPIServerLB(instance, clusterScope.ControlPlaneLoadBalancer())
+			err = s.RegisterInstanceWithAPIServerLB(ctx, instance, clusterScope.ControlPlaneLoadBalancer())
 			tc.check(t, err)
 		})
 	}
@@ -1182,24 +1195,23 @@ func TestCreateNLB(t *testing.T) {
 				return acl
 			},
 			elbV2APIMocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.CreateLoadBalancer(gomock.Eq(&elbv2.CreateLoadBalancerInput{
-					Name:           aws.String(elbName),
-					Scheme:         aws.String("internet-facing"),
-					SecurityGroups: []*string{},
-					Type:           aws.String("network"),
-					Subnets:        aws.StringSlice([]string{clusterSubnetID}),
-					Tags: []*elbv2.Tag{
+				m.CreateLoadBalancer(gomock.Any(), gomock.Eq(&elbv2.CreateLoadBalancerInput{
+					Name:    aws.String(elbName),
+					Scheme:  elbv2types.LoadBalancerSchemeEnumInternetFacing,
+					Type:    elbv2types.LoadBalancerTypeEnumNetwork,
+					Subnets: []string{clusterSubnetID},
+					Tags: []elbv2types.Tag{
 						{
 							Key:   aws.String("test"),
 							Value: aws.String("tag"),
 						},
 					},
 				})).Return(&elbv2.CreateLoadBalancerOutput{
-					LoadBalancers: []*elbv2.LoadBalancer{
+					LoadBalancers: []elbv2types.LoadBalancer{
 						{
 							LoadBalancerArn:  aws.String(elbArn),
 							LoadBalancerName: aws.String(elbName),
-							Scheme:           aws.String(string(infrav1.ELBSchemeInternetFacing)),
+							Scheme:           SchemeToSDKScheme(infrav1.ELBSchemeInternetFacing),
 							DNSName:          aws.String(dns),
 						},
 					},
@@ -1228,25 +1240,24 @@ func TestCreateNLB(t *testing.T) {
 				return acl
 			},
 			elbV2APIMocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.CreateLoadBalancer(gomock.Eq(&elbv2.CreateLoadBalancerInput{
-					Name:           aws.String(elbName),
-					IpAddressType:  aws.String("dualstack"),
-					Scheme:         aws.String("internet-facing"),
-					SecurityGroups: aws.StringSlice([]string{}),
-					Type:           aws.String("network"),
-					Subnets:        aws.StringSlice([]string{clusterSubnetID}),
-					Tags: []*elbv2.Tag{
+				m.CreateLoadBalancer(gomock.Any(), gomock.Eq(&elbv2.CreateLoadBalancerInput{
+					Name:          aws.String(elbName),
+					IpAddressType: elbv2types.IpAddressTypeDualstack,
+					Scheme:        elbv2types.LoadBalancerSchemeEnumInternetFacing,
+					Type:          elbv2types.LoadBalancerTypeEnumNetwork,
+					Subnets:       []string{clusterSubnetID},
+					Tags: []elbv2types.Tag{
 						{
 							Key:   aws.String("test"),
 							Value: aws.String("tag"),
 						},
 					},
 				})).Return(&elbv2.CreateLoadBalancerOutput{
-					LoadBalancers: []*elbv2.LoadBalancer{
+					LoadBalancers: []elbv2types.LoadBalancer{
 						{
 							LoadBalancerArn:  aws.String(elbArn),
 							LoadBalancerName: aws.String(elbName),
-							Scheme:           aws.String(string(infrav1.ELBSchemeInternetFacing)),
+							Scheme:           SchemeToSDKScheme(infrav1.ELBSchemeInternetFacing),
 							DNSName:          aws.String(dns),
 						},
 					},
@@ -1271,13 +1282,12 @@ func TestCreateNLB(t *testing.T) {
 				return acl
 			},
 			elbV2APIMocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.CreateLoadBalancer(gomock.Eq(&elbv2.CreateLoadBalancerInput{
-					Name:           aws.String(elbName),
-					Scheme:         aws.String("internet-facing"),
-					SecurityGroups: []*string{},
-					Type:           aws.String("network"),
-					Subnets:        aws.StringSlice([]string{clusterSubnetID}),
-					Tags: []*elbv2.Tag{
+				m.CreateLoadBalancer(gomock.Any(), gomock.Eq(&elbv2.CreateLoadBalancerInput{
+					Name:    aws.String(elbName),
+					Scheme:  elbv2types.LoadBalancerSchemeEnumInternetFacing,
+					Type:    elbv2types.LoadBalancerTypeEnumNetwork,
+					Subnets: []string{clusterSubnetID},
+					Tags: []elbv2types.Tag{
 						{
 							Key:   aws.String("test"),
 							Value: aws.String("tag"),
@@ -1305,24 +1315,23 @@ func TestCreateNLB(t *testing.T) {
 				return acl
 			},
 			elbV2APIMocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.CreateLoadBalancer(gomock.Eq(&elbv2.CreateLoadBalancerInput{
-					Name:           aws.String(elbName),
-					Scheme:         aws.String("internet-facing"),
-					SecurityGroups: aws.StringSlice([]string{}),
-					Type:           aws.String("network"),
-					Subnets:        aws.StringSlice([]string{clusterSubnetID}),
-					Tags: []*elbv2.Tag{
+				m.CreateLoadBalancer(gomock.Any(), gomock.Eq(&elbv2.CreateLoadBalancerInput{
+					Name:    aws.String(elbName),
+					Scheme:  elbv2types.LoadBalancerSchemeEnumInternetFacing,
+					Type:    elbv2types.LoadBalancerTypeEnumNetwork,
+					Subnets: []string{clusterSubnetID},
+					Tags: []elbv2types.Tag{
 						{
 							Key:   aws.String("test"),
 							Value: aws.String("tag"),
 						},
 					},
 				})).Return(&elbv2.CreateLoadBalancerOutput{
-					LoadBalancers: []*elbv2.LoadBalancer{
+					LoadBalancers: []elbv2types.LoadBalancer{
 						{
 							LoadBalancerArn:  aws.String(elbArn),
 							LoadBalancerName: aws.String(elbName),
-							Scheme:           aws.String(string(infrav1.ELBSchemeInternetFacing)),
+							Scheme:           SchemeToSDKScheme(infrav1.ELBSchemeInternetFacing),
 							DNSName:          aws.String(dns),
 						},
 					},
@@ -1349,24 +1358,24 @@ func TestCreateNLB(t *testing.T) {
 				return acl
 			},
 			elbV2APIMocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.CreateLoadBalancer(gomock.Eq(&elbv2.CreateLoadBalancerInput{
+				m.CreateLoadBalancer(gomock.Any(), gomock.Eq(&elbv2.CreateLoadBalancerInput{
 					Name:    aws.String(elbName),
-					Scheme:  aws.String("internet-facing"),
-					Type:    aws.String("application"),
-					Subnets: aws.StringSlice([]string{clusterSubnetID}),
-					Tags: []*elbv2.Tag{
+					Scheme:  elbv2types.LoadBalancerSchemeEnumInternetFacing,
+					Type:    elbv2types.LoadBalancerTypeEnumApplication,
+					Subnets: []string{clusterSubnetID},
+					Tags: []elbv2types.Tag{
 						{
 							Key:   aws.String("test"),
 							Value: aws.String("tag"),
 						},
 					},
-					SecurityGroups: aws.StringSlice([]string{"sg-id"}),
+					SecurityGroups: []string{"sg-id"},
 				})).Return(&elbv2.CreateLoadBalancerOutput{
-					LoadBalancers: []*elbv2.LoadBalancer{
+					LoadBalancers: []elbv2types.LoadBalancer{
 						{
 							LoadBalancerArn:  aws.String(elbArn),
 							LoadBalancerName: aws.String(elbName),
-							Scheme:           aws.String(string(infrav1.ELBSchemeInternetFacing)),
+							Scheme:           SchemeToSDKScheme(infrav1.ELBSchemeInternetFacing),
 							DNSName:          aws.String(dns),
 						},
 					},
@@ -1384,6 +1393,8 @@ func TestCreateNLB(t *testing.T) {
 		},
 	}
 
+	ctx := context.TODO()
+
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			mockCtrl := gomock.NewController(t)
@@ -1459,7 +1470,7 @@ func TestCreateNLB(t *testing.T) {
 			}
 
 			spec := tc.spec(*loadBalancerSpec)
-			lb, err := s.createLB(&spec, clusterScope.ControlPlaneLoadBalancer())
+			lb, err := s.createLB(ctx, &spec, clusterScope.ControlPlaneLoadBalancer())
 			tc.check(t, lb, err)
 		})
 	}
@@ -1480,7 +1491,7 @@ func TestReconcileTargetGroupsAndListeners(t *testing.T) {
 	tests := []struct {
 		name          string
 		elbV2APIMocks func(m *mocks.MockELBV2APIMockRecorder)
-		check         func(t *testing.T, tgs []*elbv2.TargetGroup, listeners []*elbv2.Listener, err error)
+		check         func(t *testing.T, tgs []*elbv2types.TargetGroup, listeners []*elbv2types.Listener, err error)
 		awsCluster    func(acl infrav1.AWSCluster) infrav1.AWSCluster
 		spec          func(spec infrav1.LoadBalancer) infrav1.LoadBalancer
 	}{
@@ -1493,17 +1504,17 @@ func TestReconcileTargetGroupsAndListeners(t *testing.T) {
 				return acl
 			},
 			elbV2APIMocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.DescribeTargetGroups(gomock.Eq(&elbv2.DescribeTargetGroupsInput{
+				m.DescribeTargetGroups(gomock.Any(), gomock.Eq(&elbv2.DescribeTargetGroupsInput{
 					LoadBalancerArn: aws.String(elbArn),
 				})).Return(&elbv2.DescribeTargetGroupsOutput{
-					TargetGroups: []*elbv2.TargetGroup{},
+					TargetGroups: []elbv2types.TargetGroup{},
 				}, nil)
-				m.CreateTargetGroup(gomock.Eq(&elbv2.CreateTargetGroupInput{
+				m.CreateTargetGroup(gomock.Any(), gomock.Eq(&elbv2.CreateTargetGroupInput{
 					Name:     aws.String("name"),
-					Port:     aws.Int64(infrav1.DefaultAPIServerPort),
-					Protocol: aws.String("TCP"),
+					Port:     aws.Int32(infrav1.DefaultAPIServerPort),
+					Protocol: elbv2types.ProtocolEnumTcp,
 					VpcId:    aws.String(vpcID),
-					Tags: []*elbv2.Tag{
+					Tags: []elbv2types.Tag{
 						{
 							Key:   aws.String("test"),
 							Value: aws.String("tag"),
@@ -1511,71 +1522,71 @@ func TestReconcileTargetGroupsAndListeners(t *testing.T) {
 					},
 					HealthCheckEnabled:         aws.Bool(true),
 					HealthCheckPort:            aws.String(infrav1.DefaultAPIServerPortString),
-					HealthCheckProtocol:        aws.String("tcp"),
-					HealthyThresholdCount:      aws.Int64(infrav1.DefaultAPIServerHealthThresholdCount),
-					UnhealthyThresholdCount:    aws.Int64(infrav1.DefaultAPIServerUnhealthThresholdCount),
-					HealthCheckIntervalSeconds: aws.Int64(infrav1.DefaultAPIServerHealthCheckIntervalSec),
-					HealthCheckTimeoutSeconds:  aws.Int64(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
+					HealthCheckProtocol:        elbv2types.ProtocolEnumTcp,
+					HealthyThresholdCount:      aws.Int32(infrav1.DefaultAPIServerHealthThresholdCount),
+					UnhealthyThresholdCount:    aws.Int32(infrav1.DefaultAPIServerUnhealthThresholdCount),
+					HealthCheckIntervalSeconds: aws.Int32(infrav1.DefaultAPIServerHealthCheckIntervalSec),
+					HealthCheckTimeoutSeconds:  aws.Int32(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
 				})).Return(&elbv2.CreateTargetGroupOutput{
-					TargetGroups: []*elbv2.TargetGroup{
+					TargetGroups: []elbv2types.TargetGroup{
 						{
 							TargetGroupArn:             aws.String(tgArn),
 							TargetGroupName:            aws.String("name"),
 							VpcId:                      aws.String(vpcID),
-							HealthyThresholdCount:      aws.Int64(infrav1.DefaultAPIServerHealthThresholdCount),
-							UnhealthyThresholdCount:    aws.Int64(infrav1.DefaultAPIServerUnhealthThresholdCount),
-							HealthCheckIntervalSeconds: aws.Int64(infrav1.DefaultAPIServerHealthCheckIntervalSec),
-							HealthCheckTimeoutSeconds:  aws.Int64(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
+							HealthyThresholdCount:      aws.Int32(infrav1.DefaultAPIServerHealthThresholdCount),
+							UnhealthyThresholdCount:    aws.Int32(infrav1.DefaultAPIServerUnhealthThresholdCount),
+							HealthCheckIntervalSeconds: aws.Int32(infrav1.DefaultAPIServerHealthCheckIntervalSec),
+							HealthCheckTimeoutSeconds:  aws.Int32(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
 						},
 					},
 				}, nil)
-				m.ModifyTargetGroupAttributes(gomock.Eq(&elbv2.ModifyTargetGroupAttributesInput{
+				m.ModifyTargetGroupAttributes(gomock.Any(), gomock.Eq(&elbv2.ModifyTargetGroupAttributesInput{
 					TargetGroupArn: aws.String(tgArn),
-					Attributes: []*elbv2.TargetGroupAttribute{
+					Attributes: []elbv2types.TargetGroupAttribute{
 						{
 							Key:   aws.String(infrav1.TargetGroupAttributeEnablePreserveClientIP),
 							Value: aws.String("false"),
 						},
 					},
 				})).Return(nil, nil)
-				m.DescribeListeners(gomock.Eq(&elbv2.DescribeListenersInput{
+				m.DescribeListeners(gomock.Any(), gomock.Eq(&elbv2.DescribeListenersInput{
 					LoadBalancerArn: aws.String(elbArn),
 				})).Return(&elbv2.DescribeListenersOutput{
-					Listeners: []*elbv2.Listener{},
+					Listeners: []elbv2types.Listener{},
 				}, nil)
-				m.CreateListener(gomock.Eq(&elbv2.CreateListenerInput{
-					DefaultActions: []*elbv2.Action{
+				m.CreateListener(gomock.Any(), gomock.Eq(&elbv2.CreateListenerInput{
+					DefaultActions: []elbv2types.Action{
 						{
 							TargetGroupArn: aws.String(tgArn),
-							Type:           aws.String(elbv2.ActionTypeEnumForward),
+							Type:           elbv2types.ActionTypeEnumForward,
 						},
 					},
 					LoadBalancerArn: aws.String(elbArn),
-					Port:            aws.Int64(infrav1.DefaultAPIServerPort),
-					Protocol:        aws.String("TCP"),
-					Tags: []*elbv2.Tag{
+					Port:            aws.Int32(infrav1.DefaultAPIServerPort),
+					Protocol:        elbv2types.ProtocolEnumTcp,
+					Tags: []elbv2types.Tag{
 						{
 							Key:   aws.String("test"),
 							Value: aws.String("tag"),
 						},
 					},
 				})).Return(&elbv2.CreateListenerOutput{
-					Listeners: []*elbv2.Listener{
+					Listeners: []elbv2types.Listener{
 						{
-							DefaultActions: []*elbv2.Action{
+							DefaultActions: []elbv2types.Action{
 								{
 									TargetGroupArn: aws.String(tgArn),
-									Type:           aws.String(elbv2.ActionTypeEnumForward),
+									Type:           elbv2types.ActionTypeEnumForward,
 								},
 							},
 							ListenerArn: aws.String("listener::arn"),
-							Port:        aws.Int64(infrav1.DefaultAPIServerPort),
-							Protocol:    aws.String("TCP"),
+							Port:        aws.Int32(infrav1.DefaultAPIServerPort),
+							Protocol:    elbv2types.ProtocolEnumTcp,
 						},
 					},
 				}, nil)
 			},
-			check: func(t *testing.T, tgs []*elbv2.TargetGroup, listeners []*elbv2.Listener, err error) {
+			check: func(t *testing.T, tgs []*elbv2types.TargetGroup, listeners []*elbv2types.Listener, err error) {
 				t.Helper()
 				if err != nil {
 					t.Fatalf("did not expect error: %v", err)
@@ -1609,18 +1620,18 @@ func TestReconcileTargetGroupsAndListeners(t *testing.T) {
 				return acl
 			},
 			elbV2APIMocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.DescribeTargetGroups(gomock.Eq(&elbv2.DescribeTargetGroupsInput{
+				m.DescribeTargetGroups(gomock.Any(), &elbv2.DescribeTargetGroupsInput{
 					LoadBalancerArn: aws.String(elbArn),
-				})).Return(&elbv2.DescribeTargetGroupsOutput{
-					TargetGroups: []*elbv2.TargetGroup{},
+				}).Return(&elbv2.DescribeTargetGroupsOutput{
+					TargetGroups: []elbv2types.TargetGroup{},
 				}, nil)
-				m.CreateTargetGroup(gomock.Eq(&elbv2.CreateTargetGroupInput{
+				m.CreateTargetGroup(gomock.Any(), &elbv2.CreateTargetGroupInput{
 					Name:          aws.String("name"),
-					Port:          aws.Int64(infrav1.DefaultAPIServerPort),
-					Protocol:      aws.String("TCP"),
+					Port:          aws.Int32(infrav1.DefaultAPIServerPort),
+					Protocol:      elbv2types.ProtocolEnumTcp,
 					VpcId:         aws.String(vpcID),
-					IpAddressType: aws.String("ipv6"),
-					Tags: []*elbv2.Tag{
+					IpAddressType: elbv2types.TargetGroupIpAddressTypeEnumIpv6,
+					Tags: []elbv2types.Tag{
 						{
 							Key:   aws.String("test"),
 							Value: aws.String("tag"),
@@ -1628,71 +1639,71 @@ func TestReconcileTargetGroupsAndListeners(t *testing.T) {
 					},
 					HealthCheckEnabled:         aws.Bool(true),
 					HealthCheckPort:            aws.String(infrav1.DefaultAPIServerPortString),
-					HealthCheckProtocol:        aws.String("tcp"),
-					HealthyThresholdCount:      aws.Int64(infrav1.DefaultAPIServerHealthThresholdCount),
-					UnhealthyThresholdCount:    aws.Int64(infrav1.DefaultAPIServerUnhealthThresholdCount),
-					HealthCheckIntervalSeconds: aws.Int64(infrav1.DefaultAPIServerHealthCheckIntervalSec),
-					HealthCheckTimeoutSeconds:  aws.Int64(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
-				})).Return(&elbv2.CreateTargetGroupOutput{
-					TargetGroups: []*elbv2.TargetGroup{
+					HealthCheckProtocol:        elbv2types.ProtocolEnumTcp,
+					HealthyThresholdCount:      aws.Int32(infrav1.DefaultAPIServerHealthThresholdCount),
+					UnhealthyThresholdCount:    aws.Int32(infrav1.DefaultAPIServerUnhealthThresholdCount),
+					HealthCheckIntervalSeconds: aws.Int32(infrav1.DefaultAPIServerHealthCheckIntervalSec),
+					HealthCheckTimeoutSeconds:  aws.Int32(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
+				}).Return(&elbv2.CreateTargetGroupOutput{
+					TargetGroups: []elbv2types.TargetGroup{
 						{
 							TargetGroupArn:             aws.String(tgArn),
 							TargetGroupName:            aws.String("name"),
 							VpcId:                      aws.String(vpcID),
-							HealthyThresholdCount:      aws.Int64(infrav1.DefaultAPIServerHealthThresholdCount),
-							UnhealthyThresholdCount:    aws.Int64(infrav1.DefaultAPIServerUnhealthThresholdCount),
-							HealthCheckIntervalSeconds: aws.Int64(infrav1.DefaultAPIServerHealthCheckIntervalSec),
-							HealthCheckTimeoutSeconds:  aws.Int64(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
-							IpAddressType:              aws.String("ipv6"),
+							HealthyThresholdCount:      aws.Int32(infrav1.DefaultAPIServerHealthThresholdCount),
+							UnhealthyThresholdCount:    aws.Int32(infrav1.DefaultAPIServerUnhealthThresholdCount),
+							HealthCheckIntervalSeconds: aws.Int32(infrav1.DefaultAPIServerHealthCheckIntervalSec),
+							HealthCheckTimeoutSeconds:  aws.Int32(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
+							IpAddressType:              elbv2types.TargetGroupIpAddressTypeEnumIpv6,
 						},
 					},
 				}, nil)
-				m.ModifyTargetGroupAttributes(gomock.Eq(&elbv2.ModifyTargetGroupAttributesInput{
+				m.ModifyTargetGroupAttributes(gomock.Any(), &elbv2.ModifyTargetGroupAttributesInput{
 					TargetGroupArn: aws.String(tgArn),
-					Attributes: []*elbv2.TargetGroupAttribute{
+					Attributes: []elbv2types.TargetGroupAttribute{
 						{
 							Key:   aws.String(infrav1.TargetGroupAttributeEnablePreserveClientIP),
 							Value: aws.String("false"),
 						},
 					},
-				})).Return(nil, nil)
-				m.DescribeListeners(gomock.Eq(&elbv2.DescribeListenersInput{
+				}).Return(nil, nil)
+				m.DescribeListeners(gomock.Any(), &elbv2.DescribeListenersInput{
 					LoadBalancerArn: aws.String(elbArn),
-				})).Return(&elbv2.DescribeListenersOutput{
-					Listeners: []*elbv2.Listener{},
+				}).Return(&elbv2.DescribeListenersOutput{
+					Listeners: []elbv2types.Listener{},
 				}, nil)
-				m.CreateListener(gomock.Eq(&elbv2.CreateListenerInput{
-					DefaultActions: []*elbv2.Action{
+				m.CreateListener(gomock.Any(), &elbv2.CreateListenerInput{
+					DefaultActions: []elbv2types.Action{
 						{
 							TargetGroupArn: aws.String(tgArn),
-							Type:           aws.String(elbv2.ActionTypeEnumForward),
+							Type:           elbv2types.ActionTypeEnumForward,
 						},
 					},
 					LoadBalancerArn: aws.String(elbArn),
-					Port:            aws.Int64(infrav1.DefaultAPIServerPort),
-					Protocol:        aws.String("TCP"),
-					Tags: []*elbv2.Tag{
+					Port:            aws.Int32(infrav1.DefaultAPIServerPort),
+					Protocol:        elbv2types.ProtocolEnumTcp,
+					Tags: []elbv2types.Tag{
 						{
 							Key:   aws.String("test"),
 							Value: aws.String("tag"),
 						},
 					},
-				})).Return(&elbv2.CreateListenerOutput{
-					Listeners: []*elbv2.Listener{
+				}).Return(&elbv2.CreateListenerOutput{
+					Listeners: []elbv2types.Listener{
 						{
 							ListenerArn: aws.String("listener::arn"),
 						},
 					},
 				}, nil)
 			},
-			check: func(t *testing.T, tgs []*elbv2.TargetGroup, _ []*elbv2.Listener, err error) {
+			check: func(t *testing.T, tgs []*elbv2types.TargetGroup, _ []*elbv2types.Listener, err error) {
 				t.Helper()
 				if err != nil {
 					t.Fatalf("did not expect error: %v", err)
 				}
 				tg := tgs[0]
-				got := *tg.IpAddressType
-				want := "ipv6"
+				got := tg.IpAddressType
+				want := elbv2types.TargetGroupIpAddressTypeEnumIpv6
 				if got != want {
 					t.Fatalf("did not set ip address type to ipv6")
 				}
@@ -1719,79 +1730,79 @@ func TestReconcileTargetGroupsAndListeners(t *testing.T) {
 				return acl
 			},
 			elbV2APIMocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.DescribeTargetGroups(gomock.Eq(&elbv2.DescribeTargetGroupsInput{
+				m.DescribeTargetGroups(gomock.Any(), &elbv2.DescribeTargetGroupsInput{
 					LoadBalancerArn: aws.String(elbArn),
-				})).Return(&elbv2.DescribeTargetGroupsOutput{
-					TargetGroups: []*elbv2.TargetGroup{},
+				}).Return(&elbv2.DescribeTargetGroupsOutput{
+					TargetGroups: []elbv2types.TargetGroup{},
 				}, nil)
-				m.CreateTargetGroup(gomock.Eq(&elbv2.CreateTargetGroupInput{
+				m.CreateTargetGroup(gomock.Any(), &elbv2.CreateTargetGroupInput{
 					Name:     aws.String("name"),
-					Port:     aws.Int64(infrav1.DefaultAPIServerPort),
-					Protocol: aws.String("TCP"),
+					Port:     aws.Int32(infrav1.DefaultAPIServerPort),
+					Protocol: elbv2types.ProtocolEnumTcp,
 					VpcId:    aws.String(vpcID),
-					Tags: []*elbv2.Tag{
+					Tags: []elbv2types.Tag{
 						{
 							Key:   aws.String("test"),
 							Value: aws.String("tag"),
 						},
 					},
-					HealthyThresholdCount:      aws.Int64(infrav1.DefaultAPIServerHealthThresholdCount),
-					UnhealthyThresholdCount:    aws.Int64(infrav1.DefaultAPIServerUnhealthThresholdCount),
-					HealthCheckIntervalSeconds: aws.Int64(infrav1.DefaultAPIServerHealthCheckIntervalSec),
-					HealthCheckTimeoutSeconds:  aws.Int64(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
-				})).Return(&elbv2.CreateTargetGroupOutput{
-					TargetGroups: []*elbv2.TargetGroup{
+					HealthyThresholdCount:      aws.Int32(infrav1.DefaultAPIServerHealthThresholdCount),
+					UnhealthyThresholdCount:    aws.Int32(infrav1.DefaultAPIServerUnhealthThresholdCount),
+					HealthCheckIntervalSeconds: aws.Int32(infrav1.DefaultAPIServerHealthCheckIntervalSec),
+					HealthCheckTimeoutSeconds:  aws.Int32(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
+				}).Return(&elbv2.CreateTargetGroupOutput{
+					TargetGroups: []elbv2types.TargetGroup{
 						{
 							TargetGroupArn:             aws.String(tgArn),
 							TargetGroupName:            aws.String("name"),
 							VpcId:                      aws.String(vpcID),
-							HealthyThresholdCount:      aws.Int64(infrav1.DefaultAPIServerHealthThresholdCount),
-							UnhealthyThresholdCount:    aws.Int64(infrav1.DefaultAPIServerUnhealthThresholdCount),
-							HealthCheckIntervalSeconds: aws.Int64(infrav1.DefaultAPIServerHealthCheckIntervalSec),
-							HealthCheckTimeoutSeconds:  aws.Int64(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
+							HealthyThresholdCount:      aws.Int32(infrav1.DefaultAPIServerHealthThresholdCount),
+							UnhealthyThresholdCount:    aws.Int32(infrav1.DefaultAPIServerUnhealthThresholdCount),
+							HealthCheckIntervalSeconds: aws.Int32(infrav1.DefaultAPIServerHealthCheckIntervalSec),
+							HealthCheckTimeoutSeconds:  aws.Int32(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
 							HealthCheckEnabled:         aws.Bool(false),
 						},
 					},
 				}, nil)
-				m.ModifyTargetGroupAttributes(gomock.Eq(&elbv2.ModifyTargetGroupAttributesInput{
+				m.ModifyTargetGroupAttributes(gomock.Any(), &elbv2.ModifyTargetGroupAttributesInput{
 					TargetGroupArn: aws.String(tgArn),
-					Attributes: []*elbv2.TargetGroupAttribute{
+					Attributes: []elbv2types.TargetGroupAttribute{
 						{
 							Key:   aws.String(infrav1.TargetGroupAttributeEnablePreserveClientIP),
 							Value: aws.String("false"),
 						},
 					},
-				})).Return(nil, nil)
-				m.DescribeListeners(gomock.Eq(&elbv2.DescribeListenersInput{
+				}).Return(nil, nil)
+				m.DescribeListeners(gomock.Any(), &elbv2.DescribeListenersInput{
 					LoadBalancerArn: aws.String(elbArn),
-				})).Return(&elbv2.DescribeListenersOutput{
-					Listeners: []*elbv2.Listener{},
+				}).Return(&elbv2.DescribeListenersOutput{
+					Listeners: []elbv2types.Listener{},
 				}, nil)
-				m.CreateListener(gomock.Eq(&elbv2.CreateListenerInput{
-					DefaultActions: []*elbv2.Action{
+				m.CreateListener(gomock.Any(), &elbv2.CreateListenerInput{
+					DefaultActions: []elbv2types.Action{
 						{
 							TargetGroupArn: aws.String(tgArn),
-							Type:           aws.String(elbv2.ActionTypeEnumForward),
+							Type:           elbv2types.ActionTypeEnumForward,
 						},
 					},
 					LoadBalancerArn: aws.String(elbArn),
-					Port:            aws.Int64(infrav1.DefaultAPIServerPort),
-					Protocol:        aws.String("TCP"),
-					Tags: []*elbv2.Tag{
+					Port:            aws.Int32(infrav1.DefaultAPIServerPort),
+					Protocol:        elbv2types.ProtocolEnumTcp,
+					Tags: []elbv2types.Tag{
 						{
 							Key:   aws.String("test"),
 							Value: aws.String("tag"),
 						},
 					},
-				})).Return(&elbv2.CreateListenerOutput{
-					Listeners: []*elbv2.Listener{
+				}).Return(&elbv2.CreateListenerOutput{
+					Listeners: []elbv2types.Listener{
 						{
 							ListenerArn: aws.String("listener::arn"),
 						},
 					},
 				}, nil)
 			},
-			check: func(t *testing.T, tgs []*elbv2.TargetGroup, _ []*elbv2.Listener, err error) {
+			check: func(t *testing.T, tgs []*elbv2types.TargetGroup, _ []*elbv2types.Listener, err error) {
 				t.Helper()
 				if err != nil {
 					t.Fatalf("did not expect error: %v", err)
@@ -1813,72 +1824,72 @@ func TestReconcileTargetGroupsAndListeners(t *testing.T) {
 				return acl
 			},
 			elbV2APIMocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.DescribeTargetGroups(gomock.Eq(&elbv2.DescribeTargetGroupsInput{
+				m.DescribeTargetGroups(gomock.Any(), &elbv2.DescribeTargetGroupsInput{
 					LoadBalancerArn: aws.String(elbArn),
-				})).Return(&elbv2.DescribeTargetGroupsOutput{
-					TargetGroups: []*elbv2.TargetGroup{},
+				}).Return(&elbv2.DescribeTargetGroupsOutput{
+					TargetGroups: []elbv2types.TargetGroup{},
 				}, nil)
-				m.CreateTargetGroup(gomock.Eq(&elbv2.CreateTargetGroupInput{
+				m.CreateTargetGroup(gomock.Any(), &elbv2.CreateTargetGroupInput{
 					HealthCheckEnabled:  aws.Bool(true),
 					HealthCheckPort:     aws.String(infrav1.DefaultAPIServerPortString),
-					HealthCheckProtocol: aws.String("tcp"),
+					HealthCheckProtocol: elbv2types.ProtocolEnumTcp,
 					Name:                aws.String("name"),
-					Port:                aws.Int64(infrav1.DefaultAPIServerPort),
-					Protocol:            aws.String("TCP"),
+					Port:                aws.Int32(infrav1.DefaultAPIServerPort),
+					Protocol:            elbv2types.ProtocolEnumTcp,
 					VpcId:               aws.String(vpcID),
-					Tags: []*elbv2.Tag{
+					Tags: []elbv2types.Tag{
 						{
 							Key:   aws.String("test"),
 							Value: aws.String("tag"),
 						},
 					},
-					HealthyThresholdCount:      aws.Int64(infrav1.DefaultAPIServerHealthThresholdCount),
-					UnhealthyThresholdCount:    aws.Int64(infrav1.DefaultAPIServerUnhealthThresholdCount),
-					HealthCheckIntervalSeconds: aws.Int64(infrav1.DefaultAPIServerHealthCheckIntervalSec),
-					HealthCheckTimeoutSeconds:  aws.Int64(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
-				})).Return(&elbv2.CreateTargetGroupOutput{
-					TargetGroups: []*elbv2.TargetGroup{
+					HealthyThresholdCount:      aws.Int32(infrav1.DefaultAPIServerHealthThresholdCount),
+					UnhealthyThresholdCount:    aws.Int32(infrav1.DefaultAPIServerUnhealthThresholdCount),
+					HealthCheckIntervalSeconds: aws.Int32(infrav1.DefaultAPIServerHealthCheckIntervalSec),
+					HealthCheckTimeoutSeconds:  aws.Int32(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
+				}).Return(&elbv2.CreateTargetGroupOutput{
+					TargetGroups: []elbv2types.TargetGroup{
 						{
 							TargetGroupArn:             aws.String(tgArn),
 							TargetGroupName:            aws.String("name"),
 							VpcId:                      aws.String(vpcID),
-							HealthyThresholdCount:      aws.Int64(infrav1.DefaultAPIServerHealthThresholdCount),
-							UnhealthyThresholdCount:    aws.Int64(infrav1.DefaultAPIServerUnhealthThresholdCount),
-							HealthCheckIntervalSeconds: aws.Int64(infrav1.DefaultAPIServerHealthCheckIntervalSec),
-							HealthCheckTimeoutSeconds:  aws.Int64(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
+							HealthyThresholdCount:      aws.Int32(infrav1.DefaultAPIServerHealthThresholdCount),
+							UnhealthyThresholdCount:    aws.Int32(infrav1.DefaultAPIServerUnhealthThresholdCount),
+							HealthCheckIntervalSeconds: aws.Int32(infrav1.DefaultAPIServerHealthCheckIntervalSec),
+							HealthCheckTimeoutSeconds:  aws.Int32(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
 						},
 					},
 				}, nil)
-				m.DescribeListeners(gomock.Eq(&elbv2.DescribeListenersInput{
+				m.DescribeListeners(gomock.Any(), &elbv2.DescribeListenersInput{
 					LoadBalancerArn: aws.String(elbArn),
-				})).Return(&elbv2.DescribeListenersOutput{
-					Listeners: []*elbv2.Listener{},
+				}).Return(&elbv2.DescribeListenersOutput{
+					Listeners: []elbv2types.Listener{},
 				}, nil)
-				m.CreateListener(gomock.Eq(&elbv2.CreateListenerInput{
-					DefaultActions: []*elbv2.Action{
+				m.CreateListener(gomock.Any(), &elbv2.CreateListenerInput{
+					DefaultActions: []elbv2types.Action{
 						{
 							TargetGroupArn: aws.String(tgArn),
-							Type:           aws.String(elbv2.ActionTypeEnumForward),
+							Type:           elbv2types.ActionTypeEnumForward,
 						},
 					},
 					LoadBalancerArn: aws.String(elbArn),
-					Port:            aws.Int64(infrav1.DefaultAPIServerPort),
-					Protocol:        aws.String("TCP"),
-					Tags: []*elbv2.Tag{
+					Port:            aws.Int32(infrav1.DefaultAPIServerPort),
+					Protocol:        elbv2types.ProtocolEnumTcp,
+					Tags: []elbv2types.Tag{
 						{
 							Key:   aws.String("test"),
 							Value: aws.String("tag"),
 						},
 					},
-				})).Return(&elbv2.CreateListenerOutput{
-					Listeners: []*elbv2.Listener{
+				}).Return(&elbv2.CreateListenerOutput{
+					Listeners: []elbv2types.Listener{
 						{
 							ListenerArn: aws.String("listener::arn"),
 						},
 					},
 				}, nil)
 			},
-			check: func(t *testing.T, tgs []*elbv2.TargetGroup, listeners []*elbv2.Listener, err error) {
+			check: func(t *testing.T, tgs []*elbv2types.TargetGroup, listeners []*elbv2types.Listener, err error) {
 				t.Helper()
 				if err != nil {
 					t.Fatalf("did not expect error: %v", err)
@@ -1917,92 +1928,92 @@ func TestReconcileTargetGroupsAndListeners(t *testing.T) {
 				return spec
 			},
 			elbV2APIMocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.DescribeTargetGroups(gomock.Eq(&elbv2.DescribeTargetGroupsInput{
+				m.DescribeTargetGroups(gomock.Any(), &elbv2.DescribeTargetGroupsInput{
 					LoadBalancerArn: aws.String(elbArn),
-				})).Return(&elbv2.DescribeTargetGroupsOutput{
-					TargetGroups: []*elbv2.TargetGroup{},
+				}).Return(&elbv2.DescribeTargetGroupsOutput{
+					TargetGroups: []elbv2types.TargetGroup{},
 				}, nil)
-				m.CreateTargetGroup(gomock.Eq(&elbv2.CreateTargetGroupInput{
+				m.CreateTargetGroup(gomock.Any(), &elbv2.CreateTargetGroupInput{
 					Name:                       aws.String("name"),
-					Port:                       aws.Int64(infrav1.DefaultAPIServerPort),
-					Protocol:                   aws.String("TCP"),
+					Port:                       aws.Int32(infrav1.DefaultAPIServerPort),
+					Protocol:                   elbv2types.ProtocolEnumTcp,
 					VpcId:                      aws.String(vpcID),
 					HealthCheckEnabled:         aws.Bool(true),
 					HealthCheckPort:            aws.String(infrav1.DefaultAPIServerPortString),
-					HealthCheckProtocol:        aws.String("HTTP"),
+					HealthCheckProtocol:        elbv2types.ProtocolEnumHttp,
 					HealthCheckPath:            aws.String("/readyz"),
-					HealthCheckIntervalSeconds: aws.Int64(10),
-					HealthCheckTimeoutSeconds:  aws.Int64(5),
-					HealthyThresholdCount:      aws.Int64(5),
-					UnhealthyThresholdCount:    aws.Int64(3),
-					Tags: []*elbv2.Tag{
+					HealthCheckIntervalSeconds: aws.Int32(10),
+					HealthCheckTimeoutSeconds:  aws.Int32(5),
+					HealthyThresholdCount:      aws.Int32(5),
+					UnhealthyThresholdCount:    aws.Int32(3),
+					Tags: []elbv2types.Tag{
 						{
 							Key:   aws.String("test"),
 							Value: aws.String("tag"),
 						},
 					},
-				})).Return(&elbv2.CreateTargetGroupOutput{
-					TargetGroups: []*elbv2.TargetGroup{
+				}).Return(&elbv2.CreateTargetGroupOutput{
+					TargetGroups: []elbv2types.TargetGroup{
 						{
 							TargetGroupArn:             aws.String(tgArn),
 							TargetGroupName:            aws.String("name"),
 							VpcId:                      aws.String(vpcID),
 							HealthCheckEnabled:         aws.Bool(true),
 							HealthCheckPort:            aws.String(infrav1.DefaultAPIServerPortString),
-							HealthCheckProtocol:        aws.String("HTTP"),
+							HealthCheckProtocol:        elbv2types.ProtocolEnumHttp,
 							HealthCheckPath:            aws.String("/readyz"),
-							HealthCheckIntervalSeconds: aws.Int64(10),
-							HealthCheckTimeoutSeconds:  aws.Int64(5),
-							HealthyThresholdCount:      aws.Int64(5),
-							UnhealthyThresholdCount:    aws.Int64(3),
+							HealthCheckIntervalSeconds: aws.Int32(10),
+							HealthCheckTimeoutSeconds:  aws.Int32(5),
+							HealthyThresholdCount:      aws.Int32(5),
+							UnhealthyThresholdCount:    aws.Int32(3),
 						},
 					},
 				}, nil)
-				m.DescribeListeners(gomock.Eq(&elbv2.DescribeListenersInput{
+				m.DescribeListeners(gomock.Any(), &elbv2.DescribeListenersInput{
 					LoadBalancerArn: aws.String(elbArn),
-				})).Return(&elbv2.DescribeListenersOutput{
-					Listeners: []*elbv2.Listener{},
+				}).Return(&elbv2.DescribeListenersOutput{
+					Listeners: []elbv2types.Listener{},
 				}, nil)
-				m.CreateListener(gomock.Eq(&elbv2.CreateListenerInput{
-					DefaultActions: []*elbv2.Action{
+				m.CreateListener(gomock.Any(), &elbv2.CreateListenerInput{
+					DefaultActions: []elbv2types.Action{
 						{
 							TargetGroupArn: aws.String(tgArn),
-							Type:           aws.String(elbv2.ActionTypeEnumForward),
+							Type:           elbv2types.ActionTypeEnumForward,
 						},
 					},
 					LoadBalancerArn: aws.String(elbArn),
-					Port:            aws.Int64(infrav1.DefaultAPIServerPort),
-					Protocol:        aws.String("TCP"),
-					Tags: []*elbv2.Tag{
+					Port:            aws.Int32(infrav1.DefaultAPIServerPort),
+					Protocol:        elbv2types.ProtocolEnumTcp,
+					Tags: []elbv2types.Tag{
 						{
 							Key:   aws.String("test"),
 							Value: aws.String("tag"),
 						},
 					},
-				})).Return(&elbv2.CreateListenerOutput{
-					Listeners: []*elbv2.Listener{
+				}).Return(&elbv2.CreateListenerOutput{
+					Listeners: []elbv2types.Listener{
 						{
 							ListenerArn: aws.String("listener::arn"),
 						},
 					},
 				}, nil)
-				m.ModifyTargetGroupAttributes(gomock.Eq(&elbv2.ModifyTargetGroupAttributesInput{
+				m.ModifyTargetGroupAttributes(gomock.Any(), &elbv2.ModifyTargetGroupAttributesInput{
 					TargetGroupArn: aws.String(tgArn),
-					Attributes: []*elbv2.TargetGroupAttribute{
+					Attributes: []elbv2types.TargetGroupAttribute{
 						{
 							Key:   aws.String(infrav1.TargetGroupAttributeEnablePreserveClientIP),
 							Value: aws.String("false"),
 						},
 					},
-				})).Return(nil, nil)
+				}).Return(nil, nil)
 			},
-			check: func(t *testing.T, tgs []*elbv2.TargetGroup, _ []*elbv2.Listener, err error) {
+			check: func(t *testing.T, tgs []*elbv2types.TargetGroup, _ []*elbv2types.Listener, err error) {
 				t.Helper()
 				if err != nil {
 					t.Fatalf("did not expect error: %v", err)
 				}
-				got := *tgs[0].HealthCheckProtocol
-				want := "HTTP"
+				got := tgs[0].HealthCheckProtocol
+				want := elbv2types.ProtocolEnumHttp
 				if got != want {
 					t.Fatalf("Health Check protocol for the API Target group did not equal expected value: %s; was: '%s'", want, got)
 				}
@@ -2032,92 +2043,92 @@ func TestReconcileTargetGroupsAndListeners(t *testing.T) {
 				return spec
 			},
 			elbV2APIMocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.DescribeTargetGroups(gomock.Eq(&elbv2.DescribeTargetGroupsInput{
+				m.DescribeTargetGroups(gomock.Any(), &elbv2.DescribeTargetGroupsInput{
 					LoadBalancerArn: aws.String(elbArn),
-				})).Return(&elbv2.DescribeTargetGroupsOutput{
-					TargetGroups: []*elbv2.TargetGroup{},
+				}).Return(&elbv2.DescribeTargetGroupsOutput{
+					TargetGroups: []elbv2types.TargetGroup{},
 				}, nil)
-				m.CreateTargetGroup(gomock.Eq(&elbv2.CreateTargetGroupInput{
+				m.CreateTargetGroup(gomock.Any(), &elbv2.CreateTargetGroupInput{
 					Name:                       aws.String("name"),
-					Port:                       aws.Int64(infrav1.DefaultAPIServerPort),
-					Protocol:                   aws.String("TCP"),
+					Port:                       aws.Int32(infrav1.DefaultAPIServerPort),
+					Protocol:                   elbv2types.ProtocolEnumTcp,
 					VpcId:                      aws.String(vpcID),
 					HealthCheckEnabled:         aws.Bool(true),
 					HealthCheckPort:            aws.String(infrav1.DefaultAPIServerPortString),
-					HealthCheckProtocol:        aws.String("HTTPS"),
+					HealthCheckProtocol:        elbv2types.ProtocolEnumHttps,
 					HealthCheckPath:            aws.String("/readyz"),
-					HealthCheckIntervalSeconds: aws.Int64(10),
-					HealthCheckTimeoutSeconds:  aws.Int64(5),
-					HealthyThresholdCount:      aws.Int64(5),
-					UnhealthyThresholdCount:    aws.Int64(3),
-					Tags: []*elbv2.Tag{
+					HealthCheckIntervalSeconds: aws.Int32(10),
+					HealthCheckTimeoutSeconds:  aws.Int32(5),
+					HealthyThresholdCount:      aws.Int32(5),
+					UnhealthyThresholdCount:    aws.Int32(3),
+					Tags: []elbv2types.Tag{
 						{
 							Key:   aws.String("test"),
 							Value: aws.String("tag"),
 						},
 					},
-				})).Return(&elbv2.CreateTargetGroupOutput{
-					TargetGroups: []*elbv2.TargetGroup{
+				}).Return(&elbv2.CreateTargetGroupOutput{
+					TargetGroups: []elbv2types.TargetGroup{
 						{
 							TargetGroupArn:             aws.String(tgArn),
 							TargetGroupName:            aws.String("name"),
 							VpcId:                      aws.String(vpcID),
 							HealthCheckEnabled:         aws.Bool(true),
 							HealthCheckPort:            aws.String(infrav1.DefaultAPIServerPortString),
-							HealthCheckProtocol:        aws.String("HTTPS"),
+							HealthCheckProtocol:        elbv2types.ProtocolEnumHttps,
 							HealthCheckPath:            aws.String("/readyz"),
-							HealthCheckIntervalSeconds: aws.Int64(10),
-							HealthCheckTimeoutSeconds:  aws.Int64(5),
-							HealthyThresholdCount:      aws.Int64(5),
-							UnhealthyThresholdCount:    aws.Int64(3),
+							HealthCheckIntervalSeconds: aws.Int32(10),
+							HealthCheckTimeoutSeconds:  aws.Int32(5),
+							HealthyThresholdCount:      aws.Int32(5),
+							UnhealthyThresholdCount:    aws.Int32(3),
 						},
 					},
 				}, nil)
-				m.DescribeListeners(gomock.Eq(&elbv2.DescribeListenersInput{
+				m.DescribeListeners(gomock.Any(), &elbv2.DescribeListenersInput{
 					LoadBalancerArn: aws.String(elbArn),
-				})).Return(&elbv2.DescribeListenersOutput{
-					Listeners: []*elbv2.Listener{},
+				}).Return(&elbv2.DescribeListenersOutput{
+					Listeners: []elbv2types.Listener{},
 				}, nil)
-				m.CreateListener(gomock.Eq(&elbv2.CreateListenerInput{
-					DefaultActions: []*elbv2.Action{
+				m.CreateListener(gomock.Any(), &elbv2.CreateListenerInput{
+					DefaultActions: []elbv2types.Action{
 						{
 							TargetGroupArn: aws.String(tgArn),
-							Type:           aws.String(elbv2.ActionTypeEnumForward),
+							Type:           elbv2types.ActionTypeEnumForward,
 						},
 					},
 					LoadBalancerArn: aws.String(elbArn),
-					Port:            aws.Int64(infrav1.DefaultAPIServerPort),
-					Protocol:        aws.String("TCP"),
-					Tags: []*elbv2.Tag{
+					Port:            aws.Int32(infrav1.DefaultAPIServerPort),
+					Protocol:        elbv2types.ProtocolEnumTcp,
+					Tags: []elbv2types.Tag{
 						{
 							Key:   aws.String("test"),
 							Value: aws.String("tag"),
 						},
 					},
-				})).Return(&elbv2.CreateListenerOutput{
-					Listeners: []*elbv2.Listener{
+				}).Return(&elbv2.CreateListenerOutput{
+					Listeners: []elbv2types.Listener{
 						{
 							ListenerArn: aws.String("listener::arn"),
 						},
 					},
 				}, nil)
-				m.ModifyTargetGroupAttributes(gomock.Eq(&elbv2.ModifyTargetGroupAttributesInput{
+				m.ModifyTargetGroupAttributes(gomock.Any(), &elbv2.ModifyTargetGroupAttributesInput{
 					TargetGroupArn: aws.String(tgArn),
-					Attributes: []*elbv2.TargetGroupAttribute{
+					Attributes: []elbv2types.TargetGroupAttribute{
 						{
 							Key:   aws.String(infrav1.TargetGroupAttributeEnablePreserveClientIP),
 							Value: aws.String("false"),
 						},
 					},
-				})).Return(nil, nil)
+				}).Return(nil, nil)
 			},
-			check: func(t *testing.T, tgs []*elbv2.TargetGroup, _ []*elbv2.Listener, err error) {
+			check: func(t *testing.T, tgs []*elbv2types.TargetGroup, _ []*elbv2types.Listener, err error) {
 				t.Helper()
 				if err != nil {
 					t.Fatalf("did not expect error: %v", err)
 				}
-				got := *tgs[0].HealthCheckProtocol
-				want := "HTTPS"
+				got := tgs[0].HealthCheckProtocol
+				want := elbv2types.ProtocolEnumHttps
 				if got != want {
 					t.Fatalf("Health Check protocol for the API Target group did not equal expected value: %s; was: '%s'", want, got)
 				}
@@ -2125,6 +2136,8 @@ func TestReconcileTargetGroupsAndListeners(t *testing.T) {
 		},
 	}
 
+	ctx := context.TODO()
+
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			mockCtrl := gomock.NewController(t)
@@ -2200,7 +2213,7 @@ func TestReconcileTargetGroupsAndListeners(t *testing.T) {
 			}
 
 			spec := tc.spec(*loadBalancerSpec)
-			tgs, listeners, err := s.reconcileTargetGroupsAndListeners(spec.ARN, &spec, clusterScope.ControlPlaneLoadBalancer())
+			tgs, listeners, err := s.reconcileTargetGroupsAndListeners(ctx, spec.ARN, &spec, clusterScope.ControlPlaneLoadBalancer())
 			tc.check(t, tgs, listeners, err)
 		})
 	}
@@ -2235,16 +2248,16 @@ func TestReconcileV2LB(t *testing.T) {
 				return acl
 			},
 			elbV2APIMocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.DescribeLoadBalancers(gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-					Names: aws.StringSlice([]string{elbName}),
-				})).
+				m.DescribeLoadBalancers(gomock.Any(), &elbv2.DescribeLoadBalancersInput{
+					Names: []string{elbName},
+				}).
 					Return(&elbv2.DescribeLoadBalancersOutput{
-						LoadBalancers: []*elbv2.LoadBalancer{
+						LoadBalancers: []elbv2types.LoadBalancer{
 							{
 								LoadBalancerArn:  aws.String(elbArn),
 								LoadBalancerName: aws.String(elbName),
-								Scheme:           aws.String(string(infrav1.ELBSchemeInternetFacing)),
-								AvailabilityZones: []*elbv2.AvailabilityZone{
+								Scheme:           SchemeToSDKScheme(infrav1.ELBSchemeInternetFacing),
+								AvailabilityZones: []elbv2types.AvailabilityZone{
 									{
 										SubnetId: aws.String(clusterSubnetID),
 										ZoneName: aws.String(az),
@@ -2254,9 +2267,9 @@ func TestReconcileV2LB(t *testing.T) {
 							},
 						},
 					}, nil)
-				m.DescribeLoadBalancerAttributes(&elbv2.DescribeLoadBalancerAttributesInput{LoadBalancerArn: aws.String(elbArn)}).Return(
+				m.DescribeLoadBalancerAttributes(gomock.Any(), &elbv2.DescribeLoadBalancerAttributesInput{LoadBalancerArn: aws.String(elbArn)}).Return(
 					&elbv2.DescribeLoadBalancerAttributesOutput{
-						Attributes: []*elbv2.LoadBalancerAttribute{
+						Attributes: []elbv2types.LoadBalancerAttribute{
 							{
 								Key:   aws.String("load_balancing.cross_zone.enabled"),
 								Value: aws.String("false"),
@@ -2265,20 +2278,20 @@ func TestReconcileV2LB(t *testing.T) {
 					},
 					nil,
 				)
-				m.DescribeTags(&elbv2.DescribeTagsInput{ResourceArns: []*string{aws.String(elbArn)}}).Return(
+				m.DescribeTags(gomock.Any(), &elbv2.DescribeTagsInput{ResourceArns: []string{elbArn}}).Return(
 					&elbv2.DescribeTagsOutput{
-						TagDescriptions: []*elbv2.TagDescription{
+						TagDescriptions: []elbv2types.TagDescription{
 							{
 								ResourceArn: aws.String(elbArn),
-								Tags:        []*elbv2.Tag{},
+								Tags:        []elbv2types.Tag{},
 							},
 						},
 					},
 					nil,
 				)
-				m.WaitUntilLoadBalancerAvailableWithContext(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-					LoadBalancerArns: aws.StringSlice([]string{elbArn}),
-				})).Return(nil)
+				m.WaitUntilLoadBalancerAvailable(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
+					LoadBalancerArns: []string{elbArn},
+				}), maxWaitActiveUpdateDelete).Return(nil)
 			},
 			check: func(t *testing.T, lb *infrav1.LoadBalancer, err error) {
 				t.Helper()
@@ -2302,16 +2315,16 @@ func TestReconcileV2LB(t *testing.T) {
 				return acl
 			},
 			elbV2APIMocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.DescribeLoadBalancers(gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-					Names: aws.StringSlice([]string{elbName}),
+				m.DescribeLoadBalancers(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
+					Names: []string{elbName},
 				})).
 					Return(&elbv2.DescribeLoadBalancersOutput{
-						LoadBalancers: []*elbv2.LoadBalancer{
+						LoadBalancers: []elbv2types.LoadBalancer{
 							{
 								LoadBalancerArn:  aws.String(elbArn),
 								LoadBalancerName: aws.String(elbName),
-								Scheme:           aws.String(string(infrav1.ELBSchemeInternetFacing)),
-								AvailabilityZones: []*elbv2.AvailabilityZone{
+								Scheme:           SchemeToSDKScheme(infrav1.ELBSchemeInternetFacing),
+								AvailabilityZones: []elbv2types.AvailabilityZone{
 									{
 										SubnetId: aws.String(clusterSubnetID),
 										ZoneName: aws.String(az),
@@ -2321,24 +2334,24 @@ func TestReconcileV2LB(t *testing.T) {
 							},
 						},
 					}, nil)
-				m.DescribeTargetGroups(gomock.Eq(&elbv2.DescribeTargetGroupsInput{
+				m.DescribeTargetGroups(gomock.Any(), gomock.Eq(&elbv2.DescribeTargetGroupsInput{
 					LoadBalancerArn: aws.String(elbArn),
 				})).
 					Return(&elbv2.DescribeTargetGroupsOutput{
 						NextMarker: new(string),
-						TargetGroups: []*elbv2.TargetGroup{
+						TargetGroups: []elbv2types.TargetGroup{
 							{
 								HealthCheckEnabled: aws.Bool(true),
-								LoadBalancerArns:   []*string{aws.String(elbArn)},
-								Matcher:            &elbv2.Matcher{},
+								LoadBalancerArns:   []string{elbArn},
+								Matcher:            &elbv2types.Matcher{},
 								TargetGroupArn:     aws.String(tgArn),
 								TargetGroupName:    aws.String("targetGroup"),
 							},
 						},
 					}, nil)
-				m.ModifyLoadBalancerAttributes(&elbv2.ModifyLoadBalancerAttributesInput{
+				m.ModifyLoadBalancerAttributes(gomock.Any(), &elbv2.ModifyLoadBalancerAttributesInput{
 					LoadBalancerArn: aws.String(elbArn),
-					Attributes: []*elbv2.LoadBalancerAttribute{
+					Attributes: []elbv2types.LoadBalancerAttribute{
 						{
 							Key:   aws.String("load_balancing.cross_zone.enabled"),
 							Value: aws.String("false"),
@@ -2347,18 +2360,18 @@ func TestReconcileV2LB(t *testing.T) {
 				}).
 					Return(&elbv2.ModifyLoadBalancerAttributesOutput{}, nil)
 
-				m.CreateTargetGroup(helpers.PartialMatchCreateTargetGroupInput(t, &elbv2.CreateTargetGroupInput{
+				m.CreateTargetGroup(gomock.Any(), helpers.PartialMatchCreateTargetGroupInput(t, &elbv2.CreateTargetGroupInput{
 					HealthCheckEnabled:         aws.Bool(true),
-					HealthCheckIntervalSeconds: aws.Int64(infrav1.DefaultAPIServerHealthCheckIntervalSec),
+					HealthCheckIntervalSeconds: aws.Int32(infrav1.DefaultAPIServerHealthCheckIntervalSec),
 					HealthCheckPort:            aws.String(infrav1.DefaultAPIServerPortString),
-					HealthCheckProtocol:        aws.String("TCP"),
-					HealthCheckTimeoutSeconds:  aws.Int64(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
-					HealthyThresholdCount:      aws.Int64(infrav1.DefaultAPIServerHealthThresholdCount),
+					HealthCheckProtocol:        elbv2types.ProtocolEnumTcp,
+					HealthCheckTimeoutSeconds:  aws.Int32(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
+					HealthyThresholdCount:      aws.Int32(infrav1.DefaultAPIServerHealthThresholdCount),
 					// Note: this is treated as a prefix with the partial matcher.
 					Name:     aws.String("apiserver-target"),
-					Port:     aws.Int64(infrav1.DefaultAPIServerPort),
-					Protocol: aws.String("TCP"),
-					Tags: []*elbv2.Tag{
+					Port:     aws.Int32(infrav1.DefaultAPIServerPort),
+					Protocol: elbv2types.ProtocolEnumTcp,
+					Tags: []elbv2types.Tag{
 						{
 							Key:   aws.String("Name"),
 							Value: aws.String("bar-apiserver"),
@@ -2372,24 +2385,24 @@ func TestReconcileV2LB(t *testing.T) {
 							Value: aws.String("apiserver"),
 						},
 					},
-					UnhealthyThresholdCount: aws.Int64(infrav1.DefaultAPIServerUnhealthThresholdCount),
+					UnhealthyThresholdCount: aws.Int32(infrav1.DefaultAPIServerUnhealthThresholdCount),
 					VpcId:                   aws.String(vpcID),
 				})).Return(&elbv2.CreateTargetGroupOutput{
-					TargetGroups: []*elbv2.TargetGroup{
+					TargetGroups: []elbv2types.TargetGroup{
 						{
 							TargetGroupArn:             aws.String(tgArn),
 							VpcId:                      aws.String(vpcID),
-							HealthyThresholdCount:      aws.Int64(infrav1.DefaultAPIServerHealthThresholdCount),
-							UnhealthyThresholdCount:    aws.Int64(infrav1.DefaultAPIServerUnhealthThresholdCount),
-							HealthCheckIntervalSeconds: aws.Int64(infrav1.DefaultAPIServerHealthCheckIntervalSec),
-							HealthCheckTimeoutSeconds:  aws.Int64(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
+							HealthyThresholdCount:      aws.Int32(infrav1.DefaultAPIServerHealthThresholdCount),
+							UnhealthyThresholdCount:    aws.Int32(infrav1.DefaultAPIServerUnhealthThresholdCount),
+							HealthCheckIntervalSeconds: aws.Int32(infrav1.DefaultAPIServerHealthCheckIntervalSec),
+							HealthCheckTimeoutSeconds:  aws.Int32(infrav1.DefaultAPIServerHealthCheckTimeoutSec),
 						},
 					},
 				}, nil)
 
-				m.ModifyTargetGroupAttributes(gomock.Eq(&elbv2.ModifyTargetGroupAttributesInput{
+				m.ModifyTargetGroupAttributes(gomock.Any(), gomock.Eq(&elbv2.ModifyTargetGroupAttributesInput{
 					TargetGroupArn: aws.String(tgArn),
-					Attributes: []*elbv2.TargetGroupAttribute{
+					Attributes: []elbv2types.TargetGroupAttribute{
 						{
 							Key:   aws.String(infrav1.TargetGroupAttributeEnablePreserveClientIP),
 							Value: aws.String("false"),
@@ -2397,29 +2410,29 @@ func TestReconcileV2LB(t *testing.T) {
 					},
 				})).Return(nil, nil)
 
-				m.DescribeListeners(gomock.Eq(&elbv2.DescribeListenersInput{
+				m.DescribeListeners(gomock.Any(), gomock.Eq(&elbv2.DescribeListenersInput{
 					LoadBalancerArn: aws.String(elbArn),
 				})).
 					Return(&elbv2.DescribeListenersOutput{
-						Listeners: []*elbv2.Listener{{
-							DefaultActions: []*elbv2.Action{{
+						Listeners: []elbv2types.Listener{{
+							DefaultActions: []elbv2types.Action{{
 								TargetGroupArn: aws.String("arn::targetgroup"),
 							}},
 							ListenerArn:     aws.String("arn::listener"),
 							LoadBalancerArn: aws.String(elbArn),
 						}},
 					}, nil)
-				m.CreateListener(gomock.Eq(&elbv2.CreateListenerInput{
-					DefaultActions: []*elbv2.Action{
+				m.CreateListener(gomock.Any(), gomock.Eq(&elbv2.CreateListenerInput{
+					DefaultActions: []elbv2types.Action{
 						{
 							TargetGroupArn: aws.String(tgArn),
-							Type:           aws.String(elbv2.ActionTypeEnumForward),
+							Type:           elbv2types.ActionTypeEnumForward,
 						},
 					},
 					LoadBalancerArn: aws.String(elbArn),
-					Port:            aws.Int64(infrav1.DefaultAPIServerPort),
-					Protocol:        aws.String("TCP"),
-					Tags: []*elbv2.Tag{
+					Port:            aws.Int32(infrav1.DefaultAPIServerPort),
+					Protocol:        elbv2types.ProtocolEnumTcp,
+					Tags: []elbv2types.Tag{
 						{
 							Key:   aws.String("Name"),
 							Value: aws.String("bar-apiserver"),
@@ -2434,23 +2447,23 @@ func TestReconcileV2LB(t *testing.T) {
 						},
 					},
 				})).Return(&elbv2.CreateListenerOutput{
-					Listeners: []*elbv2.Listener{
+					Listeners: []elbv2types.Listener{
 						{
-							DefaultActions: []*elbv2.Action{
+							DefaultActions: []elbv2types.Action{
 								{
 									TargetGroupArn: aws.String(tgArn),
-									Type:           aws.String(elbv2.ActionTypeEnumForward),
+									Type:           elbv2types.ActionTypeEnumForward,
 								},
 							},
 							ListenerArn: aws.String("listener::arn"),
-							Port:        aws.Int64(infrav1.DefaultAPIServerPort),
-							Protocol:    aws.String("TCP"),
+							Port:        aws.Int32(infrav1.DefaultAPIServerPort),
+							Protocol:    elbv2types.ProtocolEnumTcp,
 						},
 					},
 				}, nil)
-				m.DescribeLoadBalancerAttributes(&elbv2.DescribeLoadBalancerAttributesInput{LoadBalancerArn: aws.String(elbArn)}).Return(
+				m.DescribeLoadBalancerAttributes(gomock.Any(), &elbv2.DescribeLoadBalancerAttributesInput{LoadBalancerArn: aws.String(elbArn)}).Return(
 					&elbv2.DescribeLoadBalancerAttributesOutput{
-						Attributes: []*elbv2.LoadBalancerAttribute{
+						Attributes: []elbv2types.LoadBalancerAttribute{
 							{
 								Key:   aws.String("load_balancing.cross_zone.enabled"),
 								Value: aws.String("false"),
@@ -2461,12 +2474,12 @@ func TestReconcileV2LB(t *testing.T) {
 							},
 						},
 					}, nil)
-				m.DescribeTags(&elbv2.DescribeTagsInput{ResourceArns: []*string{aws.String(elbArn)}}).Return(
+				m.DescribeTags(gomock.Any(), &elbv2.DescribeTagsInput{ResourceArns: []string{elbArn}}).Return(
 					&elbv2.DescribeTagsOutput{
-						TagDescriptions: []*elbv2.TagDescription{
+						TagDescriptions: []elbv2types.TagDescription{
 							{
 								ResourceArn: aws.String(elbArn),
-								Tags: []*elbv2.Tag{
+								Tags: []elbv2types.Tag{
 									{
 										Key:   aws.String(infrav1.ClusterTagKey(clusterName)),
 										Value: aws.String(string(infrav1.ResourceLifecycleOwned)),
@@ -2477,16 +2490,15 @@ func TestReconcileV2LB(t *testing.T) {
 					}, nil)
 
 				// Avoid the need to sort the AddTagsInput.Tags slice
-				m.AddTags(gomock.AssignableToTypeOf(&elbv2.AddTagsInput{})).Return(&elbv2.AddTagsOutput{}, nil)
+				m.AddTags(gomock.Any(), gomock.AssignableToTypeOf(&elbv2.AddTagsInput{})).Return(&elbv2.AddTagsOutput{}, nil)
 
-				m.SetSubnets(&elbv2.SetSubnetsInput{
+				m.SetSubnets(gomock.Any(), gomock.Eq(&elbv2.SetSubnetsInput{
 					LoadBalancerArn: aws.String(elbArn),
-					Subnets:         []*string{},
-				}).Return(&elbv2.SetSubnetsOutput{}, nil)
+				})).Return(&elbv2.SetSubnetsOutput{}, nil)
 
-				m.WaitUntilLoadBalancerAvailableWithContext(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-					LoadBalancerArns: aws.StringSlice([]string{elbArn}),
-				})).Return(nil)
+				m.WaitUntilLoadBalancerAvailable(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
+					LoadBalancerArns: []string{elbArn},
+				}), maxWaitActiveUpdateDelete).Return(nil)
 			},
 			check: func(t *testing.T, lb *infrav1.LoadBalancer, err error) {
 				t.Helper()
@@ -2500,6 +2512,8 @@ func TestReconcileV2LB(t *testing.T) {
 		},
 	}
 
+	ctx := context.TODO()
+
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			mockCtrl := gomock.NewController(t)
@@ -2534,7 +2548,8 @@ func TestReconcileV2LB(t *testing.T) {
 						Name:      clusterName,
 					},
 				},
-				AWSCluster: &cluster,
+				AWSCluster:                &cluster,
+				MaxWaitActiveUpdateDelete: maxWaitActiveUpdateDelete,
 			})
 			if err != nil {
 				t.Fatal(err)
@@ -2546,7 +2561,7 @@ func TestReconcileV2LB(t *testing.T) {
 				scope:       clusterScope,
 				ELBV2Client: elbV2APIMocks,
 			}
-			reconciler, err := s.getOrCreateV2LB(clusterScope.ControlPlaneLoadBalancer())
+			reconciler, err := s.getOrCreateV2LB(ctx, clusterScope.ControlPlaneLoadBalancer())
 			if err == nil {
 				err = reconciler()
 			}
@@ -2570,13 +2585,13 @@ func TestReconcileLoadbalancers(t *testing.T) {
 		az              = "us-west-1a"
 	)
 
-	primaryELB := func() *elbv2.LoadBalancer {
-		return &elbv2.LoadBalancer{
+	primaryELB := func() elbv2types.LoadBalancer {
+		return elbv2types.LoadBalancer{
 			LoadBalancerArn:  aws.String(elbArn),
 			LoadBalancerName: aws.String(elbName),
 			DNSName:          aws.String(elbName),
-			Scheme:           aws.String(string(infrav1.ELBSchemeInternetFacing)),
-			AvailabilityZones: []*elbv2.AvailabilityZone{
+			Scheme:           SchemeToSDKScheme(infrav1.ELBSchemeInternetFacing),
+			AvailabilityZones: []elbv2types.AvailabilityZone{
 				{
 					SubnetId: aws.String(clusterSubnetID),
 					ZoneName: aws.String(az),
@@ -2586,13 +2601,13 @@ func TestReconcileLoadbalancers(t *testing.T) {
 		}
 	}
 
-	secondaryELB := func() *elbv2.LoadBalancer {
-		return &elbv2.LoadBalancer{
+	secondaryELB := func() elbv2types.LoadBalancer {
+		return elbv2types.LoadBalancer{
 			LoadBalancerArn:  aws.String(secondElbArn),
 			LoadBalancerName: aws.String(secondElbName),
 			DNSName:          aws.String(secondElbName),
-			Scheme:           aws.String(string(infrav1.ELBSchemeInternal)),
-			AvailabilityZones: []*elbv2.AvailabilityZone{
+			Scheme:           SchemeToSDKScheme(infrav1.ELBSchemeInternal),
+			AvailabilityZones: []elbv2types.AvailabilityZone{
 				{
 					SubnetId: aws.String(clusterSubnetID),
 					ZoneName: aws.String(az),
@@ -2621,15 +2636,15 @@ func TestReconcileLoadbalancers(t *testing.T) {
 				return acl
 			},
 			elbV2APIMocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.DescribeLoadBalancers(gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-					Names: aws.StringSlice([]string{elbName}),
+				m.DescribeLoadBalancers(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
+					Names: []string{elbName},
 				})).
 					Return(&elbv2.DescribeLoadBalancersOutput{
-						LoadBalancers: []*elbv2.LoadBalancer{primaryELB()},
+						LoadBalancers: []elbv2types.LoadBalancer{primaryELB()},
 					}, nil)
-				m.DescribeLoadBalancerAttributes(&elbv2.DescribeLoadBalancerAttributesInput{LoadBalancerArn: aws.String(elbArn)}).Return(
+				m.DescribeLoadBalancerAttributes(gomock.Any(), &elbv2.DescribeLoadBalancerAttributesInput{LoadBalancerArn: aws.String(elbArn)}).Return(
 					&elbv2.DescribeLoadBalancerAttributesOutput{
-						Attributes: []*elbv2.LoadBalancerAttribute{
+						Attributes: []elbv2types.LoadBalancerAttribute{
 							{
 								Key:   aws.String("load_balancing.cross_zone.enabled"),
 								Value: aws.String("false"),
@@ -2638,27 +2653,27 @@ func TestReconcileLoadbalancers(t *testing.T) {
 					},
 					nil,
 				)
-				m.DescribeTags(&elbv2.DescribeTagsInput{ResourceArns: []*string{aws.String(elbArn)}}).Return(
+				m.DescribeTags(gomock.Any(), &elbv2.DescribeTagsInput{ResourceArns: []string{elbArn}}).Return(
 					&elbv2.DescribeTagsOutput{
-						TagDescriptions: []*elbv2.TagDescription{
+						TagDescriptions: []elbv2types.TagDescription{
 							{
 								ResourceArn: aws.String(elbArn),
-								Tags:        []*elbv2.Tag{},
+								Tags:        []elbv2types.Tag{},
 							},
 						},
 					},
 					nil,
 				)
 
-				m.DescribeLoadBalancers(gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-					Names: aws.StringSlice([]string{secondElbName}),
+				m.DescribeLoadBalancers(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
+					Names: []string{secondElbName},
 				})).
 					Return(&elbv2.DescribeLoadBalancersOutput{
-						LoadBalancers: []*elbv2.LoadBalancer{secondaryELB()},
+						LoadBalancers: []elbv2types.LoadBalancer{secondaryELB()},
 					}, nil)
-				m.DescribeLoadBalancerAttributes(&elbv2.DescribeLoadBalancerAttributesInput{LoadBalancerArn: aws.String(secondElbArn)}).Return(
+				m.DescribeLoadBalancerAttributes(gomock.Any(), &elbv2.DescribeLoadBalancerAttributesInput{LoadBalancerArn: aws.String(secondElbArn)}).Return(
 					&elbv2.DescribeLoadBalancerAttributesOutput{
-						Attributes: []*elbv2.LoadBalancerAttribute{
+						Attributes: []elbv2types.LoadBalancerAttribute{
 							{
 								Key:   aws.String("load_balancing.cross_zone.enabled"),
 								Value: aws.String("false"),
@@ -2667,23 +2682,23 @@ func TestReconcileLoadbalancers(t *testing.T) {
 					},
 					nil,
 				)
-				m.DescribeTags(&elbv2.DescribeTagsInput{ResourceArns: []*string{aws.String(secondElbArn)}}).Return(
+				m.DescribeTags(gomock.Any(), &elbv2.DescribeTagsInput{ResourceArns: []string{secondElbArn}}).Return(
 					&elbv2.DescribeTagsOutput{
-						TagDescriptions: []*elbv2.TagDescription{
+						TagDescriptions: []elbv2types.TagDescription{
 							{
 								ResourceArn: aws.String(secondElbArn),
-								Tags:        []*elbv2.Tag{},
+								Tags:        []elbv2types.Tag{},
 							},
 						},
 					},
 					nil,
 				)
-				m.WaitUntilLoadBalancerAvailableWithContext(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-					LoadBalancerArns: aws.StringSlice([]string{elbArn}),
-				})).Return(nil)
-				m.WaitUntilLoadBalancerAvailableWithContext(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-					LoadBalancerArns: aws.StringSlice([]string{secondElbArn}),
-				})).Return(nil)
+				m.WaitUntilLoadBalancerAvailable(gomock.Any(), &elbv2.DescribeLoadBalancersInput{
+					LoadBalancerArns: []string{elbArn},
+				}, maxWaitActiveUpdateDelete).Return(nil)
+				m.WaitUntilLoadBalancerAvailable(gomock.Any(), &elbv2.DescribeLoadBalancersInput{
+					LoadBalancerArns: []string{secondElbArn},
+				}, maxWaitActiveUpdateDelete).Return(nil)
 			},
 			check: func(t *testing.T, firstLB *infrav1.LoadBalancer, secondLB *infrav1.LoadBalancer, err error) {
 				t.Helper()
@@ -2712,20 +2727,19 @@ func TestReconcileLoadbalancers(t *testing.T) {
 			},
 			elbV2APIMocks: func(m *mocks.MockELBV2APIMockRecorder) {
 				// Initial DescribeLoadBalancers return empty
-				m.DescribeLoadBalancers(gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-					Names: aws.StringSlice([]string{elbName}),
+				m.DescribeLoadBalancers(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
+					Names: []string{elbName},
 				})).Return(&elbv2.DescribeLoadBalancersOutput{}, nil)
-				m.DescribeLoadBalancers(gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-					Names: aws.StringSlice([]string{secondElbName}),
+				m.DescribeLoadBalancers(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
+					Names: []string{secondElbName},
 				})).Return(&elbv2.DescribeLoadBalancersOutput{}, nil)
 
 				// Create both load balancers
-				createLB1 := m.CreateLoadBalancer(gomock.Eq(&elbv2.CreateLoadBalancerInput{
+				createLB1 := m.CreateLoadBalancer(gomock.Any(), gomock.Eq(&elbv2.CreateLoadBalancerInput{
 					Name:           aws.String(elbName),
-					Scheme:         aws.String(string(infrav1.ELBSchemeInternetFacing)),
-					SecurityGroups: []*string{aws.String("")},
-					Subnets:        []*string{},
-					Tags: []*elbv2.Tag{
+					Scheme:         SchemeToSDKScheme(infrav1.ELBSchemeInternetFacing),
+					SecurityGroups: []string{""},
+					Tags: []elbv2types.Tag{
 						{
 							Key:   aws.String("Name"),
 							Value: aws.String(elbName),
@@ -2739,17 +2753,16 @@ func TestReconcileLoadbalancers(t *testing.T) {
 							Value: aws.String(infrav1.APIServerRoleTagValue),
 						},
 					},
-					Type: aws.String("network"),
+					Type: elbv2types.LoadBalancerTypeEnumNetwork,
 				})).Return(&elbv2.CreateLoadBalancerOutput{
-					LoadBalancers: []*elbv2.LoadBalancer{primaryELB()},
+					LoadBalancers: []elbv2types.LoadBalancer{primaryELB()},
 				}, nil)
 
-				createLB2 := m.CreateLoadBalancer(gomock.Eq(&elbv2.CreateLoadBalancerInput{
+				createLB2 := m.CreateLoadBalancer(gomock.Any(), gomock.Eq(&elbv2.CreateLoadBalancerInput{
 					Name:           aws.String(secondElbName),
-					Scheme:         aws.String(string(infrav1.ELBSchemeInternal)),
-					SecurityGroups: []*string{aws.String("")},
-					Subnets:        []*string{},
-					Tags: []*elbv2.Tag{
+					Scheme:         SchemeToSDKScheme(infrav1.ELBSchemeInternal),
+					SecurityGroups: []string{""},
+					Tags: []elbv2types.Tag{
 						{
 							Key:   aws.String("Name"),
 							Value: aws.String(secondElbName),
@@ -2763,38 +2776,38 @@ func TestReconcileLoadbalancers(t *testing.T) {
 							Value: aws.String(infrav1.APIServerRoleTagValue),
 						},
 					},
-					Type: aws.String("network"),
+					Type: elbv2types.LoadBalancerTypeEnumNetwork,
 				})).Return(&elbv2.CreateLoadBalancerOutput{
-					LoadBalancers: []*elbv2.LoadBalancer{secondaryELB()},
+					LoadBalancers: []elbv2types.LoadBalancer{secondaryELB()},
 				}, nil)
 
 				// Assert that we don't wait for either load balancer to be
 				// available until both load balancers have been created
-				m.WaitUntilLoadBalancerAvailableWithContext(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-					LoadBalancerArns: aws.StringSlice([]string{elbArn}),
-				})).Return(nil).After(createLB1).After(createLB2)
-				m.WaitUntilLoadBalancerAvailableWithContext(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-					LoadBalancerArns: aws.StringSlice([]string{secondElbArn}),
-				})).Return(nil).After(createLB1).After(createLB2)
+				m.WaitUntilLoadBalancerAvailable(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
+					LoadBalancerArns: []string{elbArn},
+				}), maxWaitActiveUpdateDelete).Return(nil).After(createLB1).After(createLB2)
+				m.WaitUntilLoadBalancerAvailable(gomock.Any(), gomock.Eq(&elbv2.DescribeLoadBalancersInput{
+					LoadBalancerArns: []string{secondElbArn},
+				}), maxWaitActiveUpdateDelete).Return(nil).After(createLB1).After(createLB2)
 
 				// Make minimal assertions on other calls not under test
-				m.DescribeTargetGroups(gomock.Any()).Return(&elbv2.DescribeTargetGroupsOutput{}, nil).AnyTimes()
-				m.DescribeListeners(gomock.Any()).Return(&elbv2.DescribeListenersOutput{}, nil).AnyTimes()
-				m.ModifyTargetGroupAttributes(gomock.Any()).Return(nil, nil).AnyTimes()
-				m.ModifyListener(gomock.Any()).Return(nil, nil).AnyTimes()
-				m.SetSecurityGroups(gomock.Any()).Return(nil, nil).AnyTimes()
+				m.DescribeTargetGroups(gomock.Any(), gomock.Any()).Return(&elbv2.DescribeTargetGroupsOutput{}, nil).AnyTimes()
+				m.DescribeListeners(gomock.Any(), gomock.Any()).Return(&elbv2.DescribeListenersOutput{}, nil).AnyTimes()
+				m.ModifyTargetGroupAttributes(gomock.Any(), gomock.Any()).Return(nil, nil).AnyTimes()
+				m.ModifyListener(gomock.Any(), gomock.Any()).Return(nil, nil).AnyTimes()
+				m.SetSecurityGroups(gomock.Any(), gomock.Any()).Return(nil, nil).AnyTimes()
 
 				// These calls return the same info for both load balancers, but it's not important to this test
-				m.CreateTargetGroup(gomock.Any()).Return(&elbv2.CreateTargetGroupOutput{
-					TargetGroups: []*elbv2.TargetGroup{
+				m.CreateTargetGroup(gomock.Any(), gomock.Any()).Return(&elbv2.CreateTargetGroupOutput{
+					TargetGroups: []elbv2types.TargetGroup{
 						{
 							TargetGroupName: aws.String(elbName),
 							TargetGroupArn:  aws.String(elbArn),
 						},
 					},
 				}, nil).AnyTimes()
-				m.CreateListener(gomock.Any()).Return(&elbv2.CreateListenerOutput{
-					Listeners: []*elbv2.Listener{
+				m.CreateListener(gomock.Any(), gomock.Any()).Return(&elbv2.CreateListenerOutput{
+					Listeners: []elbv2types.Listener{
 						{
 							ListenerArn: aws.String(elbArn),
 						},
@@ -2816,6 +2829,8 @@ func TestReconcileLoadbalancers(t *testing.T) {
 		},
 	}
 
+	ctx := context.TODO()
+
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			mockCtrl := gomock.NewController(t)
@@ -2850,7 +2865,8 @@ func TestReconcileLoadbalancers(t *testing.T) {
 						Name:      clusterName,
 					},
 				},
-				AWSCluster: &cluster,
+				AWSCluster:                &cluster,
+				MaxWaitActiveUpdateDelete: maxWaitActiveUpdateDelete,
 			})
 			if err != nil {
 				t.Fatal(err)
@@ -2862,7 +2878,7 @@ func TestReconcileLoadbalancers(t *testing.T) {
 				scope:       clusterScope,
 				ELBV2Client: elbV2APIMocks,
 			}
-			err = s.ReconcileLoadbalancers()
+			err = s.ReconcileLoadbalancers(ctx)
 			firstLB := s.scope.Network().APIServerELB
 			secondLB := s.scope.Network().SecondaryAPIServerELB
 			tc.check(t, &firstLB, &secondLB, err)
@@ -2881,9 +2897,9 @@ func TestDeleteAPIServerELB(t *testing.T) {
 		{
 			name: "if control plane ELB is not found, do nothing",
 			elbAPIMocks: func(m *mocks.MockELBAPIMockRecorder) {
-				m.DescribeLoadBalancers(gomock.Eq(&elb.DescribeLoadBalancersInput{
-					LoadBalancerNames: aws.StringSlice([]string{elbName}),
-				})).Return(nil, awserr.New(elb.ErrCodeAccessPointNotFoundException, "", nil))
+				m.DescribeLoadBalancers(gomock.Any(), &elb.DescribeLoadBalancersInput{
+					LoadBalancerNames: []string{elbName},
+				}).Return(nil, &elbtypes.AccessPointNotFoundException{})
 			},
 			verifyAWSCluster: func(awsCluster *infrav1.AWSCluster) {
 				loadBalancerConditionReady := conditions.IsTrue(awsCluster, infrav1.LoadBalancerReadyCondition)
@@ -2899,9 +2915,9 @@ func TestDeleteAPIServerELB(t *testing.T) {
 		{
 			name: "if control plane ELB is found, and it is not managed, do nothing",
 			elbAPIMocks: func(m *mocks.MockELBAPIMockRecorder) {
-				m.DescribeLoadBalancers(&elb.DescribeLoadBalancersInput{LoadBalancerNames: []*string{aws.String(elbName)}}).Return(
+				m.DescribeLoadBalancers(gomock.Any(), &elb.DescribeLoadBalancersInput{LoadBalancerNames: []string{elbName}}).Return(
 					&elb.DescribeLoadBalancersOutput{
-						LoadBalancerDescriptions: []*elb.LoadBalancerDescription{
+						LoadBalancerDescriptions: []elbtypes.LoadBalancerDescription{
 							{
 								LoadBalancerName: aws.String(elbName),
 								Scheme:           aws.String(string(infrav1.ELBSchemeInternetFacing)),
@@ -2911,23 +2927,23 @@ func TestDeleteAPIServerELB(t *testing.T) {
 					nil,
 				)
 
-				m.DescribeLoadBalancerAttributes(&elb.DescribeLoadBalancerAttributesInput{LoadBalancerName: aws.String(elbName)}).Return(
+				m.DescribeLoadBalancerAttributes(gomock.Any(), &elb.DescribeLoadBalancerAttributesInput{LoadBalancerName: aws.String(elbName)}).Return(
 					&elb.DescribeLoadBalancerAttributesOutput{
-						LoadBalancerAttributes: &elb.LoadBalancerAttributes{
-							CrossZoneLoadBalancing: &elb.CrossZoneLoadBalancing{
-								Enabled: aws.Bool(false),
+						LoadBalancerAttributes: &elbtypes.LoadBalancerAttributes{
+							CrossZoneLoadBalancing: &elbtypes.CrossZoneLoadBalancing{
+								Enabled: false,
 							},
 						},
 					},
 					nil,
 				)
 
-				m.DescribeTags(&elb.DescribeTagsInput{LoadBalancerNames: []*string{aws.String(elbName)}}).Return(
+				m.DescribeTags(gomock.Any(), &elb.DescribeTagsInput{LoadBalancerNames: []string{elbName}}).Return(
 					&elb.DescribeTagsOutput{
-						TagDescriptions: []*elb.TagDescription{
+						TagDescriptions: []elbtypes.TagDescription{
 							{
 								LoadBalancerName: aws.String(elbName),
-								Tags:             []*elb.Tag{},
+								Tags:             []elbtypes.Tag{},
 							},
 						},
 					},
@@ -2948,9 +2964,9 @@ func TestDeleteAPIServerELB(t *testing.T) {
 		{
 			name: "if control plane ELB is found, and it is managed, delete the ELB",
 			elbAPIMocks: func(m *mocks.MockELBAPIMockRecorder) {
-				m.DescribeLoadBalancers(&elb.DescribeLoadBalancersInput{LoadBalancerNames: []*string{aws.String(elbName)}}).Return(
+				m.DescribeLoadBalancers(gomock.Any(), &elb.DescribeLoadBalancersInput{LoadBalancerNames: []string{elbName}}).Return(
 					&elb.DescribeLoadBalancersOutput{
-						LoadBalancerDescriptions: []*elb.LoadBalancerDescription{
+						LoadBalancerDescriptions: []elbtypes.LoadBalancerDescription{
 							{
 								LoadBalancerName: aws.String(elbName),
 								Scheme:           aws.String(string(infrav1.ELBSchemeInternetFacing)),
@@ -2960,23 +2976,23 @@ func TestDeleteAPIServerELB(t *testing.T) {
 					nil,
 				)
 
-				m.DescribeLoadBalancerAttributes(&elb.DescribeLoadBalancerAttributesInput{LoadBalancerName: aws.String(elbName)}).Return(
+				m.DescribeLoadBalancerAttributes(gomock.Any(), &elb.DescribeLoadBalancerAttributesInput{LoadBalancerName: aws.String(elbName)}).Return(
 					&elb.DescribeLoadBalancerAttributesOutput{
-						LoadBalancerAttributes: &elb.LoadBalancerAttributes{
-							CrossZoneLoadBalancing: &elb.CrossZoneLoadBalancing{
-								Enabled: aws.Bool(false),
+						LoadBalancerAttributes: &elbtypes.LoadBalancerAttributes{
+							CrossZoneLoadBalancing: &elbtypes.CrossZoneLoadBalancing{
+								Enabled: false,
 							},
 						},
 					},
 					nil,
 				)
 
-				m.DescribeTags(&elb.DescribeTagsInput{LoadBalancerNames: []*string{aws.String(elbName)}}).Return(
+				m.DescribeTags(gomock.Any(), &elb.DescribeTagsInput{LoadBalancerNames: []string{elbName}}).Return(
 					&elb.DescribeTagsOutput{
-						TagDescriptions: []*elb.TagDescription{
+						TagDescriptions: []elbtypes.TagDescription{
 							{
 								LoadBalancerName: aws.String(elbName),
-								Tags: []*elb.Tag{{
+								Tags: []elbtypes.Tag{{
 									Key:   aws.String(infrav1.ClusterTagKey(clusterName)),
 									Value: aws.String(string(infrav1.ResourceLifecycleOwned)),
 								}},
@@ -2986,12 +3002,12 @@ func TestDeleteAPIServerELB(t *testing.T) {
 					nil,
 				)
 
-				m.DeleteLoadBalancer(&elb.DeleteLoadBalancerInput{LoadBalancerName: aws.String(elbName)}).Return(
+				m.DeleteLoadBalancer(gomock.Any(), &elb.DeleteLoadBalancerInput{LoadBalancerName: aws.String(elbName)}).Return(
 					&elb.DeleteLoadBalancerOutput{}, nil)
 
-				m.DescribeLoadBalancers(&elb.DescribeLoadBalancersInput{LoadBalancerNames: []*string{aws.String(elbName)}}).Return(
+				m.DescribeLoadBalancers(gomock.Any(), &elb.DescribeLoadBalancersInput{LoadBalancerNames: []string{elbName}}).Return(
 					&elb.DescribeLoadBalancersOutput{
-						LoadBalancerDescriptions: []*elb.LoadBalancerDescription{},
+						LoadBalancerDescriptions: []elbtypes.LoadBalancerDescription{},
 					},
 					nil,
 				)
@@ -3009,6 +3025,8 @@ func TestDeleteAPIServerELB(t *testing.T) {
 		},
 	}
 
+	ctx := context.TODO()
+
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			mockCtrl := gomock.NewController(t)
@@ -3054,7 +3072,7 @@ func TestDeleteAPIServerELB(t *testing.T) {
 				ELBClient:             elbapiMock,
 			}
 
-			err = s.deleteAPIServerELB()
+			err = s.deleteAPIServerELB(ctx)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -3076,30 +3094,30 @@ func TestDeleteNLB(t *testing.T) {
 		{
 			name: "if control plane NLB is not found, do nothing",
 			elbv2ApiMock: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.DescribeLoadBalancers(gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-					Names: aws.StringSlice([]string{elbName}),
-				})).Return(nil, awserr.New(elb.ErrCodeAccessPointNotFoundException, "", nil))
+				m.DescribeLoadBalancers(gomock.Any(), &elbv2.DescribeLoadBalancersInput{
+					Names: []string{elbName},
+				}).Return(nil, &elbtypes.AccessPointNotFoundException{})
 			},
 		},
 		{
 			name: "if control plane NLB is found, and it is not managed, do nothing",
 			elbv2ApiMock: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.DescribeLoadBalancers(&elbv2.DescribeLoadBalancersInput{Names: []*string{aws.String(elbName)}}).Return(
+				m.DescribeLoadBalancers(gomock.Any(), &elbv2.DescribeLoadBalancersInput{Names: []string{elbName}}).Return(
 					&elbv2.DescribeLoadBalancersOutput{
-						LoadBalancers: []*elbv2.LoadBalancer{
+						LoadBalancers: []elbv2types.LoadBalancer{
 							{
 								LoadBalancerArn:  aws.String(elbArn),
 								LoadBalancerName: aws.String(elbName),
-								Scheme:           aws.String(string(infrav1.ELBSchemeInternetFacing)),
+								Scheme:           SchemeToSDKScheme(infrav1.ELBSchemeInternetFacing),
 							},
 						},
 					},
 					nil,
 				)
 
-				m.DescribeLoadBalancerAttributes(&elbv2.DescribeLoadBalancerAttributesInput{LoadBalancerArn: aws.String(elbArn)}).Return(
+				m.DescribeLoadBalancerAttributes(gomock.Any(), &elbv2.DescribeLoadBalancerAttributesInput{LoadBalancerArn: aws.String(elbArn)}).Return(
 					&elbv2.DescribeLoadBalancerAttributesOutput{
-						Attributes: []*elbv2.LoadBalancerAttribute{
+						Attributes: []elbv2types.LoadBalancerAttribute{
 							{
 								Key:   aws.String("load_balancing.cross_zone.enabled"),
 								Value: aws.String("false"),
@@ -3109,12 +3127,12 @@ func TestDeleteNLB(t *testing.T) {
 					nil,
 				)
 
-				m.DescribeTags(&elbv2.DescribeTagsInput{ResourceArns: []*string{aws.String(elbArn)}}).Return(
+				m.DescribeTags(gomock.Any(), &elbv2.DescribeTagsInput{ResourceArns: []string{elbArn}}).Return(
 					&elbv2.DescribeTagsOutput{
-						TagDescriptions: []*elbv2.TagDescription{
+						TagDescriptions: []elbv2types.TagDescription{
 							{
 								ResourceArn: aws.String(elbArn),
-								Tags:        []*elbv2.Tag{},
+								Tags:        []elbv2types.Tag{},
 							},
 						},
 					},
@@ -3125,22 +3143,22 @@ func TestDeleteNLB(t *testing.T) {
 		{
 			name: "if control plane ELB is found, and it is managed, delete the ELB",
 			elbv2ApiMock: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.DescribeLoadBalancers(&elbv2.DescribeLoadBalancersInput{Names: []*string{aws.String(elbName)}}).Return(
+				m.DescribeLoadBalancers(gomock.Any(), &elbv2.DescribeLoadBalancersInput{Names: []string{elbName}}).Return(
 					&elbv2.DescribeLoadBalancersOutput{
-						LoadBalancers: []*elbv2.LoadBalancer{
+						LoadBalancers: []elbv2types.LoadBalancer{
 							{
 								LoadBalancerArn:  aws.String(elbArn),
 								LoadBalancerName: aws.String(elbName),
-								Scheme:           aws.String(string(infrav1.ELBSchemeInternetFacing)),
+								Scheme:           SchemeToSDKScheme(infrav1.ELBSchemeInternetFacing),
 							},
 						},
 					},
 					nil,
 				)
 
-				m.DescribeLoadBalancerAttributes(&elbv2.DescribeLoadBalancerAttributesInput{LoadBalancerArn: aws.String(elbArn)}).Return(
+				m.DescribeLoadBalancerAttributes(gomock.Any(), &elbv2.DescribeLoadBalancerAttributesInput{LoadBalancerArn: aws.String(elbArn)}).Return(
 					&elbv2.DescribeLoadBalancerAttributesOutput{
-						Attributes: []*elbv2.LoadBalancerAttribute{
+						Attributes: []elbv2types.LoadBalancerAttribute{
 							{
 								Key:   aws.String("load_balancing.cross_zone.enabled"),
 								Value: aws.String("false"),
@@ -3150,12 +3168,12 @@ func TestDeleteNLB(t *testing.T) {
 					nil,
 				)
 
-				m.DescribeTags(&elbv2.DescribeTagsInput{ResourceArns: []*string{aws.String(elbArn)}}).Return(
+				m.DescribeTags(gomock.Any(), &elbv2.DescribeTagsInput{ResourceArns: []string{elbArn}}).Return(
 					&elbv2.DescribeTagsOutput{
-						TagDescriptions: []*elbv2.TagDescription{
+						TagDescriptions: []elbv2types.TagDescription{
 							{
 								ResourceArn: aws.String(elbArn),
-								Tags: []*elbv2.Tag{{
+								Tags: []elbv2types.Tag{{
 									Key:   aws.String(infrav1.ClusterTagKey(clusterName)),
 									Value: aws.String(string(infrav1.ResourceLifecycleOwned)),
 								}},
@@ -3166,31 +3184,31 @@ func TestDeleteNLB(t *testing.T) {
 				)
 
 				// delete listeners
-				m.DescribeListeners(&elbv2.DescribeListenersInput{LoadBalancerArn: aws.String(elbArn)}).Return(&elbv2.DescribeListenersOutput{
-					Listeners: []*elbv2.Listener{
+				m.DescribeListeners(gomock.Any(), &elbv2.DescribeListenersInput{LoadBalancerArn: aws.String(elbArn)}).Return(&elbv2.DescribeListenersOutput{
+					Listeners: []elbv2types.Listener{
 						{
 							ListenerArn: aws.String("listener::arn"),
 						},
 					},
 				}, nil)
-				m.DeleteListener(&elbv2.DeleteListenerInput{ListenerArn: aws.String("listener::arn")}).Return(&elbv2.DeleteListenerOutput{}, nil)
+				m.DeleteListener(gomock.Any(), &elbv2.DeleteListenerInput{ListenerArn: aws.String("listener::arn")}).Return(&elbv2.DeleteListenerOutput{}, nil)
 				// delete target groups
-				m.DescribeTargetGroups(&elbv2.DescribeTargetGroupsInput{LoadBalancerArn: aws.String(elbArn)}).Return(&elbv2.DescribeTargetGroupsOutput{
-					TargetGroups: []*elbv2.TargetGroup{
+				m.DescribeTargetGroups(gomock.Any(), &elbv2.DescribeTargetGroupsInput{LoadBalancerArn: aws.String(elbArn)}).Return(&elbv2.DescribeTargetGroupsOutput{
+					TargetGroups: []elbv2types.TargetGroup{
 						{
 							TargetGroupArn: aws.String(tgArn),
 						},
 					},
 				}, nil)
-				m.DeleteTargetGroup(&elbv2.DeleteTargetGroupInput{TargetGroupArn: aws.String(tgArn)}).Return(&elbv2.DeleteTargetGroupOutput{}, nil)
+				m.DeleteTargetGroup(gomock.Any(), &elbv2.DeleteTargetGroupInput{TargetGroupArn: aws.String(tgArn)}).Return(&elbv2.DeleteTargetGroupOutput{}, nil)
 				// delete the load balancer
 
-				m.DeleteLoadBalancer(&elbv2.DeleteLoadBalancerInput{LoadBalancerArn: aws.String(elbArn)}).Return(
+				m.DeleteLoadBalancer(gomock.Any(), &elbv2.DeleteLoadBalancerInput{LoadBalancerArn: aws.String(elbArn)}).Return(
 					&elbv2.DeleteLoadBalancerOutput{}, nil)
 
-				m.DescribeLoadBalancers(&elbv2.DescribeLoadBalancersInput{Names: []*string{aws.String(elbName)}}).Return(
+				m.DescribeLoadBalancers(gomock.Any(), &elbv2.DescribeLoadBalancersInput{Names: []string{elbName}}).Return(
 					&elbv2.DescribeLoadBalancersOutput{
-						LoadBalancers: []*elbv2.LoadBalancer{},
+						LoadBalancers: []elbv2types.LoadBalancer{},
 					},
 					nil,
 				)
@@ -3198,6 +3216,8 @@ func TestDeleteNLB(t *testing.T) {
 		},
 	}
 
+	ctx := context.TODO()
+
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			mockCtrl := gomock.NewController(t)
@@ -3244,7 +3264,7 @@ func TestDeleteNLB(t *testing.T) {
 				ELBV2Client:           elbv2ApiMock,
 			}
 
-			err = s.deleteExistingNLBs()
+			err = s.deleteExistingNLBs(ctx)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -3264,59 +3284,59 @@ func TestDeleteAWSCloudProviderELBs(t *testing.T) {
 		{
 			name: "discover ELBs with Resource Groups Tagging API and then delete successfully",
 			rgAPIMocks: func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder) {
-				m.GetResourcesPages(&rgapi.GetResourcesInput{
-					ResourceTypeFilters: aws.StringSlice([]string{elbResourceType}),
-					TagFilters: []*rgapi.TagFilter{
+				m.GetResourcesPages(gomock.Any(), &rgapi.GetResourcesInput{
+					ResourceTypeFilters: []string{elbResourceType},
+					TagFilters: []rgapitypes.TagFilter{
 						{
 							Key:    aws.String(infrav1.ClusterAWSCloudProviderTagKey(clusterName)),
-							Values: aws.StringSlice([]string{string(infrav1.ResourceLifecycleOwned)}),
+							Values: []string{string(infrav1.ResourceLifecycleOwned)},
 						},
 					},
-				}, gomock.Any()).Do(func(_, y interface{}) {
-					funct := y.(func(output *rgapi.GetResourcesOutput, lastPage bool) bool)
+				}, gomock.Any()).Do(func(_, _, y interface{}) {
+					funct := y.(func(output *rgapi.GetResourcesOutput))
 					funct(&rgapi.GetResourcesOutput{
-						ResourceTagMappingList: []*rgapi.ResourceTagMapping{
+						ResourceTagMappingList: []rgapitypes.ResourceTagMapping{
 							{
 								ResourceARN: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:loadbalancer/lb-service-name"),
-								Tags: []*rgapi.Tag{{
+								Tags: []rgapitypes.Tag{{
 									Key:   aws.String(infrav1.ClusterAWSCloudProviderTagKey(clusterName)),
 									Value: aws.String(string(infrav1.ResourceLifecycleOwned)),
 								}},
 							},
 						},
-					}, true)
+					})
 				}).Return(nil)
 			},
 			elbAPIMocks: func(m *mocks.MockELBAPIMockRecorder) {
-				m.DeleteLoadBalancer(gomock.Eq(&elb.DeleteLoadBalancerInput{LoadBalancerName: aws.String("lb-service-name")})).Return(nil, nil)
+				m.DeleteLoadBalancer(gomock.Any(), &elb.DeleteLoadBalancerInput{LoadBalancerName: aws.String("lb-service-name")}).Return(nil, nil)
 			},
 			postDeleteRGAPIMocks: func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder) {
-				m.GetResourcesPages(&rgapi.GetResourcesInput{
-					ResourceTypeFilters: aws.StringSlice([]string{elbResourceType}),
-					TagFilters: []*rgapi.TagFilter{
+				m.GetResourcesPages(gomock.Any(), &rgapi.GetResourcesInput{
+					ResourceTypeFilters: []string{elbResourceType},
+					TagFilters: []rgapitypes.TagFilter{
 						{
 							Key:    aws.String(infrav1.ClusterAWSCloudProviderTagKey(clusterName)),
-							Values: aws.StringSlice([]string{string(infrav1.ResourceLifecycleOwned)}),
+							Values: []string{string(infrav1.ResourceLifecycleOwned)},
 						},
 					},
-				}, gomock.Any()).Do(func(_, y interface{}) {
-					funct := y.(func(output *rgapi.GetResourcesOutput, lastPage bool) bool)
+				}, gomock.Any()).Do(func(_, _, y interface{}) {
+					funct := y.(func(output *rgapi.GetResourcesOutput))
 					funct(&rgapi.GetResourcesOutput{
-						ResourceTagMappingList: []*rgapi.ResourceTagMapping{},
-					}, true)
+						ResourceTagMappingList: []rgapitypes.ResourceTagMapping{},
+					})
 				}).Return(nil)
 			},
 		},
 		{
 			name: "fall back to ELB API when Resource Groups Tagging API fails and then delete successfully",
 			rgAPIMocks: func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder) {
-				m.GetResourcesPages(gomock.Any(), gomock.Any()).Return(errors.Errorf("connection failure")).AnyTimes()
+				m.GetResourcesPages(gomock.Any(), gomock.Any(), gomock.Any()).Return(errors.Errorf("connection failure")).AnyTimes()
 			},
 			elbAPIMocks: func(m *mocks.MockELBAPIMockRecorder) {
-				m.DescribeLoadBalancersPages(gomock.Any(), gomock.Any()).Do(func(_, y interface{}) {
-					funct := y.(func(output *elb.DescribeLoadBalancersOutput, lastPage bool) bool)
+				m.DescribeLoadBalancersPages(gomock.Any(), gomock.Any(), gomock.Any()).Do(func(_, _, y interface{}) {
+					funct := y.(func(output *elb.DescribeLoadBalancersOutput))
 					funct(&elb.DescribeLoadBalancersOutput{
-						LoadBalancerDescriptions: []*elb.LoadBalancerDescription{
+						LoadBalancerDescriptions: []elbtypes.LoadBalancerDescription{
 							{
 								LoadBalancerName: aws.String("lb-service-name"),
 							},
@@ -3327,34 +3347,34 @@ func TestDeleteAWSCloudProviderELBs(t *testing.T) {
 								LoadBalancerName: aws.String("service-without-tags"),
 							},
 						},
-					}, true)
+					})
 				}).Return(nil)
-				m.DescribeTags(&elb.DescribeTagsInput{LoadBalancerNames: []*string{aws.String("lb-service-name"), aws.String("another-service-not-owned"), aws.String("service-without-tags")}}).Return(&elb.DescribeTagsOutput{
-					TagDescriptions: []*elb.TagDescription{
+				m.DescribeTags(gomock.Any(), &elb.DescribeTagsInput{LoadBalancerNames: []string{"lb-service-name", "another-service-not-owned", "service-without-tags"}}).Return(&elb.DescribeTagsOutput{
+					TagDescriptions: []elbtypes.TagDescription{
 						{
 							LoadBalancerName: aws.String("lb-service-name"),
-							Tags: []*elb.Tag{{
+							Tags: []elbtypes.Tag{{
 								Key:   aws.String(infrav1.ClusterAWSCloudProviderTagKey(clusterName)),
 								Value: aws.String(string(infrav1.ResourceLifecycleOwned)),
 							}},
 						},
 						{
 							LoadBalancerName: aws.String("another-service-not-owned"),
-							Tags: []*elb.Tag{{
+							Tags: []elbtypes.Tag{{
 								Key:   aws.String("some-tag-key"),
 								Value: aws.String("some-tag-value"),
 							}},
 						},
 						{
 							LoadBalancerName: aws.String("service-without-tags"),
-							Tags:             []*elb.Tag{},
+							Tags:             []elbtypes.Tag{},
 						},
 					},
 				}, nil)
-				m.DeleteLoadBalancer(gomock.Eq(&elb.DeleteLoadBalancerInput{LoadBalancerName: aws.String("lb-service-name")})).Return(nil, nil)
+				m.DeleteLoadBalancer(gomock.Any(), &elb.DeleteLoadBalancerInput{LoadBalancerName: aws.String("lb-service-name")}).Return(nil, nil)
 			},
 			postDeleteElbAPIMocks: func(m *mocks.MockELBAPIMockRecorder) {
-				m.DescribeLoadBalancersPages(gomock.Any(), gomock.Any()).Return(nil)
+				m.DescribeLoadBalancersPages(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
 			},
 		},
 	}
@@ -3409,7 +3429,7 @@ func TestDeleteAWSCloudProviderELBs(t *testing.T) {
 				ELBClient:             elbapiMock,
 			}
 
-			err = s.deleteAWSCloudProviderELBs()
+			err = s.deleteAWSCloudProviderELBs(ctx)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -3429,12 +3449,12 @@ func TestDescribeLoadbalancers(t *testing.T) {
 			name:   "Error if existing loadbalancer with same name doesn't have same scheme",
 			lbName: "bar-apiserver",
 			rgAPIMocks: func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder) {
-				m.GetResourcesPages(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+				m.GetResourcesPages(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
 			},
 			DescribeElbAPIMocks: func(m *mocks.MockELBAPIMockRecorder) {
-				m.DescribeLoadBalancers(gomock.Eq(&elb.DescribeLoadBalancersInput{
-					LoadBalancerNames: aws.StringSlice([]string{"bar-apiserver"}),
-				})).Return(&elb.DescribeLoadBalancersOutput{LoadBalancerDescriptions: []*elb.LoadBalancerDescription{{Scheme: ptr.To[string](string(infrav1.ELBSchemeInternal))}}}, nil)
+				m.DescribeLoadBalancers(gomock.Any(), &elb.DescribeLoadBalancersInput{
+					LoadBalancerNames: []string{"bar-apiserver"},
+				}).Return(&elb.DescribeLoadBalancersOutput{LoadBalancerDescriptions: []elbtypes.LoadBalancerDescription{{Scheme: ptr.To[string](string(infrav1.ELBSchemeInternal))}}}, nil)
 			},
 		},
 	}
@@ -3484,7 +3504,7 @@ func TestDescribeLoadbalancers(t *testing.T) {
 				ELBClient:             elbapiMock,
 			}
 
-			_, err = s.describeClassicELB(tc.lbName)
+			_, err = s.describeClassicELB(ctx, tc.lbName)
 			if err == nil {
 				t.Fatal(err)
 			}
@@ -3504,12 +3524,12 @@ func TestDescribeV2Loadbalancers(t *testing.T) {
 			name:   "Error if existing loadbalancer with same name doesn't have same scheme",
 			lbName: "bar-apiserver",
 			rgAPIMocks: func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder) {
-				m.GetResourcesPages(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+				m.GetResourcesPages(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
 			},
 			DescribeElbV2APIMocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.DescribeLoadBalancers(gomock.Eq(&elbv2.DescribeLoadBalancersInput{
-					Names: aws.StringSlice([]string{"bar-apiserver"}),
-				})).Return(&elbv2.DescribeLoadBalancersOutput{LoadBalancers: []*elbv2.LoadBalancer{{Scheme: ptr.To[string](string(infrav1.ELBSchemeInternal))}}}, nil)
+				m.DescribeLoadBalancers(gomock.Any(), &elbv2.DescribeLoadBalancersInput{
+					Names: []string{"bar-apiserver"},
+				}).Return(&elbv2.DescribeLoadBalancersOutput{LoadBalancers: []elbv2types.LoadBalancer{{Scheme: SchemeToSDKScheme(infrav1.ELBSchemeInternal)}}}, nil)
 			},
 		},
 	}
@@ -3560,7 +3580,7 @@ func TestDescribeV2Loadbalancers(t *testing.T) {
 				ELBV2Client:           elbV2ApiMock,
 			}
 
-			_, err = s.describeLB(tc.lbName, clusterScope.ControlPlaneLoadBalancer())
+			_, err = s.describeLB(ctx, tc.lbName, clusterScope.ControlPlaneLoadBalancer())
 			if err == nil {
 				t.Fatal(err)
 			}
diff --git a/pkg/cloud/services/gc/cleanup_test.go b/pkg/cloud/services/gc/cleanup_test.go
index 6416c51a6..48f9ff7c4 100644
--- a/pkg/cloud/services/gc/cleanup_test.go
+++ b/pkg/cloud/services/gc/cleanup_test.go
@@ -20,12 +20,13 @@ import (
 	"context"
 	"testing"
 
-	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	elb "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing"
+	elbv2 "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2"
+	rgapi "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi"
+	rgapitypes "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi/types"
 	"github.com/aws/aws-sdk-go/aws/request"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/elb"
-	"github.com/aws/aws-sdk-go/service/elbv2"
-	rgapi "github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi"
 	"github.com/golang/mock/gomock"
 	. "github.com/onsi/gomega"
 	corev1 "k8s.io/api/core/v1"
@@ -65,16 +66,16 @@ func TestReconcileDelete(t *testing.T) {
 			name:         "eks with no Service load balancers",
 			clusterScope: createManageScope(t, "", ""),
 			rgAPIMocks: func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder) {
-				m.GetResourcesWithContext(gomock.Any(), &rgapi.GetResourcesInput{
-					TagFilters: []*rgapi.TagFilter{
+				m.GetResources(gomock.Any(), &rgapi.GetResourcesInput{
+					TagFilters: []rgapitypes.TagFilter{
 						{
 							Key:    aws.String("kubernetes.io/cluster/eks-test-cluster"),
-							Values: []*string{aws.String("owned")},
+							Values: []string{"owned"},
 						},
 					},
 				}).DoAndReturn(func(awsCtx context.Context, input *rgapi.GetResourcesInput, opts ...request.Option) (*rgapi.GetResourcesOutput, error) {
 					return &rgapi.GetResourcesOutput{
-						ResourceTagMappingList: []*rgapi.ResourceTagMapping{},
+						ResourceTagMappingList: []rgapitypes.ResourceTagMapping{},
 					}, nil
 				})
 			},
@@ -87,16 +88,16 @@ func TestReconcileDelete(t *testing.T) {
 			name:         "eks with no Service load balancers and explicit opt-in",
 			clusterScope: createManageScope(t, "true", ""),
 			rgAPIMocks: func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder) {
-				m.GetResourcesWithContext(gomock.Any(), &rgapi.GetResourcesInput{
-					TagFilters: []*rgapi.TagFilter{
+				m.GetResources(gomock.Any(), &rgapi.GetResourcesInput{
+					TagFilters: []rgapitypes.TagFilter{
 						{
 							Key:    aws.String("kubernetes.io/cluster/eks-test-cluster"),
-							Values: []*string{aws.String("owned")},
+							Values: []string{"owned"},
 						},
 					},
 				}).DoAndReturn(func(awsCtx context.Context, input *rgapi.GetResourcesInput, opts ...request.Option) (*rgapi.GetResourcesOutput, error) {
 					return &rgapi.GetResourcesOutput{
-						ResourceTagMappingList: []*rgapi.ResourceTagMapping{},
+						ResourceTagMappingList: []rgapitypes.ResourceTagMapping{},
 					}, nil
 				})
 			},
@@ -109,16 +110,16 @@ func TestReconcileDelete(t *testing.T) {
 			name:         "ec2 cluster with no Service load balancers",
 			clusterScope: createUnManageScope(t, "", ""),
 			rgAPIMocks: func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder) {
-				m.GetResourcesWithContext(gomock.Any(), &rgapi.GetResourcesInput{
-					TagFilters: []*rgapi.TagFilter{
+				m.GetResources(gomock.Any(), &rgapi.GetResourcesInput{
+					TagFilters: []rgapitypes.TagFilter{
 						{
 							Key:    aws.String("kubernetes.io/cluster/cluster1"),
-							Values: []*string{aws.String("owned")},
+							Values: []string{"owned"},
 						},
 					},
 				}).DoAndReturn(func(awsCtx context.Context, input *rgapi.GetResourcesInput, opts ...request.Option) (*rgapi.GetResourcesOutput, error) {
 					return &rgapi.GetResourcesOutput{
-						ResourceTagMappingList: []*rgapi.ResourceTagMapping{},
+						ResourceTagMappingList: []rgapitypes.ResourceTagMapping{},
 					}, nil
 				})
 			},
@@ -131,19 +132,19 @@ func TestReconcileDelete(t *testing.T) {
 			name:         "eks with non-Service load balancer",
 			clusterScope: createManageScope(t, "", ""),
 			rgAPIMocks: func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder) {
-				m.GetResourcesWithContext(gomock.Any(), &rgapi.GetResourcesInput{
-					TagFilters: []*rgapi.TagFilter{
+				m.GetResources(gomock.Any(), &rgapi.GetResourcesInput{
+					TagFilters: []rgapitypes.TagFilter{
 						{
 							Key:    aws.String("kubernetes.io/cluster/eks-test-cluster"),
-							Values: []*string{aws.String("owned")},
+							Values: []string{"owned"},
 						},
 					},
 				}).DoAndReturn(func(awsCtx context.Context, input *rgapi.GetResourcesInput, opts ...request.Option) (*rgapi.GetResourcesOutput, error) {
 					return &rgapi.GetResourcesOutput{
-						ResourceTagMappingList: []*rgapi.ResourceTagMapping{
+						ResourceTagMappingList: []rgapitypes.ResourceTagMapping{
 							{
 								ResourceARN: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:loadbalancer/aec24434cd2ce4630bd14a955413ee37"),
-								Tags: []*rgapi.Tag{
+								Tags: []rgapitypes.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/eks-test-cluster"),
 										Value: aws.String("owned"),
@@ -163,19 +164,19 @@ func TestReconcileDelete(t *testing.T) {
 			name:         "ec2 cluster with non-Service load balancer",
 			clusterScope: createUnManageScope(t, "", ""),
 			rgAPIMocks: func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder) {
-				m.GetResourcesWithContext(gomock.Any(), &rgapi.GetResourcesInput{
-					TagFilters: []*rgapi.TagFilter{
+				m.GetResources(gomock.Any(), &rgapi.GetResourcesInput{
+					TagFilters: []rgapitypes.TagFilter{
 						{
 							Key:    aws.String("kubernetes.io/cluster/cluster1"),
-							Values: []*string{aws.String("owned")},
+							Values: []string{"owned"},
 						},
 					},
 				}).DoAndReturn(func(awsCtx context.Context, input *rgapi.GetResourcesInput, opts ...request.Option) (*rgapi.GetResourcesOutput, error) {
 					return &rgapi.GetResourcesOutput{
-						ResourceTagMappingList: []*rgapi.ResourceTagMapping{
+						ResourceTagMappingList: []rgapitypes.ResourceTagMapping{
 							{
 								ResourceARN: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:loadbalancer/aec24434cd2ce4630bd14a955413ee37"),
-								Tags: []*rgapi.Tag{
+								Tags: []rgapitypes.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/cluster1"),
 										Value: aws.String("owned"),
@@ -195,19 +196,19 @@ func TestReconcileDelete(t *testing.T) {
 			name:         "eks with ELB Service load balancer",
 			clusterScope: createManageScope(t, "", ""),
 			rgAPIMocks: func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder) {
-				m.GetResourcesWithContext(gomock.Any(), &rgapi.GetResourcesInput{
-					TagFilters: []*rgapi.TagFilter{
+				m.GetResources(gomock.Any(), &rgapi.GetResourcesInput{
+					TagFilters: []rgapitypes.TagFilter{
 						{
 							Key:    aws.String("kubernetes.io/cluster/eks-test-cluster"),
-							Values: []*string{aws.String("owned")},
+							Values: []string{"owned"},
 						},
 					},
 				}).DoAndReturn(func(awsCtx context.Context, input *rgapi.GetResourcesInput, opts ...request.Option) (*rgapi.GetResourcesOutput, error) {
 					return &rgapi.GetResourcesOutput{
-						ResourceTagMappingList: []*rgapi.ResourceTagMapping{
+						ResourceTagMappingList: []rgapitypes.ResourceTagMapping{
 							{
 								ResourceARN: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:loadbalancer/aec24434cd2ce4630bd14a955413ee37"),
-								Tags: []*rgapi.Tag{
+								Tags: []rgapitypes.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/eks-test-cluster"),
 										Value: aws.String("owned"),
@@ -223,7 +224,7 @@ func TestReconcileDelete(t *testing.T) {
 				})
 			},
 			elbMocks: func(m *mocks.MockELBAPIMockRecorder) {
-				m.DeleteLoadBalancerWithContext(gomock.Any(), &elb.DeleteLoadBalancerInput{
+				m.DeleteLoadBalancer(gomock.Any(), &elb.DeleteLoadBalancerInput{
 					LoadBalancerName: aws.String("aec24434cd2ce4630bd14a955413ee37"),
 				}).Return(&elb.DeleteLoadBalancerOutput{}, nil)
 			},
@@ -235,19 +236,19 @@ func TestReconcileDelete(t *testing.T) {
 			name:         "ec2 cluster with ELB Service load balancer",
 			clusterScope: createUnManageScope(t, "", ""),
 			rgAPIMocks: func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder) {
-				m.GetResourcesWithContext(gomock.Any(), &rgapi.GetResourcesInput{
-					TagFilters: []*rgapi.TagFilter{
+				m.GetResources(gomock.Any(), &rgapi.GetResourcesInput{
+					TagFilters: []rgapitypes.TagFilter{
 						{
 							Key:    aws.String("kubernetes.io/cluster/cluster1"),
-							Values: []*string{aws.String("owned")},
+							Values: []string{"owned"},
 						},
 					},
 				}).DoAndReturn(func(awsCtx context.Context, input *rgapi.GetResourcesInput, opts ...request.Option) (*rgapi.GetResourcesOutput, error) {
 					return &rgapi.GetResourcesOutput{
-						ResourceTagMappingList: []*rgapi.ResourceTagMapping{
+						ResourceTagMappingList: []rgapitypes.ResourceTagMapping{
 							{
 								ResourceARN: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:loadbalancer/aec24434cd2ce4630bd14a955413ee37"),
-								Tags: []*rgapi.Tag{
+								Tags: []rgapitypes.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/cluster1"),
 										Value: aws.String("owned"),
@@ -263,7 +264,7 @@ func TestReconcileDelete(t *testing.T) {
 				})
 			},
 			elbMocks: func(m *mocks.MockELBAPIMockRecorder) {
-				m.DeleteLoadBalancerWithContext(gomock.Any(), &elb.DeleteLoadBalancerInput{
+				m.DeleteLoadBalancer(gomock.Any(), &elb.DeleteLoadBalancerInput{
 					LoadBalancerName: aws.String("aec24434cd2ce4630bd14a955413ee37"),
 				}).Return(&elb.DeleteLoadBalancerOutput{}, nil)
 			},
@@ -275,19 +276,19 @@ func TestReconcileDelete(t *testing.T) {
 			name:         "eks with NLB Service load balancer",
 			clusterScope: createManageScope(t, "", ""),
 			rgAPIMocks: func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder) {
-				m.GetResourcesWithContext(gomock.Any(), &rgapi.GetResourcesInput{
-					TagFilters: []*rgapi.TagFilter{
+				m.GetResources(gomock.Any(), &rgapi.GetResourcesInput{
+					TagFilters: []rgapitypes.TagFilter{
 						{
 							Key:    aws.String("kubernetes.io/cluster/eks-test-cluster"),
-							Values: []*string{aws.String("owned")},
+							Values: []string{"owned"},
 						},
 					},
 				}).DoAndReturn(func(awsCtx context.Context, input *rgapi.GetResourcesInput, opts ...request.Option) (*rgapi.GetResourcesOutput, error) {
 					return &rgapi.GetResourcesOutput{
-						ResourceTagMappingList: []*rgapi.ResourceTagMapping{
+						ResourceTagMappingList: []rgapitypes.ResourceTagMapping{
 							{
 								ResourceARN: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:loadbalancer/net/aec24434cd2ce4630bd14a955413ee37"),
-								Tags: []*rgapi.Tag{
+								Tags: []rgapitypes.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/eks-test-cluster"),
 										Value: aws.String("owned"),
@@ -304,7 +305,7 @@ func TestReconcileDelete(t *testing.T) {
 			},
 			elbMocks: func(m *mocks.MockELBAPIMockRecorder) {},
 			elbv2Mocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.DeleteLoadBalancerWithContext(gomock.Any(), &elbv2.DeleteLoadBalancerInput{
+				m.DeleteLoadBalancer(gomock.Any(), &elbv2.DeleteLoadBalancerInput{
 					LoadBalancerArn: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:loadbalancer/net/aec24434cd2ce4630bd14a955413ee37"),
 				}).Return(&elbv2.DeleteLoadBalancerOutput{}, nil)
 			},
@@ -315,19 +316,19 @@ func TestReconcileDelete(t *testing.T) {
 			name:         "ec2 cluster with NLB Service load balancer",
 			clusterScope: createUnManageScope(t, "", ""),
 			rgAPIMocks: func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder) {
-				m.GetResourcesWithContext(gomock.Any(), &rgapi.GetResourcesInput{
-					TagFilters: []*rgapi.TagFilter{
+				m.GetResources(gomock.Any(), &rgapi.GetResourcesInput{
+					TagFilters: []rgapitypes.TagFilter{
 						{
 							Key:    aws.String("kubernetes.io/cluster/cluster1"),
-							Values: []*string{aws.String("owned")},
+							Values: []string{"owned"},
 						},
 					},
 				}).DoAndReturn(func(awsCtx context.Context, input *rgapi.GetResourcesInput, opts ...request.Option) (*rgapi.GetResourcesOutput, error) {
 					return &rgapi.GetResourcesOutput{
-						ResourceTagMappingList: []*rgapi.ResourceTagMapping{
+						ResourceTagMappingList: []rgapitypes.ResourceTagMapping{
 							{
 								ResourceARN: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:loadbalancer/net/aec24434cd2ce4630bd14a955413ee37"),
-								Tags: []*rgapi.Tag{
+								Tags: []rgapitypes.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/cluster1"),
 										Value: aws.String("owned"),
@@ -344,7 +345,7 @@ func TestReconcileDelete(t *testing.T) {
 			},
 			elbMocks: func(m *mocks.MockELBAPIMockRecorder) {},
 			elbv2Mocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.DeleteLoadBalancerWithContext(gomock.Any(), &elbv2.DeleteLoadBalancerInput{
+				m.DeleteLoadBalancer(gomock.Any(), &elbv2.DeleteLoadBalancerInput{
 					LoadBalancerArn: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:loadbalancer/net/aec24434cd2ce4630bd14a955413ee37"),
 				}).Return(&elbv2.DeleteLoadBalancerOutput{}, nil)
 			},
@@ -355,19 +356,19 @@ func TestReconcileDelete(t *testing.T) {
 			name:         "eks with ALB Service load balancer",
 			clusterScope: createManageScope(t, "", ""),
 			rgAPIMocks: func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder) {
-				m.GetResourcesWithContext(gomock.Any(), &rgapi.GetResourcesInput{
-					TagFilters: []*rgapi.TagFilter{
+				m.GetResources(gomock.Any(), &rgapi.GetResourcesInput{
+					TagFilters: []rgapitypes.TagFilter{
 						{
 							Key:    aws.String("kubernetes.io/cluster/eks-test-cluster"),
-							Values: []*string{aws.String("owned")},
+							Values: []string{"owned"},
 						},
 					},
 				}).DoAndReturn(func(awsCtx context.Context, input *rgapi.GetResourcesInput, opts ...request.Option) (*rgapi.GetResourcesOutput, error) {
 					return &rgapi.GetResourcesOutput{
-						ResourceTagMappingList: []*rgapi.ResourceTagMapping{
+						ResourceTagMappingList: []rgapitypes.ResourceTagMapping{
 							{
 								ResourceARN: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:loadbalancer/app/aec24434cd2ce4630bd14a955413ee37"),
-								Tags: []*rgapi.Tag{
+								Tags: []rgapitypes.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/eks-test-cluster"),
 										Value: aws.String("owned"),
@@ -384,7 +385,7 @@ func TestReconcileDelete(t *testing.T) {
 			},
 			elbMocks: func(m *mocks.MockELBAPIMockRecorder) {},
 			elbv2Mocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.DeleteLoadBalancerWithContext(gomock.Any(), &elbv2.DeleteLoadBalancerInput{
+				m.DeleteLoadBalancer(gomock.Any(), &elbv2.DeleteLoadBalancerInput{
 					LoadBalancerArn: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:loadbalancer/app/aec24434cd2ce4630bd14a955413ee37"),
 				}).Return(&elbv2.DeleteLoadBalancerOutput{}, nil)
 			},
@@ -395,19 +396,19 @@ func TestReconcileDelete(t *testing.T) {
 			name:         "ec2 cluster with ALB Service load balancer",
 			clusterScope: createUnManageScope(t, "", ""),
 			rgAPIMocks: func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder) {
-				m.GetResourcesWithContext(gomock.Any(), &rgapi.GetResourcesInput{
-					TagFilters: []*rgapi.TagFilter{
+				m.GetResources(gomock.Any(), &rgapi.GetResourcesInput{
+					TagFilters: []rgapitypes.TagFilter{
 						{
 							Key:    aws.String("kubernetes.io/cluster/cluster1"),
-							Values: []*string{aws.String("owned")},
+							Values: []string{"owned"},
 						},
 					},
 				}).DoAndReturn(func(awsCtx context.Context, input *rgapi.GetResourcesInput, opts ...request.Option) (*rgapi.GetResourcesOutput, error) {
 					return &rgapi.GetResourcesOutput{
-						ResourceTagMappingList: []*rgapi.ResourceTagMapping{
+						ResourceTagMappingList: []rgapitypes.ResourceTagMapping{
 							{
 								ResourceARN: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:loadbalancer/app/aec24434cd2ce4630bd14a955413ee37"),
-								Tags: []*rgapi.Tag{
+								Tags: []rgapitypes.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/cluster1"),
 										Value: aws.String("owned"),
@@ -424,7 +425,7 @@ func TestReconcileDelete(t *testing.T) {
 			},
 			elbMocks: func(m *mocks.MockELBAPIMockRecorder) {},
 			elbv2Mocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.DeleteLoadBalancerWithContext(gomock.Any(), &elbv2.DeleteLoadBalancerInput{
+				m.DeleteLoadBalancer(gomock.Any(), &elbv2.DeleteLoadBalancerInput{
 					LoadBalancerArn: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:loadbalancer/app/aec24434cd2ce4630bd14a955413ee37"),
 				}).Return(&elbv2.DeleteLoadBalancerOutput{}, nil)
 			},
@@ -435,19 +436,19 @@ func TestReconcileDelete(t *testing.T) {
 			name:         "eks cluster with different resource types",
 			clusterScope: createManageScope(t, "", ""),
 			rgAPIMocks: func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder) {
-				m.GetResourcesWithContext(gomock.Any(), &rgapi.GetResourcesInput{
-					TagFilters: []*rgapi.TagFilter{
+				m.GetResources(gomock.Any(), &rgapi.GetResourcesInput{
+					TagFilters: []rgapitypes.TagFilter{
 						{
 							Key:    aws.String("kubernetes.io/cluster/eks-test-cluster"),
-							Values: []*string{aws.String("owned")},
+							Values: []string{"owned"},
 						},
 					},
 				}).DoAndReturn(func(awsCtx context.Context, input *rgapi.GetResourcesInput, opts ...request.Option) (*rgapi.GetResourcesOutput, error) {
 					return &rgapi.GetResourcesOutput{
-						ResourceTagMappingList: []*rgapi.ResourceTagMapping{
+						ResourceTagMappingList: []rgapitypes.ResourceTagMapping{
 							{
 								ResourceARN: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:targetgroup/k8s-default-podinfo-2c868b281a/e979fe9bd6825433"),
-								Tags: []*rgapi.Tag{
+								Tags: []rgapitypes.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/cluster1"),
 										Value: aws.String("owned"),
@@ -460,7 +461,7 @@ func TestReconcileDelete(t *testing.T) {
 							},
 							{
 								ResourceARN: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:loadbalancer/aec24434cd2ce4630bd14a955413ee37"),
-								Tags: []*rgapi.Tag{
+								Tags: []rgapitypes.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/cluster1"),
 										Value: aws.String("owned"),
@@ -473,7 +474,7 @@ func TestReconcileDelete(t *testing.T) {
 							},
 							{
 								ResourceARN: aws.String("arn:aws:ec2:eu-west-2:1234567890:security-group/sg-123456"),
-								Tags: []*rgapi.Tag{
+								Tags: []rgapitypes.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/cluster1"),
 										Value: aws.String("owned"),
@@ -489,12 +490,12 @@ func TestReconcileDelete(t *testing.T) {
 				})
 			},
 			elbMocks: func(m *mocks.MockELBAPIMockRecorder) {
-				m.DeleteLoadBalancerWithContext(gomock.Any(), &elb.DeleteLoadBalancerInput{
+				m.DeleteLoadBalancer(gomock.Any(), &elb.DeleteLoadBalancerInput{
 					LoadBalancerName: aws.String("aec24434cd2ce4630bd14a955413ee37"),
 				}).Return(&elb.DeleteLoadBalancerOutput{}, nil)
 			},
 			elbv2Mocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.DeleteTargetGroupWithContext(gomock.Any(), &elbv2.DeleteTargetGroupInput{
+				m.DeleteTargetGroup(gomock.Any(), &elbv2.DeleteTargetGroupInput{
 					TargetGroupArn: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:targetgroup/k8s-default-podinfo-2c868b281a/e979fe9bd6825433"),
 				})
 			},
@@ -509,19 +510,19 @@ func TestReconcileDelete(t *testing.T) {
 			name:         "eks should ignore unhandled resources",
 			clusterScope: createManageScope(t, "", ""),
 			rgAPIMocks: func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder) {
-				m.GetResourcesWithContext(gomock.Any(), &rgapi.GetResourcesInput{
-					TagFilters: []*rgapi.TagFilter{
+				m.GetResources(gomock.Any(), &rgapi.GetResourcesInput{
+					TagFilters: []rgapitypes.TagFilter{
 						{
 							Key:    aws.String("kubernetes.io/cluster/eks-test-cluster"),
-							Values: []*string{aws.String("owned")},
+							Values: []string{"owned"},
 						},
 					},
 				}).DoAndReturn(func(awsCtx context.Context, input *rgapi.GetResourcesInput, opts ...request.Option) (*rgapi.GetResourcesOutput, error) {
 					return &rgapi.GetResourcesOutput{
-						ResourceTagMappingList: []*rgapi.ResourceTagMapping{
+						ResourceTagMappingList: []rgapitypes.ResourceTagMapping{
 							{
 								ResourceARN: aws.String("arn:aws:ec2:eu-west-2:217426147237:s3/somebucket"),
-								Tags: []*rgapi.Tag{
+								Tags: []rgapitypes.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/eks-test-cluster"),
 										Value: aws.String("owned"),
@@ -549,19 +550,19 @@ func TestReconcileDelete(t *testing.T) {
 			name:         "eks with security group created by EKS",
 			clusterScope: createManageScope(t, "", ""),
 			rgAPIMocks: func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder) {
-				m.GetResourcesWithContext(gomock.Any(), &rgapi.GetResourcesInput{
-					TagFilters: []*rgapi.TagFilter{
+				m.GetResources(gomock.Any(), &rgapi.GetResourcesInput{
+					TagFilters: []rgapitypes.TagFilter{
 						{
 							Key:    aws.String("kubernetes.io/cluster/eks-test-cluster"),
-							Values: []*string{aws.String("owned")},
+							Values: []string{"owned"},
 						},
 					},
 				}).DoAndReturn(func(awsCtx context.Context, input *rgapi.GetResourcesInput, opts ...request.Option) (*rgapi.GetResourcesOutput, error) {
 					return &rgapi.GetResourcesOutput{
-						ResourceTagMappingList: []*rgapi.ResourceTagMapping{
+						ResourceTagMappingList: []rgapitypes.ResourceTagMapping{
 							{
 								ResourceARN: aws.String("arn:aws:ec2:eu-west-2:1234567890:security-group/sg-123456"),
-								Tags: []*rgapi.Tag{
+								Tags: []rgapitypes.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/cluster1"),
 										Value: aws.String("owned"),
@@ -589,19 +590,19 @@ func TestReconcileDelete(t *testing.T) {
 			name:         "eks cluster with all clean-up funcs explicitly enabled",
 			clusterScope: createManageScope(t, "", "load-balancer,target-group,security-group"),
 			rgAPIMocks: func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder) {
-				m.GetResourcesWithContext(gomock.Any(), &rgapi.GetResourcesInput{
-					TagFilters: []*rgapi.TagFilter{
+				m.GetResources(gomock.Any(), &rgapi.GetResourcesInput{
+					TagFilters: []rgapitypes.TagFilter{
 						{
 							Key:    aws.String("kubernetes.io/cluster/eks-test-cluster"),
-							Values: []*string{aws.String("owned")},
+							Values: []string{"owned"},
 						},
 					},
 				}).DoAndReturn(func(awsCtx context.Context, input *rgapi.GetResourcesInput, opts ...request.Option) (*rgapi.GetResourcesOutput, error) {
 					return &rgapi.GetResourcesOutput{
-						ResourceTagMappingList: []*rgapi.ResourceTagMapping{
+						ResourceTagMappingList: []rgapitypes.ResourceTagMapping{
 							{
 								ResourceARN: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:targetgroup/k8s-default-podinfo-2c868b281a/e979fe9bd6825433"),
-								Tags: []*rgapi.Tag{
+								Tags: []rgapitypes.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/cluster1"),
 										Value: aws.String("owned"),
@@ -614,7 +615,7 @@ func TestReconcileDelete(t *testing.T) {
 							},
 							{
 								ResourceARN: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:loadbalancer/aec24434cd2ce4630bd14a955413ee37"),
-								Tags: []*rgapi.Tag{
+								Tags: []rgapitypes.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/cluster1"),
 										Value: aws.String("owned"),
@@ -627,7 +628,7 @@ func TestReconcileDelete(t *testing.T) {
 							},
 							{
 								ResourceARN: aws.String("arn:aws:ec2:eu-west-2:1234567890:security-group/sg-123456"),
-								Tags: []*rgapi.Tag{
+								Tags: []rgapitypes.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/cluster1"),
 										Value: aws.String("owned"),
@@ -643,12 +644,12 @@ func TestReconcileDelete(t *testing.T) {
 				})
 			},
 			elbMocks: func(m *mocks.MockELBAPIMockRecorder) {
-				m.DeleteLoadBalancerWithContext(gomock.Any(), &elb.DeleteLoadBalancerInput{
+				m.DeleteLoadBalancer(gomock.Any(), &elb.DeleteLoadBalancerInput{
 					LoadBalancerName: aws.String("aec24434cd2ce4630bd14a955413ee37"),
 				}).Return(&elb.DeleteLoadBalancerOutput{}, nil)
 			},
 			elbv2Mocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.DeleteTargetGroupWithContext(gomock.Any(), &elbv2.DeleteTargetGroupInput{
+				m.DeleteTargetGroup(gomock.Any(), &elbv2.DeleteTargetGroupInput{
 					TargetGroupArn: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:targetgroup/k8s-default-podinfo-2c868b281a/e979fe9bd6825433"),
 				})
 			},
@@ -663,19 +664,19 @@ func TestReconcileDelete(t *testing.T) {
 			name:         "eks cluster with skipped security groups clean-up func",
 			clusterScope: createManageScope(t, "", "load-balancer,target-group"),
 			rgAPIMocks: func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder) {
-				m.GetResourcesWithContext(gomock.Any(), &rgapi.GetResourcesInput{
-					TagFilters: []*rgapi.TagFilter{
+				m.GetResources(gomock.Any(), &rgapi.GetResourcesInput{
+					TagFilters: []rgapitypes.TagFilter{
 						{
 							Key:    aws.String("kubernetes.io/cluster/eks-test-cluster"),
-							Values: []*string{aws.String("owned")},
+							Values: []string{"owned"},
 						},
 					},
 				}).DoAndReturn(func(awsCtx context.Context, input *rgapi.GetResourcesInput, opts ...request.Option) (*rgapi.GetResourcesOutput, error) {
 					return &rgapi.GetResourcesOutput{
-						ResourceTagMappingList: []*rgapi.ResourceTagMapping{
+						ResourceTagMappingList: []rgapitypes.ResourceTagMapping{
 							{
 								ResourceARN: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:targetgroup/k8s-default-podinfo-2c868b281a/e979fe9bd6825433"),
-								Tags: []*rgapi.Tag{
+								Tags: []rgapitypes.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/cluster1"),
 										Value: aws.String("owned"),
@@ -688,7 +689,7 @@ func TestReconcileDelete(t *testing.T) {
 							},
 							{
 								ResourceARN: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:loadbalancer/aec24434cd2ce4630bd14a955413ee37"),
-								Tags: []*rgapi.Tag{
+								Tags: []rgapitypes.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/cluster1"),
 										Value: aws.String("owned"),
@@ -701,7 +702,7 @@ func TestReconcileDelete(t *testing.T) {
 							},
 							{
 								ResourceARN: aws.String("arn:aws:ec2:eu-west-2:1234567890:security-group/sg-123456"),
-								Tags: []*rgapi.Tag{
+								Tags: []rgapitypes.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/cluster1"),
 										Value: aws.String("owned"),
@@ -717,12 +718,12 @@ func TestReconcileDelete(t *testing.T) {
 				})
 			},
 			elbMocks: func(m *mocks.MockELBAPIMockRecorder) {
-				m.DeleteLoadBalancerWithContext(gomock.Any(), &elb.DeleteLoadBalancerInput{
+				m.DeleteLoadBalancer(gomock.Any(), &elb.DeleteLoadBalancerInput{
 					LoadBalancerName: aws.String("aec24434cd2ce4630bd14a955413ee37"),
 				}).Return(&elb.DeleteLoadBalancerOutput{}, nil)
 			},
 			elbv2Mocks: func(m *mocks.MockELBV2APIMockRecorder) {
-				m.DeleteTargetGroupWithContext(gomock.Any(), &elbv2.DeleteTargetGroupInput{
+				m.DeleteTargetGroup(gomock.Any(), &elbv2.DeleteTargetGroupInput{
 					TargetGroupArn: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:targetgroup/k8s-default-podinfo-2c868b281a/e979fe9bd6825433"),
 				})
 			},
@@ -733,19 +734,19 @@ func TestReconcileDelete(t *testing.T) {
 			name:         "eks cluster with skipped security and target groups clean-up funcs",
 			clusterScope: createManageScope(t, "", "load-balancer"),
 			rgAPIMocks: func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder) {
-				m.GetResourcesWithContext(gomock.Any(), &rgapi.GetResourcesInput{
-					TagFilters: []*rgapi.TagFilter{
+				m.GetResources(gomock.Any(), &rgapi.GetResourcesInput{
+					TagFilters: []rgapitypes.TagFilter{
 						{
 							Key:    aws.String("kubernetes.io/cluster/eks-test-cluster"),
-							Values: []*string{aws.String("owned")},
+							Values: []string{"owned"},
 						},
 					},
 				}).DoAndReturn(func(awsCtx context.Context, input *rgapi.GetResourcesInput, opts ...request.Option) (*rgapi.GetResourcesOutput, error) {
 					return &rgapi.GetResourcesOutput{
-						ResourceTagMappingList: []*rgapi.ResourceTagMapping{
+						ResourceTagMappingList: []rgapitypes.ResourceTagMapping{
 							{
 								ResourceARN: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:targetgroup/k8s-default-podinfo-2c868b281a/e979fe9bd6825433"),
-								Tags: []*rgapi.Tag{
+								Tags: []rgapitypes.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/cluster1"),
 										Value: aws.String("owned"),
@@ -758,7 +759,7 @@ func TestReconcileDelete(t *testing.T) {
 							},
 							{
 								ResourceARN: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:loadbalancer/aec24434cd2ce4630bd14a955413ee37"),
-								Tags: []*rgapi.Tag{
+								Tags: []rgapitypes.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/cluster1"),
 										Value: aws.String("owned"),
@@ -771,7 +772,7 @@ func TestReconcileDelete(t *testing.T) {
 							},
 							{
 								ResourceARN: aws.String("arn:aws:ec2:eu-west-2:1234567890:security-group/sg-123456"),
-								Tags: []*rgapi.Tag{
+								Tags: []rgapitypes.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/cluster1"),
 										Value: aws.String("owned"),
@@ -787,7 +788,7 @@ func TestReconcileDelete(t *testing.T) {
 				})
 			},
 			elbMocks: func(m *mocks.MockELBAPIMockRecorder) {
-				m.DeleteLoadBalancerWithContext(gomock.Any(), &elb.DeleteLoadBalancerInput{
+				m.DeleteLoadBalancer(gomock.Any(), &elb.DeleteLoadBalancerInput{
 					LoadBalancerName: aws.String("aec24434cd2ce4630bd14a955413ee37"),
 				}).Return(&elb.DeleteLoadBalancerOutput{}, nil)
 			},
diff --git a/test/e2e/shared/aws.go b/test/e2e/shared/aws.go
index 3727122f7..a385ce0db 100644
--- a/test/e2e/shared/aws.go
+++ b/test/e2e/shared/aws.go
@@ -37,6 +37,8 @@ import (
 	awscredsv2 "github.com/aws/aws-sdk-go-v2/credentials"
 	"github.com/aws/aws-sdk-go-v2/service/eks"
 	ekstypes "github.com/aws/aws-sdk-go-v2/service/eks/types"
+	elb "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing"
+	elbtypes "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing/types"
 	"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"
@@ -49,7 +51,6 @@ import (
 	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/aws/aws-sdk-go/service/ecrpublic"
 	"github.com/aws/aws-sdk-go/service/efs"
-	"github.com/aws/aws-sdk-go/service/elb"
 	"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"
@@ -296,7 +297,7 @@ func (i *AWSInfrastructure) CreateInfrastructure() AWSInfrastructure {
 // by CAPA. In an attempt to avoid dependency violations it works in the following order
 // Instances, Load Balancers, Route Tables, NAT gateway, Elastic IP, Internet Gateway,
 // Security Group Rules, Security Groups, Subnets, VPC.
-func (i *AWSInfrastructure) DeleteInfrastructure() {
+func (i *AWSInfrastructure) DeleteInfrastructure(ctx context.Context) {
 	instances, _ := ListClusterEC2Instances(i.Context, i.Spec.ClusterName)
 	for _, instance := range instances {
 		if instance.State.Code != aws.Int64(48) {
@@ -305,9 +306,9 @@ func (i *AWSInfrastructure) DeleteInfrastructure() {
 	}
 	WaitForInstanceState(i.Context, i.Spec.ClusterName, "terminated")
 
-	loadbalancers, _ := ListLoadBalancers(i.Context, i.Spec.ClusterName)
+	loadbalancers, _ := ListLoadBalancers(ctx, i.Context, i.Spec.ClusterName)
 	for _, lb := range loadbalancers {
-		By(fmt.Sprintf("Deleting orphaned load balancer: %s - %v", *lb.LoadBalancerName, DeleteLoadBalancer(i.Context, *lb.LoadBalancerName)))
+		By(fmt.Sprintf("Deleting orphaned load balancer: %s - %v", *lb.LoadBalancerName, DeleteLoadBalancer(ctx, i.Context, *lb.LoadBalancerName)))
 	}
 
 	for _, rt := range i.RouteTables {
@@ -2295,14 +2296,14 @@ func DeleteSecurityGroupRule(e2eCtx *E2EContext, sgID, sgrID, rt string) bool {
 	return false
 }
 
-func ListLoadBalancers(e2eCtx *E2EContext, clusterName string) ([]*elb.LoadBalancerDescription, error) {
-	elbSvc := elb.New(e2eCtx.AWSSession)
+func ListLoadBalancers(ctx context.Context, e2eCtx *E2EContext, clusterName string) ([]elbtypes.LoadBalancerDescription, error) {
+	elbSvc := elb.NewFromConfig(*e2eCtx.BootstrapUserAWSSessionV2)
 
 	input := &elb.DescribeLoadBalancersInput{
-		LoadBalancerNames: aws.StringSlice([]string{clusterName + "-apiserver"}),
+		LoadBalancerNames: []string{clusterName + "-apiserver"},
 	}
 
-	result, err := elbSvc.DescribeLoadBalancers(input)
+	result, err := elbSvc.DescribeLoadBalancers(ctx, input)
 	if err != nil {
 		return nil, err
 	}
@@ -2312,14 +2313,14 @@ func ListLoadBalancers(e2eCtx *E2EContext, clusterName string) ([]*elb.LoadBalan
 	return result.LoadBalancerDescriptions, nil
 }
 
-func DeleteLoadBalancer(e2eCtx *E2EContext, loadbalancerName string) bool {
-	elbSvc := elb.New(e2eCtx.AWSSession)
+func DeleteLoadBalancer(ctx context.Context, e2eCtx *E2EContext, loadbalancerName string) bool {
+	elbSvc := elb.NewFromConfig(*e2eCtx.BootstrapUserAWSSessionV2)
 
 	input := &elb.DeleteLoadBalancerInput{
 		LoadBalancerName: aws.String(loadbalancerName),
 	}
 
-	if _, err := elbSvc.DeleteLoadBalancer(input); err != nil {
+	if _, err := elbSvc.DeleteLoadBalancer(ctx, input); err != nil {
 		return false
 	}
 	return true
diff --git a/test/e2e/shared/aws_helpers.go b/test/e2e/shared/aws_helpers.go
index 89ddba99e..a338741f7 100644
--- a/test/e2e/shared/aws_helpers.go
+++ b/test/e2e/shared/aws_helpers.go
@@ -20,15 +20,16 @@ limitations under the License.
 package shared
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"strings"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/arn"
-	"github.com/aws/aws-sdk-go/aws/client"
-	"github.com/aws/aws-sdk-go/service/elb"
-	rgapi "github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/aws/arn"
+	elb "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing"
+	rgapi "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi"
+	rgapitypes "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi/types"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 
@@ -36,20 +37,20 @@ import (
 )
 
 type WaitForLoadBalancerToExistForServiceInput struct {
-	AWSSession       client.ConfigProvider
+	AWSSession       *aws.Config
 	ServiceName      string
 	ServiceNamespace string
 	ClusterName      string
 	Type             infrav1.LoadBalancerType
 }
 
-func WaitForLoadBalancerToExistForService(input WaitForLoadBalancerToExistForServiceInput, intervals ...interface{}) {
+func WaitForLoadBalancerToExistForService(ctx context.Context, input WaitForLoadBalancerToExistForServiceInput, intervals ...interface{}) {
 	By(fmt.Sprintf("Waiting for AWS load balancer of type %s to exist for service %s/%s", input.Type, input.ServiceNamespace, input.ServiceName))
 
 	Eventually(func() bool {
 		input := GetLoadBalancerARNsInput(input)
 
-		arns, err := GetLoadBalancerARNs(input)
+		arns, err := GetLoadBalancerARNs(ctx, input)
 		if err != nil {
 			fmt.Fprintf(GinkgoWriter, "Error getting loadbalancer arns: %v\n", err)
 
@@ -64,14 +65,14 @@ func WaitForLoadBalancerToExistForService(input WaitForLoadBalancerToExistForSer
 }
 
 type GetLoadBalancerARNsInput struct {
-	AWSSession       client.ConfigProvider
+	AWSSession       *aws.Config
 	ServiceName      string
 	ServiceNamespace string
 	ClusterName      string
 	Type             infrav1.LoadBalancerType
 }
 
-func GetLoadBalancerARNs(input GetLoadBalancerARNsInput) ([]string, error) {
+func GetLoadBalancerARNs(ctx context.Context, input GetLoadBalancerARNsInput) ([]string, error) {
 	By(fmt.Sprintf("Getting AWS load balancer ARNs of type %s for service %s/%s", input.Type, input.ServiceNamespace, input.ServiceName))
 
 	serviceTag := infrav1.ClusterAWSCloudProviderTagKey(input.ClusterName)
@@ -84,7 +85,7 @@ func GetLoadBalancerARNs(input GetLoadBalancerARNsInput) ([]string, error) {
 		Tags:       tags,
 	}
 
-	descOutput, err := DescribeResourcesByTags(*descInput)
+	descOutput, err := DescribeResourcesByTags(ctx, *descInput)
 	if err != nil {
 		fmt.Fprintf(GinkgoWriter, "Error querying resources by tags: %v\n", err)
 		return nil, fmt.Errorf("describing resource tags: %w", err)
@@ -122,7 +123,7 @@ func GetLoadBalancerARNs(input GetLoadBalancerARNsInput) ([]string, error) {
 }
 
 type DescribeResourcesByTagsInput struct {
-	AWSSession client.ConfigProvider
+	AWSSession *aws.Config
 	Tags       map[string][]string
 }
 
@@ -130,24 +131,24 @@ type DescribeResourcesByTagsOutput struct {
 	ARNs []string
 }
 
-func DescribeResourcesByTags(input DescribeResourcesByTagsInput) (*DescribeResourcesByTagsOutput, error) {
+func DescribeResourcesByTags(ctx context.Context, input DescribeResourcesByTagsInput) (*DescribeResourcesByTagsOutput, error) {
 	if len(input.Tags) == 0 {
 		return nil, errors.New("you must supply tags")
 	}
 
 	awsInput := rgapi.GetResourcesInput{
-		TagFilters: []*rgapi.TagFilter{},
+		TagFilters: []rgapitypes.TagFilter{},
 	}
 
 	for k, v := range input.Tags {
-		awsInput.TagFilters = append(awsInput.TagFilters, &rgapi.TagFilter{
+		awsInput.TagFilters = append(awsInput.TagFilters, rgapitypes.TagFilter{
 			Key:    aws.String(k),
-			Values: aws.StringSlice(v),
+			Values: v,
 		})
 	}
 
-	rgSvc := rgapi.New(input.AWSSession)
-	awsOutput, err := rgSvc.GetResources(&awsInput)
+	rgSvc := rgapi.NewFromConfig(*input.AWSSession)
+	awsOutput, err := rgSvc.GetResources(ctx, &awsInput)
 	if err != nil {
 		return nil, fmt.Errorf("getting resources by tags: %w", err)
 	}
@@ -163,20 +164,20 @@ func DescribeResourcesByTags(input DescribeResourcesByTagsInput) (*DescribeResou
 }
 
 type CheckClassicElbHealthCheckInput struct {
-	AWSSession       client.ConfigProvider
+	AWSSession       *aws.Config
 	LoadBalancerName string
 	ExpectedTarget   string
 }
 
-func CheckClassicElbHealthCheck(input CheckClassicElbHealthCheckInput, intervals ...interface{}) {
+func CheckClassicElbHealthCheck(ctx context.Context, input CheckClassicElbHealthCheckInput, intervals ...interface{}) {
 	Byf("Checking the health check for the classic load balancer %s", input.LoadBalancerName)
 
-	elbSvc := elb.New(input.AWSSession)
+	elbSvc := elb.NewFromConfig(*input.AWSSession)
 
 	Eventually(func() error {
-		out, err := elbSvc.DescribeLoadBalancers(&elb.DescribeLoadBalancersInput{
-			LoadBalancerNames: []*string{
-				aws.String(input.LoadBalancerName),
+		out, err := elbSvc.DescribeLoadBalancers(ctx, &elb.DescribeLoadBalancersInput{
+			LoadBalancerNames: []string{
+				input.LoadBalancerName,
 			},
 		})
 		if err != nil {
diff --git a/test/e2e/suites/managed/gc_test.go b/test/e2e/suites/managed/gc_test.go
index faf9d9951..51a34e99d 100644
--- a/test/e2e/suites/managed/gc_test.go
+++ b/test/e2e/suites/managed/gc_test.go
@@ -111,15 +111,15 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests",
 		}, e2eCtx.E2EConfig.GetIntervals("", "wait-deployment-ready")...)
 
 		ginkgo.By("Checking we have the load balancers in AWS")
-		shared.WaitForLoadBalancerToExistForService(shared.WaitForLoadBalancerToExistForServiceInput{
-			AWSSession:       e2eCtx.BootstrapUserAWSSession,
+		shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{
+			AWSSession:       e2eCtx.BootstrapUserAWSSessionV2,
 			ServiceName:      "podinfo-nlb",
 			ServiceNamespace: "default",
 			ClusterName:      cp.Spec.EKSClusterName,
 			Type:             infrav1.LoadBalancerTypeNLB,
 		}, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...)
-		shared.WaitForLoadBalancerToExistForService(shared.WaitForLoadBalancerToExistForServiceInput{
-			AWSSession:       e2eCtx.BootstrapUserAWSSession,
+		shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{
+			AWSSession:       e2eCtx.BootstrapUserAWSSessionV2,
 			ServiceName:      "podinfo-elb",
 			ServiceNamespace: "default",
 			ClusterName:      cp.Spec.EKSClusterName,
@@ -139,8 +139,8 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests",
 		}, e2eCtx.E2EConfig.GetIntervals("", "wait-delete-cluster")...)
 
 		ginkgo.By("Getting counts of service load balancers")
-		arns, err := shared.GetLoadBalancerARNs(shared.GetLoadBalancerARNsInput{
-			AWSSession:       e2eCtx.BootstrapUserAWSSession,
+		arns, err := shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{
+			AWSSession:       e2eCtx.BootstrapUserAWSSessionV2,
 			ServiceName:      "podinfo-nlb",
 			ServiceNamespace: "default",
 			ClusterName:      cp.Spec.EKSClusterName,
@@ -148,8 +148,8 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests",
 		})
 		Expect(err).NotTo(HaveOccurred())
 		Expect(arns).To(BeEmpty(), "there are %d service load balancers (nlb) still", len(arns))
-		arns, err = shared.GetLoadBalancerARNs(shared.GetLoadBalancerARNsInput{
-			AWSSession:       e2eCtx.BootstrapUserAWSSession,
+		arns, err = shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{
+			AWSSession:       e2eCtx.BootstrapUserAWSSessionV2,
 			ServiceName:      "podinfo-elb",
 			ServiceNamespace: "default",
 			ClusterName:      cp.Spec.EKSClusterName,
@@ -235,15 +235,15 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests",
 		}, e2eCtx.E2EConfig.GetIntervals("", "wait-deployment-ready")...)
 
 		ginkgo.By("Checking we have the load balancers in AWS")
-		shared.WaitForLoadBalancerToExistForService(shared.WaitForLoadBalancerToExistForServiceInput{
-			AWSSession:       e2eCtx.BootstrapUserAWSSession,
+		shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{
+			AWSSession:       e2eCtx.BootstrapUserAWSSessionV2,
 			ServiceName:      "podinfo-nlb",
 			ServiceNamespace: "default",
 			ClusterName:      cp.Spec.EKSClusterName,
 			Type:             infrav1.LoadBalancerTypeNLB,
 		}, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...)
-		shared.WaitForLoadBalancerToExistForService(shared.WaitForLoadBalancerToExistForServiceInput{
-			AWSSession:       e2eCtx.BootstrapUserAWSSession,
+		shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{
+			AWSSession:       e2eCtx.BootstrapUserAWSSessionV2,
 			ServiceName:      "podinfo-elb",
 			ServiceNamespace: "default",
 			ClusterName:      cp.Spec.EKSClusterName,
@@ -263,8 +263,8 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests",
 		}, e2eCtx.E2EConfig.GetIntervals("", "wait-delete-cluster")...)
 
 		ginkgo.By("Getting counts of service load balancers")
-		arns, err := shared.GetLoadBalancerARNs(shared.GetLoadBalancerARNsInput{
-			AWSSession:       e2eCtx.BootstrapUserAWSSession,
+		arns, err := shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{
+			AWSSession:       e2eCtx.BootstrapUserAWSSessionV2,
 			ServiceName:      "podinfo-nlb",
 			ServiceNamespace: "default",
 			ClusterName:      cp.Spec.EKSClusterName,
@@ -272,8 +272,8 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests",
 		})
 		Expect(err).NotTo(HaveOccurred())
 		Expect(arns).To(BeEmpty(), "there are %d service load balancers (nlb) still", len(arns))
-		arns, err = shared.GetLoadBalancerARNs(shared.GetLoadBalancerARNsInput{
-			AWSSession:       e2eCtx.BootstrapUserAWSSession,
+		arns, err = shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{
+			AWSSession:       e2eCtx.BootstrapUserAWSSessionV2,
 			ServiceName:      "podinfo-elb",
 			ServiceNamespace: "default",
 			ClusterName:      cp.Spec.EKSClusterName,
diff --git a/test/e2e/suites/unmanaged/gc_test.go b/test/e2e/suites/unmanaged/gc_test.go
index 9e2b78474..01d6807e9 100644
--- a/test/e2e/suites/unmanaged/gc_test.go
+++ b/test/e2e/suites/unmanaged/gc_test.go
@@ -90,15 +90,15 @@ var _ = ginkgo.Context("[unmanaged] [gc]", func() {
 		}, e2eCtx.E2EConfig.GetIntervals("", "wait-deployment-ready")...)
 
 		ginkgo.By("Checking we have the load balancers in AWS")
-		shared.WaitForLoadBalancerToExistForService(shared.WaitForLoadBalancerToExistForServiceInput{
-			AWSSession:       e2eCtx.BootstrapUserAWSSession,
+		shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{
+			AWSSession:       e2eCtx.BootstrapUserAWSSessionV2,
 			ServiceName:      "podinfo-nlb",
 			ServiceNamespace: "default",
 			ClusterName:      clusterName,
 			Type:             infrav1.LoadBalancerTypeNLB,
 		}, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...)
-		shared.WaitForLoadBalancerToExistForService(shared.WaitForLoadBalancerToExistForServiceInput{
-			AWSSession:       e2eCtx.BootstrapUserAWSSession,
+		shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{
+			AWSSession:       e2eCtx.BootstrapUserAWSSessionV2,
 			ServiceName:      "podinfo-elb",
 			ServiceNamespace: "default",
 			ClusterName:      clusterName,
@@ -118,8 +118,8 @@ var _ = ginkgo.Context("[unmanaged] [gc]", func() {
 		}, e2eCtx.E2EConfig.GetIntervals("", "wait-delete-cluster")...)
 
 		ginkgo.By("Getting counts of service load balancers")
-		arns, err := shared.GetLoadBalancerARNs(shared.GetLoadBalancerARNsInput{
-			AWSSession:       e2eCtx.BootstrapUserAWSSession,
+		arns, err := shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{
+			AWSSession:       e2eCtx.BootstrapUserAWSSessionV2,
 			ServiceName:      "podinfo-nlb",
 			ServiceNamespace: "default",
 			ClusterName:      clusterName,
@@ -127,8 +127,8 @@ var _ = ginkgo.Context("[unmanaged] [gc]", func() {
 		})
 		Expect(err).NotTo(HaveOccurred())
 		Expect(arns).To(BeEmpty(), "there are %d service load balancers (nlb) still", len(arns))
-		arns, err = shared.GetLoadBalancerARNs(shared.GetLoadBalancerARNsInput{
-			AWSSession:       e2eCtx.BootstrapUserAWSSession,
+		arns, err = shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{
+			AWSSession:       e2eCtx.BootstrapUserAWSSessionV2,
 			ServiceName:      "podinfo-elb",
 			ServiceNamespace: "default",
 			ClusterName:      clusterName,
@@ -196,15 +196,15 @@ var _ = ginkgo.Context("[unmanaged] [gc]", func() {
 		}, e2eCtx.E2EConfig.GetIntervals("", "wait-deployment-ready")...)
 
 		ginkgo.By("Checking we have the load balancers in AWS")
-		shared.WaitForLoadBalancerToExistForService(shared.WaitForLoadBalancerToExistForServiceInput{
-			AWSSession:       e2eCtx.BootstrapUserAWSSession,
+		shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{
+			AWSSession:       e2eCtx.BootstrapUserAWSSessionV2,
 			ServiceName:      "podinfo-nlb",
 			ServiceNamespace: "default",
 			ClusterName:      clusterName,
 			Type:             infrav1.LoadBalancerTypeNLB,
 		}, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...)
-		shared.WaitForLoadBalancerToExistForService(shared.WaitForLoadBalancerToExistForServiceInput{
-			AWSSession:       e2eCtx.BootstrapUserAWSSession,
+		shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{
+			AWSSession:       e2eCtx.BootstrapUserAWSSessionV2,
 			ServiceName:      "podinfo-elb",
 			ServiceNamespace: "default",
 			ClusterName:      clusterName,
@@ -224,8 +224,8 @@ var _ = ginkgo.Context("[unmanaged] [gc]", func() {
 		}, e2eCtx.E2EConfig.GetIntervals("", "wait-delete-cluster")...)
 
 		ginkgo.By("Getting counts of service load balancers")
-		arns, err := shared.GetLoadBalancerARNs(shared.GetLoadBalancerARNsInput{
-			AWSSession:       e2eCtx.BootstrapUserAWSSession,
+		arns, err := shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{
+			AWSSession:       e2eCtx.BootstrapUserAWSSessionV2,
 			ServiceName:      "podinfo-nlb",
 			ServiceNamespace: "default",
 			ClusterName:      clusterName,
@@ -233,8 +233,8 @@ var _ = ginkgo.Context("[unmanaged] [gc]", func() {
 		})
 		Expect(err).NotTo(HaveOccurred())
 		Expect(arns).To(BeEmpty(), "there are %d service load balancers (nlb) still", len(arns))
-		arns, err = shared.GetLoadBalancerARNs(shared.GetLoadBalancerARNsInput{
-			AWSSession:       e2eCtx.BootstrapUserAWSSession,
+		arns, err = shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{
+			AWSSession:       e2eCtx.BootstrapUserAWSSessionV2,
 			ServiceName:      "podinfo-elb",
 			ServiceNamespace: "default",
 			ClusterName:      clusterName,
diff --git a/test/e2e/suites/unmanaged/unmanaged_classic_elb_upgrade_test.go b/test/e2e/suites/unmanaged/unmanaged_classic_elb_upgrade_test.go
index 4d3c6e3f5..4fba43f45 100644
--- a/test/e2e/suites/unmanaged/unmanaged_classic_elb_upgrade_test.go
+++ b/test/e2e/suites/unmanaged/unmanaged_classic_elb_upgrade_test.go
@@ -190,8 +190,8 @@ var _ = ginkgo.Context("[unmanaged] [upgrade]", func() {
 			awsCluster, err := GetAWSClusterByName(ctx, managementClusterProxy, workloadClusterNamespace, workloadClusterName)
 			Expect(err).NotTo(HaveOccurred(), "failed to get the AWS cluster")
 
-			shared.CheckClassicElbHealthCheck(shared.CheckClassicElbHealthCheckInput{
-				AWSSession:       e2eCtx.BootstrapUserAWSSession,
+			shared.CheckClassicElbHealthCheck(ctx, shared.CheckClassicElbHealthCheckInput{
+				AWSSession:       e2eCtx.BootstrapUserAWSSessionV2,
 				LoadBalancerName: awsCluster.Status.Network.APIServerELB.Name,
 				ExpectedTarget:   "SSL:6443",
 			}, e2eCtx.E2EConfig.GetIntervals(specName, "wait-classic-elb-health-check-short")...)
@@ -209,8 +209,8 @@ var _ = ginkgo.Context("[unmanaged] [upgrade]", func() {
 
 			ginkgo.By("Management cluster is upgraded to main version")
 
-			shared.CheckClassicElbHealthCheck(shared.CheckClassicElbHealthCheckInput{
-				AWSSession:       e2eCtx.BootstrapUserAWSSession,
+			shared.CheckClassicElbHealthCheck(ctx, shared.CheckClassicElbHealthCheckInput{
+				AWSSession:       e2eCtx.BootstrapUserAWSSessionV2,
 				LoadBalancerName: awsCluster.Status.Network.APIServerELB.Name,
 				ExpectedTarget:   "TCP:6443",
 			}, e2eCtx.E2EConfig.GetIntervals(specName, "wait-classic-elb-health-check-long")...)
diff --git a/test/e2e/suites/unmanaged/unmanaged_functional_clusterclass_test.go b/test/e2e/suites/unmanaged/unmanaged_functional_clusterclass_test.go
index 23e42c8d6..36dc53021 100644
--- a/test/e2e/suites/unmanaged/unmanaged_functional_clusterclass_test.go
+++ b/test/e2e/suites/unmanaged/unmanaged_functional_clusterclass_test.go
@@ -171,7 +171,7 @@ var _ = ginkgo.Context("[unmanaged] [functional] [ClusterClass]", func() {
 			shared.DumpSpecResourcesAndCleanup(ctx, "", namespace, e2eCtx)
 			if !e2eCtx.Settings.SkipCleanup {
 				ginkgo.By("Deleting the management cluster infrastructure")
-				mgmtClusterInfra.DeleteInfrastructure()
+				mgmtClusterInfra.DeleteInfrastructure(ctx)
 			}
 		})
 
diff --git a/test/e2e/suites/unmanaged/unmanaged_functional_test.go b/test/e2e/suites/unmanaged/unmanaged_functional_test.go
index ecf29af5f..611361439 100644
--- a/test/e2e/suites/unmanaged/unmanaged_functional_test.go
+++ b/test/e2e/suites/unmanaged/unmanaged_functional_test.go
@@ -676,9 +676,9 @@ var _ = ginkgo.Context("[unmanaged] [functional]", func() {
 					shared.DeletePeering(e2eCtx, *cPeering.VpcPeeringConnectionId)
 				}
 				ginkgo.By("Deleting the workload cluster infrastructure")
-				wlClusterInfra.DeleteInfrastructure()
+				wlClusterInfra.DeleteInfrastructure(ctx)
 				ginkgo.By("Deleting the management cluster infrastructure")
-				mgmtClusterInfra.DeleteInfrastructure()
+				mgmtClusterInfra.DeleteInfrastructure(ctx)
 			}
 		})
 
diff --git a/test/helpers/matchers.go b/test/helpers/matchers.go
index 202ae22c2..1aa0d799a 100644
--- a/test/helpers/matchers.go
+++ b/test/helpers/matchers.go
@@ -21,7 +21,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/aws/aws-sdk-go/service/elbv2"
+	elbv2 "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2"
 	"github.com/golang/mock/gomock"
 )
 
diff --git a/test/mocks/aws_elb_mock.go b/test/mocks/aws_elb_mock.go
index 1f5f64369..a9563fe8a 100644
--- a/test/mocks/aws_elb_mock.go
+++ b/test/mocks/aws_elb_mock.go
@@ -15,7 +15,7 @@ limitations under the License.
 */
 
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/aws/aws-sdk-go/service/elb/elbiface (interfaces: ELBAPI)
+// Source: sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/elb (interfaces: ELBAPI)
 
 // Package mocks is a generated GoMock package.
 package mocks
@@ -24,8 +24,7 @@ import (
 	context "context"
 	reflect "reflect"
 
-	request "github.com/aws/aws-sdk-go/aws/request"
-	elb "github.com/aws/aws-sdk-go/service/elb"
+	elasticloadbalancing "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing"
 	gomock "github.com/golang/mock/gomock"
 )
 
@@ -53,1583 +52,275 @@ func (m *MockELBAPI) EXPECT() *MockELBAPIMockRecorder {
 }
 
 // AddTags mocks base method.
-func (m *MockELBAPI) AddTags(arg0 *elb.AddTagsInput) (*elb.AddTagsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AddTags", arg0)
-	ret0, _ := ret[0].(*elb.AddTagsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AddTags indicates an expected call of AddTags.
-func (mr *MockELBAPIMockRecorder) AddTags(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTags", reflect.TypeOf((*MockELBAPI)(nil).AddTags), arg0)
-}
-
-// AddTagsRequest mocks base method.
-func (m *MockELBAPI) AddTagsRequest(arg0 *elb.AddTagsInput) (*request.Request, *elb.AddTagsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AddTagsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.AddTagsOutput)
-	return ret0, ret1
-}
-
-// AddTagsRequest indicates an expected call of AddTagsRequest.
-func (mr *MockELBAPIMockRecorder) AddTagsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsRequest", reflect.TypeOf((*MockELBAPI)(nil).AddTagsRequest), arg0)
-}
-
-// AddTagsWithContext mocks base method.
-func (m *MockELBAPI) AddTagsWithContext(arg0 context.Context, arg1 *elb.AddTagsInput, arg2 ...request.Option) (*elb.AddTagsOutput, error) {
+func (m *MockELBAPI) AddTags(arg0 context.Context, arg1 *elasticloadbalancing.AddTagsInput, arg2 ...func(*elasticloadbalancing.Options)) (*elasticloadbalancing.AddTagsOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AddTagsWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.AddTagsOutput)
+	ret := m.ctrl.Call(m, "AddTags", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancing.AddTagsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AddTagsWithContext indicates an expected call of AddTagsWithContext.
-func (mr *MockELBAPIMockRecorder) AddTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// AddTags indicates an expected call of AddTags.
+func (mr *MockELBAPIMockRecorder) AddTags(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, "AddTagsWithContext", reflect.TypeOf((*MockELBAPI)(nil).AddTagsWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTags", reflect.TypeOf((*MockELBAPI)(nil).AddTags), varargs...)
 }
 
 // ApplySecurityGroupsToLoadBalancer mocks base method.
-func (m *MockELBAPI) ApplySecurityGroupsToLoadBalancer(arg0 *elb.ApplySecurityGroupsToLoadBalancerInput) (*elb.ApplySecurityGroupsToLoadBalancerOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ApplySecurityGroupsToLoadBalancer", arg0)
-	ret0, _ := ret[0].(*elb.ApplySecurityGroupsToLoadBalancerOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ApplySecurityGroupsToLoadBalancer indicates an expected call of ApplySecurityGroupsToLoadBalancer.
-func (mr *MockELBAPIMockRecorder) ApplySecurityGroupsToLoadBalancer(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySecurityGroupsToLoadBalancer", reflect.TypeOf((*MockELBAPI)(nil).ApplySecurityGroupsToLoadBalancer), arg0)
-}
-
-// ApplySecurityGroupsToLoadBalancerRequest mocks base method.
-func (m *MockELBAPI) ApplySecurityGroupsToLoadBalancerRequest(arg0 *elb.ApplySecurityGroupsToLoadBalancerInput) (*request.Request, *elb.ApplySecurityGroupsToLoadBalancerOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ApplySecurityGroupsToLoadBalancerRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.ApplySecurityGroupsToLoadBalancerOutput)
-	return ret0, ret1
-}
-
-// ApplySecurityGroupsToLoadBalancerRequest indicates an expected call of ApplySecurityGroupsToLoadBalancerRequest.
-func (mr *MockELBAPIMockRecorder) ApplySecurityGroupsToLoadBalancerRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySecurityGroupsToLoadBalancerRequest", reflect.TypeOf((*MockELBAPI)(nil).ApplySecurityGroupsToLoadBalancerRequest), arg0)
-}
-
-// ApplySecurityGroupsToLoadBalancerWithContext mocks base method.
-func (m *MockELBAPI) ApplySecurityGroupsToLoadBalancerWithContext(arg0 context.Context, arg1 *elb.ApplySecurityGroupsToLoadBalancerInput, arg2 ...request.Option) (*elb.ApplySecurityGroupsToLoadBalancerOutput, error) {
+func (m *MockELBAPI) ApplySecurityGroupsToLoadBalancer(arg0 context.Context, arg1 *elasticloadbalancing.ApplySecurityGroupsToLoadBalancerInput, arg2 ...func(*elasticloadbalancing.Options)) (*elasticloadbalancing.ApplySecurityGroupsToLoadBalancerOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "ApplySecurityGroupsToLoadBalancerWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.ApplySecurityGroupsToLoadBalancerOutput)
+	ret := m.ctrl.Call(m, "ApplySecurityGroupsToLoadBalancer", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancing.ApplySecurityGroupsToLoadBalancerOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// ApplySecurityGroupsToLoadBalancerWithContext indicates an expected call of ApplySecurityGroupsToLoadBalancerWithContext.
-func (mr *MockELBAPIMockRecorder) ApplySecurityGroupsToLoadBalancerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// ApplySecurityGroupsToLoadBalancer indicates an expected call of ApplySecurityGroupsToLoadBalancer.
+func (mr *MockELBAPIMockRecorder) ApplySecurityGroupsToLoadBalancer(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, "ApplySecurityGroupsToLoadBalancerWithContext", reflect.TypeOf((*MockELBAPI)(nil).ApplySecurityGroupsToLoadBalancerWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySecurityGroupsToLoadBalancer", reflect.TypeOf((*MockELBAPI)(nil).ApplySecurityGroupsToLoadBalancer), varargs...)
 }
 
 // AttachLoadBalancerToSubnets mocks base method.
-func (m *MockELBAPI) AttachLoadBalancerToSubnets(arg0 *elb.AttachLoadBalancerToSubnetsInput) (*elb.AttachLoadBalancerToSubnetsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AttachLoadBalancerToSubnets", arg0)
-	ret0, _ := ret[0].(*elb.AttachLoadBalancerToSubnetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AttachLoadBalancerToSubnets indicates an expected call of AttachLoadBalancerToSubnets.
-func (mr *MockELBAPIMockRecorder) AttachLoadBalancerToSubnets(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachLoadBalancerToSubnets", reflect.TypeOf((*MockELBAPI)(nil).AttachLoadBalancerToSubnets), arg0)
-}
-
-// AttachLoadBalancerToSubnetsRequest mocks base method.
-func (m *MockELBAPI) AttachLoadBalancerToSubnetsRequest(arg0 *elb.AttachLoadBalancerToSubnetsInput) (*request.Request, *elb.AttachLoadBalancerToSubnetsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AttachLoadBalancerToSubnetsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.AttachLoadBalancerToSubnetsOutput)
-	return ret0, ret1
-}
-
-// AttachLoadBalancerToSubnetsRequest indicates an expected call of AttachLoadBalancerToSubnetsRequest.
-func (mr *MockELBAPIMockRecorder) AttachLoadBalancerToSubnetsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachLoadBalancerToSubnetsRequest", reflect.TypeOf((*MockELBAPI)(nil).AttachLoadBalancerToSubnetsRequest), arg0)
-}
-
-// AttachLoadBalancerToSubnetsWithContext mocks base method.
-func (m *MockELBAPI) AttachLoadBalancerToSubnetsWithContext(arg0 context.Context, arg1 *elb.AttachLoadBalancerToSubnetsInput, arg2 ...request.Option) (*elb.AttachLoadBalancerToSubnetsOutput, error) {
+func (m *MockELBAPI) AttachLoadBalancerToSubnets(arg0 context.Context, arg1 *elasticloadbalancing.AttachLoadBalancerToSubnetsInput, arg2 ...func(*elasticloadbalancing.Options)) (*elasticloadbalancing.AttachLoadBalancerToSubnetsOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AttachLoadBalancerToSubnetsWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.AttachLoadBalancerToSubnetsOutput)
+	ret := m.ctrl.Call(m, "AttachLoadBalancerToSubnets", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancing.AttachLoadBalancerToSubnetsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AttachLoadBalancerToSubnetsWithContext indicates an expected call of AttachLoadBalancerToSubnetsWithContext.
-func (mr *MockELBAPIMockRecorder) AttachLoadBalancerToSubnetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// AttachLoadBalancerToSubnets indicates an expected call of AttachLoadBalancerToSubnets.
+func (mr *MockELBAPIMockRecorder) AttachLoadBalancerToSubnets(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, "AttachLoadBalancerToSubnetsWithContext", reflect.TypeOf((*MockELBAPI)(nil).AttachLoadBalancerToSubnetsWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachLoadBalancerToSubnets", reflect.TypeOf((*MockELBAPI)(nil).AttachLoadBalancerToSubnets), varargs...)
 }
 
 // ConfigureHealthCheck mocks base method.
-func (m *MockELBAPI) ConfigureHealthCheck(arg0 *elb.ConfigureHealthCheckInput) (*elb.ConfigureHealthCheckOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ConfigureHealthCheck", arg0)
-	ret0, _ := ret[0].(*elb.ConfigureHealthCheckOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ConfigureHealthCheck indicates an expected call of ConfigureHealthCheck.
-func (mr *MockELBAPIMockRecorder) ConfigureHealthCheck(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigureHealthCheck", reflect.TypeOf((*MockELBAPI)(nil).ConfigureHealthCheck), arg0)
-}
-
-// ConfigureHealthCheckRequest mocks base method.
-func (m *MockELBAPI) ConfigureHealthCheckRequest(arg0 *elb.ConfigureHealthCheckInput) (*request.Request, *elb.ConfigureHealthCheckOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ConfigureHealthCheckRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.ConfigureHealthCheckOutput)
-	return ret0, ret1
-}
-
-// ConfigureHealthCheckRequest indicates an expected call of ConfigureHealthCheckRequest.
-func (mr *MockELBAPIMockRecorder) ConfigureHealthCheckRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigureHealthCheckRequest", reflect.TypeOf((*MockELBAPI)(nil).ConfigureHealthCheckRequest), arg0)
-}
-
-// ConfigureHealthCheckWithContext mocks base method.
-func (m *MockELBAPI) ConfigureHealthCheckWithContext(arg0 context.Context, arg1 *elb.ConfigureHealthCheckInput, arg2 ...request.Option) (*elb.ConfigureHealthCheckOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ConfigureHealthCheckWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.ConfigureHealthCheckOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ConfigureHealthCheckWithContext indicates an expected call of ConfigureHealthCheckWithContext.
-func (mr *MockELBAPIMockRecorder) ConfigureHealthCheckWithContext(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, "ConfigureHealthCheckWithContext", reflect.TypeOf((*MockELBAPI)(nil).ConfigureHealthCheckWithContext), varargs...)
-}
-
-// CreateAppCookieStickinessPolicy mocks base method.
-func (m *MockELBAPI) CreateAppCookieStickinessPolicy(arg0 *elb.CreateAppCookieStickinessPolicyInput) (*elb.CreateAppCookieStickinessPolicyOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateAppCookieStickinessPolicy", arg0)
-	ret0, _ := ret[0].(*elb.CreateAppCookieStickinessPolicyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateAppCookieStickinessPolicy indicates an expected call of CreateAppCookieStickinessPolicy.
-func (mr *MockELBAPIMockRecorder) CreateAppCookieStickinessPolicy(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAppCookieStickinessPolicy", reflect.TypeOf((*MockELBAPI)(nil).CreateAppCookieStickinessPolicy), arg0)
-}
-
-// CreateAppCookieStickinessPolicyRequest mocks base method.
-func (m *MockELBAPI) CreateAppCookieStickinessPolicyRequest(arg0 *elb.CreateAppCookieStickinessPolicyInput) (*request.Request, *elb.CreateAppCookieStickinessPolicyOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateAppCookieStickinessPolicyRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.CreateAppCookieStickinessPolicyOutput)
-	return ret0, ret1
-}
-
-// CreateAppCookieStickinessPolicyRequest indicates an expected call of CreateAppCookieStickinessPolicyRequest.
-func (mr *MockELBAPIMockRecorder) CreateAppCookieStickinessPolicyRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAppCookieStickinessPolicyRequest", reflect.TypeOf((*MockELBAPI)(nil).CreateAppCookieStickinessPolicyRequest), arg0)
-}
-
-// CreateAppCookieStickinessPolicyWithContext mocks base method.
-func (m *MockELBAPI) CreateAppCookieStickinessPolicyWithContext(arg0 context.Context, arg1 *elb.CreateAppCookieStickinessPolicyInput, arg2 ...request.Option) (*elb.CreateAppCookieStickinessPolicyOutput, error) {
+func (m *MockELBAPI) ConfigureHealthCheck(arg0 context.Context, arg1 *elasticloadbalancing.ConfigureHealthCheckInput, arg2 ...func(*elasticloadbalancing.Options)) (*elasticloadbalancing.ConfigureHealthCheckOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "CreateAppCookieStickinessPolicyWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.CreateAppCookieStickinessPolicyOutput)
+	ret := m.ctrl.Call(m, "ConfigureHealthCheck", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancing.ConfigureHealthCheckOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// CreateAppCookieStickinessPolicyWithContext indicates an expected call of CreateAppCookieStickinessPolicyWithContext.
-func (mr *MockELBAPIMockRecorder) CreateAppCookieStickinessPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// ConfigureHealthCheck indicates an expected call of ConfigureHealthCheck.
+func (mr *MockELBAPIMockRecorder) ConfigureHealthCheck(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, "CreateAppCookieStickinessPolicyWithContext", reflect.TypeOf((*MockELBAPI)(nil).CreateAppCookieStickinessPolicyWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigureHealthCheck", reflect.TypeOf((*MockELBAPI)(nil).ConfigureHealthCheck), varargs...)
 }
 
-// CreateLBCookieStickinessPolicy mocks base method.
-func (m *MockELBAPI) CreateLBCookieStickinessPolicy(arg0 *elb.CreateLBCookieStickinessPolicyInput) (*elb.CreateLBCookieStickinessPolicyOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLBCookieStickinessPolicy", arg0)
-	ret0, _ := ret[0].(*elb.CreateLBCookieStickinessPolicyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateLBCookieStickinessPolicy indicates an expected call of CreateLBCookieStickinessPolicy.
-func (mr *MockELBAPIMockRecorder) CreateLBCookieStickinessPolicy(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLBCookieStickinessPolicy", reflect.TypeOf((*MockELBAPI)(nil).CreateLBCookieStickinessPolicy), arg0)
-}
-
-// CreateLBCookieStickinessPolicyRequest mocks base method.
-func (m *MockELBAPI) CreateLBCookieStickinessPolicyRequest(arg0 *elb.CreateLBCookieStickinessPolicyInput) (*request.Request, *elb.CreateLBCookieStickinessPolicyOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLBCookieStickinessPolicyRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.CreateLBCookieStickinessPolicyOutput)
-	return ret0, ret1
-}
-
-// CreateLBCookieStickinessPolicyRequest indicates an expected call of CreateLBCookieStickinessPolicyRequest.
-func (mr *MockELBAPIMockRecorder) CreateLBCookieStickinessPolicyRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLBCookieStickinessPolicyRequest", reflect.TypeOf((*MockELBAPI)(nil).CreateLBCookieStickinessPolicyRequest), arg0)
-}
-
-// CreateLBCookieStickinessPolicyWithContext mocks base method.
-func (m *MockELBAPI) CreateLBCookieStickinessPolicyWithContext(arg0 context.Context, arg1 *elb.CreateLBCookieStickinessPolicyInput, arg2 ...request.Option) (*elb.CreateLBCookieStickinessPolicyOutput, error) {
+// CreateLoadBalancer mocks base method.
+func (m *MockELBAPI) CreateLoadBalancer(arg0 context.Context, arg1 *elasticloadbalancing.CreateLoadBalancerInput, arg2 ...func(*elasticloadbalancing.Options)) (*elasticloadbalancing.CreateLoadBalancerOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "CreateLBCookieStickinessPolicyWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.CreateLBCookieStickinessPolicyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateLBCookieStickinessPolicyWithContext indicates an expected call of CreateLBCookieStickinessPolicyWithContext.
-func (mr *MockELBAPIMockRecorder) CreateLBCookieStickinessPolicyWithContext(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, "CreateLBCookieStickinessPolicyWithContext", reflect.TypeOf((*MockELBAPI)(nil).CreateLBCookieStickinessPolicyWithContext), varargs...)
-}
-
-// CreateLoadBalancer mocks base method.
-func (m *MockELBAPI) CreateLoadBalancer(arg0 *elb.CreateLoadBalancerInput) (*elb.CreateLoadBalancerOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLoadBalancer", arg0)
-	ret0, _ := ret[0].(*elb.CreateLoadBalancerOutput)
+	ret := m.ctrl.Call(m, "CreateLoadBalancer", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancing.CreateLoadBalancerOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // CreateLoadBalancer indicates an expected call of CreateLoadBalancer.
-func (mr *MockELBAPIMockRecorder) CreateLoadBalancer(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancer", reflect.TypeOf((*MockELBAPI)(nil).CreateLoadBalancer), arg0)
-}
-
-// CreateLoadBalancerListeners mocks base method.
-func (m *MockELBAPI) CreateLoadBalancerListeners(arg0 *elb.CreateLoadBalancerListenersInput) (*elb.CreateLoadBalancerListenersOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLoadBalancerListeners", arg0)
-	ret0, _ := ret[0].(*elb.CreateLoadBalancerListenersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateLoadBalancerListeners indicates an expected call of CreateLoadBalancerListeners.
-func (mr *MockELBAPIMockRecorder) CreateLoadBalancerListeners(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancerListeners", reflect.TypeOf((*MockELBAPI)(nil).CreateLoadBalancerListeners), arg0)
-}
-
-// CreateLoadBalancerListenersRequest mocks base method.
-func (m *MockELBAPI) CreateLoadBalancerListenersRequest(arg0 *elb.CreateLoadBalancerListenersInput) (*request.Request, *elb.CreateLoadBalancerListenersOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLoadBalancerListenersRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.CreateLoadBalancerListenersOutput)
-	return ret0, ret1
-}
-
-// CreateLoadBalancerListenersRequest indicates an expected call of CreateLoadBalancerListenersRequest.
-func (mr *MockELBAPIMockRecorder) CreateLoadBalancerListenersRequest(arg0 interface{}) *gomock.Call {
+func (mr *MockELBAPIMockRecorder) CreateLoadBalancer(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancerListenersRequest", reflect.TypeOf((*MockELBAPI)(nil).CreateLoadBalancerListenersRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancer", reflect.TypeOf((*MockELBAPI)(nil).CreateLoadBalancer), varargs...)
 }
 
-// CreateLoadBalancerListenersWithContext mocks base method.
-func (m *MockELBAPI) CreateLoadBalancerListenersWithContext(arg0 context.Context, arg1 *elb.CreateLoadBalancerListenersInput, arg2 ...request.Option) (*elb.CreateLoadBalancerListenersOutput, error) {
+// DeleteLoadBalancer mocks base method.
+func (m *MockELBAPI) DeleteLoadBalancer(arg0 context.Context, arg1 *elasticloadbalancing.DeleteLoadBalancerInput, arg2 ...func(*elasticloadbalancing.Options)) (*elasticloadbalancing.DeleteLoadBalancerOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "CreateLoadBalancerListenersWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.CreateLoadBalancerListenersOutput)
+	ret := m.ctrl.Call(m, "DeleteLoadBalancer", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancing.DeleteLoadBalancerOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// CreateLoadBalancerListenersWithContext indicates an expected call of CreateLoadBalancerListenersWithContext.
-func (mr *MockELBAPIMockRecorder) CreateLoadBalancerListenersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DeleteLoadBalancer indicates an expected call of DeleteLoadBalancer.
+func (mr *MockELBAPIMockRecorder) DeleteLoadBalancer(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, "CreateLoadBalancerListenersWithContext", reflect.TypeOf((*MockELBAPI)(nil).CreateLoadBalancerListenersWithContext), varargs...)
-}
-
-// CreateLoadBalancerPolicy mocks base method.
-func (m *MockELBAPI) CreateLoadBalancerPolicy(arg0 *elb.CreateLoadBalancerPolicyInput) (*elb.CreateLoadBalancerPolicyOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLoadBalancerPolicy", arg0)
-	ret0, _ := ret[0].(*elb.CreateLoadBalancerPolicyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateLoadBalancerPolicy indicates an expected call of CreateLoadBalancerPolicy.
-func (mr *MockELBAPIMockRecorder) CreateLoadBalancerPolicy(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancerPolicy", reflect.TypeOf((*MockELBAPI)(nil).CreateLoadBalancerPolicy), arg0)
-}
-
-// CreateLoadBalancerPolicyRequest mocks base method.
-func (m *MockELBAPI) CreateLoadBalancerPolicyRequest(arg0 *elb.CreateLoadBalancerPolicyInput) (*request.Request, *elb.CreateLoadBalancerPolicyOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLoadBalancerPolicyRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.CreateLoadBalancerPolicyOutput)
-	return ret0, ret1
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancer", reflect.TypeOf((*MockELBAPI)(nil).DeleteLoadBalancer), varargs...)
 }
 
-// CreateLoadBalancerPolicyRequest indicates an expected call of CreateLoadBalancerPolicyRequest.
-func (mr *MockELBAPIMockRecorder) CreateLoadBalancerPolicyRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancerPolicyRequest", reflect.TypeOf((*MockELBAPI)(nil).CreateLoadBalancerPolicyRequest), arg0)
-}
-
-// CreateLoadBalancerPolicyWithContext mocks base method.
-func (m *MockELBAPI) CreateLoadBalancerPolicyWithContext(arg0 context.Context, arg1 *elb.CreateLoadBalancerPolicyInput, arg2 ...request.Option) (*elb.CreateLoadBalancerPolicyOutput, error) {
+// DeregisterInstancesFromLoadBalancer mocks base method.
+func (m *MockELBAPI) DeregisterInstancesFromLoadBalancer(arg0 context.Context, arg1 *elasticloadbalancing.DeregisterInstancesFromLoadBalancerInput, arg2 ...func(*elasticloadbalancing.Options)) (*elasticloadbalancing.DeregisterInstancesFromLoadBalancerOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "CreateLoadBalancerPolicyWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.CreateLoadBalancerPolicyOutput)
+	ret := m.ctrl.Call(m, "DeregisterInstancesFromLoadBalancer", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancing.DeregisterInstancesFromLoadBalancerOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// CreateLoadBalancerPolicyWithContext indicates an expected call of CreateLoadBalancerPolicyWithContext.
-func (mr *MockELBAPIMockRecorder) CreateLoadBalancerPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DeregisterInstancesFromLoadBalancer indicates an expected call of DeregisterInstancesFromLoadBalancer.
+func (mr *MockELBAPIMockRecorder) DeregisterInstancesFromLoadBalancer(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, "CreateLoadBalancerPolicyWithContext", reflect.TypeOf((*MockELBAPI)(nil).CreateLoadBalancerPolicyWithContext), varargs...)
-}
-
-// CreateLoadBalancerRequest mocks base method.
-func (m *MockELBAPI) CreateLoadBalancerRequest(arg0 *elb.CreateLoadBalancerInput) (*request.Request, *elb.CreateLoadBalancerOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLoadBalancerRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.CreateLoadBalancerOutput)
-	return ret0, ret1
-}
-
-// CreateLoadBalancerRequest indicates an expected call of CreateLoadBalancerRequest.
-func (mr *MockELBAPIMockRecorder) CreateLoadBalancerRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancerRequest", reflect.TypeOf((*MockELBAPI)(nil).CreateLoadBalancerRequest), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterInstancesFromLoadBalancer", reflect.TypeOf((*MockELBAPI)(nil).DeregisterInstancesFromLoadBalancer), varargs...)
 }
 
-// CreateLoadBalancerWithContext mocks base method.
-func (m *MockELBAPI) CreateLoadBalancerWithContext(arg0 context.Context, arg1 *elb.CreateLoadBalancerInput, arg2 ...request.Option) (*elb.CreateLoadBalancerOutput, error) {
+// DescribeLoadBalancerAttributes mocks base method.
+func (m *MockELBAPI) DescribeLoadBalancerAttributes(arg0 context.Context, arg1 *elasticloadbalancing.DescribeLoadBalancerAttributesInput, arg2 ...func(*elasticloadbalancing.Options)) (*elasticloadbalancing.DescribeLoadBalancerAttributesOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "CreateLoadBalancerWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.CreateLoadBalancerOutput)
+	ret := m.ctrl.Call(m, "DescribeLoadBalancerAttributes", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancing.DescribeLoadBalancerAttributesOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// CreateLoadBalancerWithContext indicates an expected call of CreateLoadBalancerWithContext.
-func (mr *MockELBAPIMockRecorder) CreateLoadBalancerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DescribeLoadBalancerAttributes indicates an expected call of DescribeLoadBalancerAttributes.
+func (mr *MockELBAPIMockRecorder) DescribeLoadBalancerAttributes(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, "CreateLoadBalancerWithContext", reflect.TypeOf((*MockELBAPI)(nil).CreateLoadBalancerWithContext), varargs...)
-}
-
-// DeleteLoadBalancer mocks base method.
-func (m *MockELBAPI) DeleteLoadBalancer(arg0 *elb.DeleteLoadBalancerInput) (*elb.DeleteLoadBalancerOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLoadBalancer", arg0)
-	ret0, _ := ret[0].(*elb.DeleteLoadBalancerOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteLoadBalancer indicates an expected call of DeleteLoadBalancer.
-func (mr *MockELBAPIMockRecorder) DeleteLoadBalancer(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancer", reflect.TypeOf((*MockELBAPI)(nil).DeleteLoadBalancer), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerAttributes", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancerAttributes), varargs...)
 }
 
-// DeleteLoadBalancerListeners mocks base method.
-func (m *MockELBAPI) DeleteLoadBalancerListeners(arg0 *elb.DeleteLoadBalancerListenersInput) (*elb.DeleteLoadBalancerListenersOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLoadBalancerListeners", arg0)
-	ret0, _ := ret[0].(*elb.DeleteLoadBalancerListenersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteLoadBalancerListeners indicates an expected call of DeleteLoadBalancerListeners.
-func (mr *MockELBAPIMockRecorder) DeleteLoadBalancerListeners(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerListeners", reflect.TypeOf((*MockELBAPI)(nil).DeleteLoadBalancerListeners), arg0)
-}
-
-// DeleteLoadBalancerListenersRequest mocks base method.
-func (m *MockELBAPI) DeleteLoadBalancerListenersRequest(arg0 *elb.DeleteLoadBalancerListenersInput) (*request.Request, *elb.DeleteLoadBalancerListenersOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLoadBalancerListenersRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.DeleteLoadBalancerListenersOutput)
-	return ret0, ret1
-}
-
-// DeleteLoadBalancerListenersRequest indicates an expected call of DeleteLoadBalancerListenersRequest.
-func (mr *MockELBAPIMockRecorder) DeleteLoadBalancerListenersRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerListenersRequest", reflect.TypeOf((*MockELBAPI)(nil).DeleteLoadBalancerListenersRequest), arg0)
-}
-
-// DeleteLoadBalancerListenersWithContext mocks base method.
-func (m *MockELBAPI) DeleteLoadBalancerListenersWithContext(arg0 context.Context, arg1 *elb.DeleteLoadBalancerListenersInput, arg2 ...request.Option) (*elb.DeleteLoadBalancerListenersOutput, error) {
+// DescribeLoadBalancers mocks base method.
+func (m *MockELBAPI) DescribeLoadBalancers(arg0 context.Context, arg1 *elasticloadbalancing.DescribeLoadBalancersInput, arg2 ...func(*elasticloadbalancing.Options)) (*elasticloadbalancing.DescribeLoadBalancersOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "DeleteLoadBalancerListenersWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.DeleteLoadBalancerListenersOutput)
+	ret := m.ctrl.Call(m, "DescribeLoadBalancers", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancing.DescribeLoadBalancersOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// DeleteLoadBalancerListenersWithContext indicates an expected call of DeleteLoadBalancerListenersWithContext.
-func (mr *MockELBAPIMockRecorder) DeleteLoadBalancerListenersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DescribeLoadBalancers indicates an expected call of DescribeLoadBalancers.
+func (mr *MockELBAPIMockRecorder) DescribeLoadBalancers(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, "DeleteLoadBalancerListenersWithContext", reflect.TypeOf((*MockELBAPI)(nil).DeleteLoadBalancerListenersWithContext), varargs...)
-}
-
-// DeleteLoadBalancerPolicy mocks base method.
-func (m *MockELBAPI) DeleteLoadBalancerPolicy(arg0 *elb.DeleteLoadBalancerPolicyInput) (*elb.DeleteLoadBalancerPolicyOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLoadBalancerPolicy", arg0)
-	ret0, _ := ret[0].(*elb.DeleteLoadBalancerPolicyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteLoadBalancerPolicy indicates an expected call of DeleteLoadBalancerPolicy.
-func (mr *MockELBAPIMockRecorder) DeleteLoadBalancerPolicy(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerPolicy", reflect.TypeOf((*MockELBAPI)(nil).DeleteLoadBalancerPolicy), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancers", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancers), varargs...)
 }
 
-// DeleteLoadBalancerPolicyRequest mocks base method.
-func (m *MockELBAPI) DeleteLoadBalancerPolicyRequest(arg0 *elb.DeleteLoadBalancerPolicyInput) (*request.Request, *elb.DeleteLoadBalancerPolicyOutput) {
+// DescribeLoadBalancersPages mocks base method.
+func (m *MockELBAPI) DescribeLoadBalancersPages(arg0 context.Context, arg1 *elasticloadbalancing.DescribeLoadBalancersInput, arg2 func(*elasticloadbalancing.DescribeLoadBalancersOutput)) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLoadBalancerPolicyRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.DeleteLoadBalancerPolicyOutput)
-	return ret0, ret1
+	ret := m.ctrl.Call(m, "DescribeLoadBalancersPages", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
 }
 
-// DeleteLoadBalancerPolicyRequest indicates an expected call of DeleteLoadBalancerPolicyRequest.
-func (mr *MockELBAPIMockRecorder) DeleteLoadBalancerPolicyRequest(arg0 interface{}) *gomock.Call {
+// DescribeLoadBalancersPages indicates an expected call of DescribeLoadBalancersPages.
+func (mr *MockELBAPIMockRecorder) DescribeLoadBalancersPages(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerPolicyRequest", reflect.TypeOf((*MockELBAPI)(nil).DeleteLoadBalancerPolicyRequest), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersPages", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancersPages), arg0, arg1, arg2)
 }
 
-// DeleteLoadBalancerPolicyWithContext mocks base method.
-func (m *MockELBAPI) DeleteLoadBalancerPolicyWithContext(arg0 context.Context, arg1 *elb.DeleteLoadBalancerPolicyInput, arg2 ...request.Option) (*elb.DeleteLoadBalancerPolicyOutput, error) {
+// DescribeTags mocks base method.
+func (m *MockELBAPI) DescribeTags(arg0 context.Context, arg1 *elasticloadbalancing.DescribeTagsInput, arg2 ...func(*elasticloadbalancing.Options)) (*elasticloadbalancing.DescribeTagsOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "DeleteLoadBalancerPolicyWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.DeleteLoadBalancerPolicyOutput)
+	ret := m.ctrl.Call(m, "DescribeTags", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancing.DescribeTagsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// DeleteLoadBalancerPolicyWithContext indicates an expected call of DeleteLoadBalancerPolicyWithContext.
-func (mr *MockELBAPIMockRecorder) DeleteLoadBalancerPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DescribeTags indicates an expected call of DescribeTags.
+func (mr *MockELBAPIMockRecorder) DescribeTags(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, "DeleteLoadBalancerPolicyWithContext", reflect.TypeOf((*MockELBAPI)(nil).DeleteLoadBalancerPolicyWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTags", reflect.TypeOf((*MockELBAPI)(nil).DescribeTags), varargs...)
 }
 
-// DeleteLoadBalancerRequest mocks base method.
-func (m *MockELBAPI) DeleteLoadBalancerRequest(arg0 *elb.DeleteLoadBalancerInput) (*request.Request, *elb.DeleteLoadBalancerOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLoadBalancerRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.DeleteLoadBalancerOutput)
-	return ret0, ret1
-}
-
-// DeleteLoadBalancerRequest indicates an expected call of DeleteLoadBalancerRequest.
-func (mr *MockELBAPIMockRecorder) DeleteLoadBalancerRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerRequest", reflect.TypeOf((*MockELBAPI)(nil).DeleteLoadBalancerRequest), arg0)
-}
-
-// DeleteLoadBalancerWithContext mocks base method.
-func (m *MockELBAPI) DeleteLoadBalancerWithContext(arg0 context.Context, arg1 *elb.DeleteLoadBalancerInput, arg2 ...request.Option) (*elb.DeleteLoadBalancerOutput, error) {
+// ModifyLoadBalancerAttributes mocks base method.
+func (m *MockELBAPI) ModifyLoadBalancerAttributes(arg0 context.Context, arg1 *elasticloadbalancing.ModifyLoadBalancerAttributesInput, arg2 ...func(*elasticloadbalancing.Options)) (*elasticloadbalancing.ModifyLoadBalancerAttributesOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "DeleteLoadBalancerWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.DeleteLoadBalancerOutput)
+	ret := m.ctrl.Call(m, "ModifyLoadBalancerAttributes", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancing.ModifyLoadBalancerAttributesOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// DeleteLoadBalancerWithContext indicates an expected call of DeleteLoadBalancerWithContext.
-func (mr *MockELBAPIMockRecorder) DeleteLoadBalancerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// ModifyLoadBalancerAttributes indicates an expected call of ModifyLoadBalancerAttributes.
+func (mr *MockELBAPIMockRecorder) ModifyLoadBalancerAttributes(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, "DeleteLoadBalancerWithContext", reflect.TypeOf((*MockELBAPI)(nil).DeleteLoadBalancerWithContext), varargs...)
-}
-
-// DeregisterInstancesFromLoadBalancer mocks base method.
-func (m *MockELBAPI) DeregisterInstancesFromLoadBalancer(arg0 *elb.DeregisterInstancesFromLoadBalancerInput) (*elb.DeregisterInstancesFromLoadBalancerOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeregisterInstancesFromLoadBalancer", arg0)
-	ret0, _ := ret[0].(*elb.DeregisterInstancesFromLoadBalancerOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeregisterInstancesFromLoadBalancer indicates an expected call of DeregisterInstancesFromLoadBalancer.
-func (mr *MockELBAPIMockRecorder) DeregisterInstancesFromLoadBalancer(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterInstancesFromLoadBalancer", reflect.TypeOf((*MockELBAPI)(nil).DeregisterInstancesFromLoadBalancer), arg0)
-}
-
-// DeregisterInstancesFromLoadBalancerRequest mocks base method.
-func (m *MockELBAPI) DeregisterInstancesFromLoadBalancerRequest(arg0 *elb.DeregisterInstancesFromLoadBalancerInput) (*request.Request, *elb.DeregisterInstancesFromLoadBalancerOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeregisterInstancesFromLoadBalancerRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.DeregisterInstancesFromLoadBalancerOutput)
-	return ret0, ret1
-}
-
-// DeregisterInstancesFromLoadBalancerRequest indicates an expected call of DeregisterInstancesFromLoadBalancerRequest.
-func (mr *MockELBAPIMockRecorder) DeregisterInstancesFromLoadBalancerRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterInstancesFromLoadBalancerRequest", reflect.TypeOf((*MockELBAPI)(nil).DeregisterInstancesFromLoadBalancerRequest), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLoadBalancerAttributes", reflect.TypeOf((*MockELBAPI)(nil).ModifyLoadBalancerAttributes), varargs...)
 }
 
-// DeregisterInstancesFromLoadBalancerWithContext mocks base method.
-func (m *MockELBAPI) DeregisterInstancesFromLoadBalancerWithContext(arg0 context.Context, arg1 *elb.DeregisterInstancesFromLoadBalancerInput, arg2 ...request.Option) (*elb.DeregisterInstancesFromLoadBalancerOutput, error) {
+// RegisterInstancesWithLoadBalancer mocks base method.
+func (m *MockELBAPI) RegisterInstancesWithLoadBalancer(arg0 context.Context, arg1 *elasticloadbalancing.RegisterInstancesWithLoadBalancerInput, arg2 ...func(*elasticloadbalancing.Options)) (*elasticloadbalancing.RegisterInstancesWithLoadBalancerOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "DeregisterInstancesFromLoadBalancerWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.DeregisterInstancesFromLoadBalancerOutput)
+	ret := m.ctrl.Call(m, "RegisterInstancesWithLoadBalancer", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancing.RegisterInstancesWithLoadBalancerOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// DeregisterInstancesFromLoadBalancerWithContext indicates an expected call of DeregisterInstancesFromLoadBalancerWithContext.
-func (mr *MockELBAPIMockRecorder) DeregisterInstancesFromLoadBalancerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// RegisterInstancesWithLoadBalancer indicates an expected call of RegisterInstancesWithLoadBalancer.
+func (mr *MockELBAPIMockRecorder) RegisterInstancesWithLoadBalancer(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, "DeregisterInstancesFromLoadBalancerWithContext", reflect.TypeOf((*MockELBAPI)(nil).DeregisterInstancesFromLoadBalancerWithContext), varargs...)
-}
-
-// DescribeAccountLimits mocks base method.
-func (m *MockELBAPI) DescribeAccountLimits(arg0 *elb.DescribeAccountLimitsInput) (*elb.DescribeAccountLimitsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAccountLimits", arg0)
-	ret0, _ := ret[0].(*elb.DescribeAccountLimitsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAccountLimits indicates an expected call of DescribeAccountLimits.
-func (mr *MockELBAPIMockRecorder) DescribeAccountLimits(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimits", reflect.TypeOf((*MockELBAPI)(nil).DescribeAccountLimits), arg0)
-}
-
-// DescribeAccountLimitsRequest mocks base method.
-func (m *MockELBAPI) DescribeAccountLimitsRequest(arg0 *elb.DescribeAccountLimitsInput) (*request.Request, *elb.DescribeAccountLimitsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAccountLimitsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.DescribeAccountLimitsOutput)
-	return ret0, ret1
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInstancesWithLoadBalancer", reflect.TypeOf((*MockELBAPI)(nil).RegisterInstancesWithLoadBalancer), varargs...)
 }
 
-// DescribeAccountLimitsRequest indicates an expected call of DescribeAccountLimitsRequest.
-func (mr *MockELBAPIMockRecorder) DescribeAccountLimitsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimitsRequest", reflect.TypeOf((*MockELBAPI)(nil).DescribeAccountLimitsRequest), arg0)
-}
-
-// DescribeAccountLimitsWithContext mocks base method.
-func (m *MockELBAPI) DescribeAccountLimitsWithContext(arg0 context.Context, arg1 *elb.DescribeAccountLimitsInput, arg2 ...request.Option) (*elb.DescribeAccountLimitsOutput, error) {
+// RemoveTags mocks base method.
+func (m *MockELBAPI) RemoveTags(arg0 context.Context, arg1 *elasticloadbalancing.RemoveTagsInput, arg2 ...func(*elasticloadbalancing.Options)) (*elasticloadbalancing.RemoveTagsOutput, 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].(*elb.DescribeAccountLimitsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAccountLimitsWithContext indicates an expected call of DescribeAccountLimitsWithContext.
-func (mr *MockELBAPIMockRecorder) 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((*MockELBAPI)(nil).DescribeAccountLimitsWithContext), varargs...)
-}
-
-// DescribeInstanceHealth mocks base method.
-func (m *MockELBAPI) DescribeInstanceHealth(arg0 *elb.DescribeInstanceHealthInput) (*elb.DescribeInstanceHealthOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceHealth", arg0)
-	ret0, _ := ret[0].(*elb.DescribeInstanceHealthOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstanceHealth indicates an expected call of DescribeInstanceHealth.
-func (mr *MockELBAPIMockRecorder) DescribeInstanceHealth(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceHealth", reflect.TypeOf((*MockELBAPI)(nil).DescribeInstanceHealth), arg0)
-}
-
-// DescribeInstanceHealthRequest mocks base method.
-func (m *MockELBAPI) DescribeInstanceHealthRequest(arg0 *elb.DescribeInstanceHealthInput) (*request.Request, *elb.DescribeInstanceHealthOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceHealthRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.DescribeInstanceHealthOutput)
-	return ret0, ret1
-}
-
-// DescribeInstanceHealthRequest indicates an expected call of DescribeInstanceHealthRequest.
-func (mr *MockELBAPIMockRecorder) DescribeInstanceHealthRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceHealthRequest", reflect.TypeOf((*MockELBAPI)(nil).DescribeInstanceHealthRequest), arg0)
-}
-
-// DescribeInstanceHealthWithContext mocks base method.
-func (m *MockELBAPI) DescribeInstanceHealthWithContext(arg0 context.Context, arg1 *elb.DescribeInstanceHealthInput, arg2 ...request.Option) (*elb.DescribeInstanceHealthOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeInstanceHealthWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.DescribeInstanceHealthOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstanceHealthWithContext indicates an expected call of DescribeInstanceHealthWithContext.
-func (mr *MockELBAPIMockRecorder) DescribeInstanceHealthWithContext(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, "DescribeInstanceHealthWithContext", reflect.TypeOf((*MockELBAPI)(nil).DescribeInstanceHealthWithContext), varargs...)
-}
-
-// DescribeLoadBalancerAttributes mocks base method.
-func (m *MockELBAPI) DescribeLoadBalancerAttributes(arg0 *elb.DescribeLoadBalancerAttributesInput) (*elb.DescribeLoadBalancerAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLoadBalancerAttributes", arg0)
-	ret0, _ := ret[0].(*elb.DescribeLoadBalancerAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancerAttributes indicates an expected call of DescribeLoadBalancerAttributes.
-func (mr *MockELBAPIMockRecorder) DescribeLoadBalancerAttributes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerAttributes", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancerAttributes), arg0)
-}
-
-// DescribeLoadBalancerAttributesRequest mocks base method.
-func (m *MockELBAPI) DescribeLoadBalancerAttributesRequest(arg0 *elb.DescribeLoadBalancerAttributesInput) (*request.Request, *elb.DescribeLoadBalancerAttributesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLoadBalancerAttributesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.DescribeLoadBalancerAttributesOutput)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancerAttributesRequest indicates an expected call of DescribeLoadBalancerAttributesRequest.
-func (mr *MockELBAPIMockRecorder) DescribeLoadBalancerAttributesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerAttributesRequest", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancerAttributesRequest), arg0)
-}
-
-// DescribeLoadBalancerAttributesWithContext mocks base method.
-func (m *MockELBAPI) DescribeLoadBalancerAttributesWithContext(arg0 context.Context, arg1 *elb.DescribeLoadBalancerAttributesInput, arg2 ...request.Option) (*elb.DescribeLoadBalancerAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeLoadBalancerAttributesWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.DescribeLoadBalancerAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancerAttributesWithContext indicates an expected call of DescribeLoadBalancerAttributesWithContext.
-func (mr *MockELBAPIMockRecorder) DescribeLoadBalancerAttributesWithContext(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, "DescribeLoadBalancerAttributesWithContext", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancerAttributesWithContext), varargs...)
-}
-
-// DescribeLoadBalancerPolicies mocks base method.
-func (m *MockELBAPI) DescribeLoadBalancerPolicies(arg0 *elb.DescribeLoadBalancerPoliciesInput) (*elb.DescribeLoadBalancerPoliciesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLoadBalancerPolicies", arg0)
-	ret0, _ := ret[0].(*elb.DescribeLoadBalancerPoliciesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancerPolicies indicates an expected call of DescribeLoadBalancerPolicies.
-func (mr *MockELBAPIMockRecorder) DescribeLoadBalancerPolicies(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerPolicies", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancerPolicies), arg0)
-}
-
-// DescribeLoadBalancerPoliciesRequest mocks base method.
-func (m *MockELBAPI) DescribeLoadBalancerPoliciesRequest(arg0 *elb.DescribeLoadBalancerPoliciesInput) (*request.Request, *elb.DescribeLoadBalancerPoliciesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLoadBalancerPoliciesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.DescribeLoadBalancerPoliciesOutput)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancerPoliciesRequest indicates an expected call of DescribeLoadBalancerPoliciesRequest.
-func (mr *MockELBAPIMockRecorder) DescribeLoadBalancerPoliciesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerPoliciesRequest", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancerPoliciesRequest), arg0)
-}
-
-// DescribeLoadBalancerPoliciesWithContext mocks base method.
-func (m *MockELBAPI) DescribeLoadBalancerPoliciesWithContext(arg0 context.Context, arg1 *elb.DescribeLoadBalancerPoliciesInput, arg2 ...request.Option) (*elb.DescribeLoadBalancerPoliciesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeLoadBalancerPoliciesWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.DescribeLoadBalancerPoliciesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancerPoliciesWithContext indicates an expected call of DescribeLoadBalancerPoliciesWithContext.
-func (mr *MockELBAPIMockRecorder) DescribeLoadBalancerPoliciesWithContext(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, "DescribeLoadBalancerPoliciesWithContext", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancerPoliciesWithContext), varargs...)
-}
-
-// DescribeLoadBalancerPolicyTypes mocks base method.
-func (m *MockELBAPI) DescribeLoadBalancerPolicyTypes(arg0 *elb.DescribeLoadBalancerPolicyTypesInput) (*elb.DescribeLoadBalancerPolicyTypesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLoadBalancerPolicyTypes", arg0)
-	ret0, _ := ret[0].(*elb.DescribeLoadBalancerPolicyTypesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancerPolicyTypes indicates an expected call of DescribeLoadBalancerPolicyTypes.
-func (mr *MockELBAPIMockRecorder) DescribeLoadBalancerPolicyTypes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerPolicyTypes", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancerPolicyTypes), arg0)
-}
-
-// DescribeLoadBalancerPolicyTypesRequest mocks base method.
-func (m *MockELBAPI) DescribeLoadBalancerPolicyTypesRequest(arg0 *elb.DescribeLoadBalancerPolicyTypesInput) (*request.Request, *elb.DescribeLoadBalancerPolicyTypesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLoadBalancerPolicyTypesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.DescribeLoadBalancerPolicyTypesOutput)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancerPolicyTypesRequest indicates an expected call of DescribeLoadBalancerPolicyTypesRequest.
-func (mr *MockELBAPIMockRecorder) DescribeLoadBalancerPolicyTypesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerPolicyTypesRequest", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancerPolicyTypesRequest), arg0)
-}
-
-// DescribeLoadBalancerPolicyTypesWithContext mocks base method.
-func (m *MockELBAPI) DescribeLoadBalancerPolicyTypesWithContext(arg0 context.Context, arg1 *elb.DescribeLoadBalancerPolicyTypesInput, arg2 ...request.Option) (*elb.DescribeLoadBalancerPolicyTypesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeLoadBalancerPolicyTypesWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.DescribeLoadBalancerPolicyTypesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancerPolicyTypesWithContext indicates an expected call of DescribeLoadBalancerPolicyTypesWithContext.
-func (mr *MockELBAPIMockRecorder) DescribeLoadBalancerPolicyTypesWithContext(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, "DescribeLoadBalancerPolicyTypesWithContext", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancerPolicyTypesWithContext), varargs...)
-}
-
-// DescribeLoadBalancers mocks base method.
-func (m *MockELBAPI) DescribeLoadBalancers(arg0 *elb.DescribeLoadBalancersInput) (*elb.DescribeLoadBalancersOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLoadBalancers", arg0)
-	ret0, _ := ret[0].(*elb.DescribeLoadBalancersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancers indicates an expected call of DescribeLoadBalancers.
-func (mr *MockELBAPIMockRecorder) DescribeLoadBalancers(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancers", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancers), arg0)
-}
-
-// DescribeLoadBalancersPages mocks base method.
-func (m *MockELBAPI) DescribeLoadBalancersPages(arg0 *elb.DescribeLoadBalancersInput, arg1 func(*elb.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 *MockELBAPIMockRecorder) DescribeLoadBalancersPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersPages", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancersPages), arg0, arg1)
-}
-
-// DescribeLoadBalancersPagesWithContext mocks base method.
-func (m *MockELBAPI) DescribeLoadBalancersPagesWithContext(arg0 context.Context, arg1 *elb.DescribeLoadBalancersInput, arg2 func(*elb.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 *MockELBAPIMockRecorder) 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((*MockELBAPI)(nil).DescribeLoadBalancersPagesWithContext), varargs...)
-}
-
-// DescribeLoadBalancersRequest mocks base method.
-func (m *MockELBAPI) DescribeLoadBalancersRequest(arg0 *elb.DescribeLoadBalancersInput) (*request.Request, *elb.DescribeLoadBalancersOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLoadBalancersRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.DescribeLoadBalancersOutput)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancersRequest indicates an expected call of DescribeLoadBalancersRequest.
-func (mr *MockELBAPIMockRecorder) DescribeLoadBalancersRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersRequest", reflect.TypeOf((*MockELBAPI)(nil).DescribeLoadBalancersRequest), arg0)
-}
-
-// DescribeLoadBalancersWithContext mocks base method.
-func (m *MockELBAPI) DescribeLoadBalancersWithContext(arg0 context.Context, arg1 *elb.DescribeLoadBalancersInput, arg2 ...request.Option) (*elb.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].(*elb.DescribeLoadBalancersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancersWithContext indicates an expected call of DescribeLoadBalancersWithContext.
-func (mr *MockELBAPIMockRecorder) 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((*MockELBAPI)(nil).DescribeLoadBalancersWithContext), varargs...)
-}
-
-// DescribeTags mocks base method.
-func (m *MockELBAPI) DescribeTags(arg0 *elb.DescribeTagsInput) (*elb.DescribeTagsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTags", arg0)
-	ret0, _ := ret[0].(*elb.DescribeTagsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTags indicates an expected call of DescribeTags.
-func (mr *MockELBAPIMockRecorder) DescribeTags(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTags", reflect.TypeOf((*MockELBAPI)(nil).DescribeTags), arg0)
-}
-
-// DescribeTagsRequest mocks base method.
-func (m *MockELBAPI) DescribeTagsRequest(arg0 *elb.DescribeTagsInput) (*request.Request, *elb.DescribeTagsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTagsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.DescribeTagsOutput)
-	return ret0, ret1
-}
-
-// DescribeTagsRequest indicates an expected call of DescribeTagsRequest.
-func (mr *MockELBAPIMockRecorder) DescribeTagsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsRequest", reflect.TypeOf((*MockELBAPI)(nil).DescribeTagsRequest), arg0)
-}
-
-// DescribeTagsWithContext mocks base method.
-func (m *MockELBAPI) DescribeTagsWithContext(arg0 context.Context, arg1 *elb.DescribeTagsInput, arg2 ...request.Option) (*elb.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].(*elb.DescribeTagsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTagsWithContext indicates an expected call of DescribeTagsWithContext.
-func (mr *MockELBAPIMockRecorder) 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((*MockELBAPI)(nil).DescribeTagsWithContext), varargs...)
-}
-
-// DetachLoadBalancerFromSubnets mocks base method.
-func (m *MockELBAPI) DetachLoadBalancerFromSubnets(arg0 *elb.DetachLoadBalancerFromSubnetsInput) (*elb.DetachLoadBalancerFromSubnetsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DetachLoadBalancerFromSubnets", arg0)
-	ret0, _ := ret[0].(*elb.DetachLoadBalancerFromSubnetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DetachLoadBalancerFromSubnets indicates an expected call of DetachLoadBalancerFromSubnets.
-func (mr *MockELBAPIMockRecorder) DetachLoadBalancerFromSubnets(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachLoadBalancerFromSubnets", reflect.TypeOf((*MockELBAPI)(nil).DetachLoadBalancerFromSubnets), arg0)
-}
-
-// DetachLoadBalancerFromSubnetsRequest mocks base method.
-func (m *MockELBAPI) DetachLoadBalancerFromSubnetsRequest(arg0 *elb.DetachLoadBalancerFromSubnetsInput) (*request.Request, *elb.DetachLoadBalancerFromSubnetsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DetachLoadBalancerFromSubnetsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.DetachLoadBalancerFromSubnetsOutput)
-	return ret0, ret1
-}
-
-// DetachLoadBalancerFromSubnetsRequest indicates an expected call of DetachLoadBalancerFromSubnetsRequest.
-func (mr *MockELBAPIMockRecorder) DetachLoadBalancerFromSubnetsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachLoadBalancerFromSubnetsRequest", reflect.TypeOf((*MockELBAPI)(nil).DetachLoadBalancerFromSubnetsRequest), arg0)
-}
-
-// DetachLoadBalancerFromSubnetsWithContext mocks base method.
-func (m *MockELBAPI) DetachLoadBalancerFromSubnetsWithContext(arg0 context.Context, arg1 *elb.DetachLoadBalancerFromSubnetsInput, arg2 ...request.Option) (*elb.DetachLoadBalancerFromSubnetsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DetachLoadBalancerFromSubnetsWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.DetachLoadBalancerFromSubnetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DetachLoadBalancerFromSubnetsWithContext indicates an expected call of DetachLoadBalancerFromSubnetsWithContext.
-func (mr *MockELBAPIMockRecorder) DetachLoadBalancerFromSubnetsWithContext(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, "DetachLoadBalancerFromSubnetsWithContext", reflect.TypeOf((*MockELBAPI)(nil).DetachLoadBalancerFromSubnetsWithContext), varargs...)
-}
-
-// DisableAvailabilityZonesForLoadBalancer mocks base method.
-func (m *MockELBAPI) DisableAvailabilityZonesForLoadBalancer(arg0 *elb.DisableAvailabilityZonesForLoadBalancerInput) (*elb.DisableAvailabilityZonesForLoadBalancerOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableAvailabilityZonesForLoadBalancer", arg0)
-	ret0, _ := ret[0].(*elb.DisableAvailabilityZonesForLoadBalancerOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableAvailabilityZonesForLoadBalancer indicates an expected call of DisableAvailabilityZonesForLoadBalancer.
-func (mr *MockELBAPIMockRecorder) DisableAvailabilityZonesForLoadBalancer(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableAvailabilityZonesForLoadBalancer", reflect.TypeOf((*MockELBAPI)(nil).DisableAvailabilityZonesForLoadBalancer), arg0)
-}
-
-// DisableAvailabilityZonesForLoadBalancerRequest mocks base method.
-func (m *MockELBAPI) DisableAvailabilityZonesForLoadBalancerRequest(arg0 *elb.DisableAvailabilityZonesForLoadBalancerInput) (*request.Request, *elb.DisableAvailabilityZonesForLoadBalancerOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableAvailabilityZonesForLoadBalancerRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.DisableAvailabilityZonesForLoadBalancerOutput)
-	return ret0, ret1
-}
-
-// DisableAvailabilityZonesForLoadBalancerRequest indicates an expected call of DisableAvailabilityZonesForLoadBalancerRequest.
-func (mr *MockELBAPIMockRecorder) DisableAvailabilityZonesForLoadBalancerRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableAvailabilityZonesForLoadBalancerRequest", reflect.TypeOf((*MockELBAPI)(nil).DisableAvailabilityZonesForLoadBalancerRequest), arg0)
-}
-
-// DisableAvailabilityZonesForLoadBalancerWithContext mocks base method.
-func (m *MockELBAPI) DisableAvailabilityZonesForLoadBalancerWithContext(arg0 context.Context, arg1 *elb.DisableAvailabilityZonesForLoadBalancerInput, arg2 ...request.Option) (*elb.DisableAvailabilityZonesForLoadBalancerOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisableAvailabilityZonesForLoadBalancerWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.DisableAvailabilityZonesForLoadBalancerOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableAvailabilityZonesForLoadBalancerWithContext indicates an expected call of DisableAvailabilityZonesForLoadBalancerWithContext.
-func (mr *MockELBAPIMockRecorder) DisableAvailabilityZonesForLoadBalancerWithContext(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, "DisableAvailabilityZonesForLoadBalancerWithContext", reflect.TypeOf((*MockELBAPI)(nil).DisableAvailabilityZonesForLoadBalancerWithContext), varargs...)
-}
-
-// EnableAvailabilityZonesForLoadBalancer mocks base method.
-func (m *MockELBAPI) EnableAvailabilityZonesForLoadBalancer(arg0 *elb.EnableAvailabilityZonesForLoadBalancerInput) (*elb.EnableAvailabilityZonesForLoadBalancerOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableAvailabilityZonesForLoadBalancer", arg0)
-	ret0, _ := ret[0].(*elb.EnableAvailabilityZonesForLoadBalancerOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableAvailabilityZonesForLoadBalancer indicates an expected call of EnableAvailabilityZonesForLoadBalancer.
-func (mr *MockELBAPIMockRecorder) EnableAvailabilityZonesForLoadBalancer(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableAvailabilityZonesForLoadBalancer", reflect.TypeOf((*MockELBAPI)(nil).EnableAvailabilityZonesForLoadBalancer), arg0)
-}
-
-// EnableAvailabilityZonesForLoadBalancerRequest mocks base method.
-func (m *MockELBAPI) EnableAvailabilityZonesForLoadBalancerRequest(arg0 *elb.EnableAvailabilityZonesForLoadBalancerInput) (*request.Request, *elb.EnableAvailabilityZonesForLoadBalancerOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableAvailabilityZonesForLoadBalancerRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.EnableAvailabilityZonesForLoadBalancerOutput)
-	return ret0, ret1
-}
-
-// EnableAvailabilityZonesForLoadBalancerRequest indicates an expected call of EnableAvailabilityZonesForLoadBalancerRequest.
-func (mr *MockELBAPIMockRecorder) EnableAvailabilityZonesForLoadBalancerRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableAvailabilityZonesForLoadBalancerRequest", reflect.TypeOf((*MockELBAPI)(nil).EnableAvailabilityZonesForLoadBalancerRequest), arg0)
-}
-
-// EnableAvailabilityZonesForLoadBalancerWithContext mocks base method.
-func (m *MockELBAPI) EnableAvailabilityZonesForLoadBalancerWithContext(arg0 context.Context, arg1 *elb.EnableAvailabilityZonesForLoadBalancerInput, arg2 ...request.Option) (*elb.EnableAvailabilityZonesForLoadBalancerOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EnableAvailabilityZonesForLoadBalancerWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.EnableAvailabilityZonesForLoadBalancerOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableAvailabilityZonesForLoadBalancerWithContext indicates an expected call of EnableAvailabilityZonesForLoadBalancerWithContext.
-func (mr *MockELBAPIMockRecorder) EnableAvailabilityZonesForLoadBalancerWithContext(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, "EnableAvailabilityZonesForLoadBalancerWithContext", reflect.TypeOf((*MockELBAPI)(nil).EnableAvailabilityZonesForLoadBalancerWithContext), varargs...)
-}
-
-// ModifyLoadBalancerAttributes mocks base method.
-func (m *MockELBAPI) ModifyLoadBalancerAttributes(arg0 *elb.ModifyLoadBalancerAttributesInput) (*elb.ModifyLoadBalancerAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyLoadBalancerAttributes", arg0)
-	ret0, _ := ret[0].(*elb.ModifyLoadBalancerAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyLoadBalancerAttributes indicates an expected call of ModifyLoadBalancerAttributes.
-func (mr *MockELBAPIMockRecorder) ModifyLoadBalancerAttributes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLoadBalancerAttributes", reflect.TypeOf((*MockELBAPI)(nil).ModifyLoadBalancerAttributes), arg0)
-}
-
-// ModifyLoadBalancerAttributesRequest mocks base method.
-func (m *MockELBAPI) ModifyLoadBalancerAttributesRequest(arg0 *elb.ModifyLoadBalancerAttributesInput) (*request.Request, *elb.ModifyLoadBalancerAttributesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyLoadBalancerAttributesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.ModifyLoadBalancerAttributesOutput)
-	return ret0, ret1
-}
-
-// ModifyLoadBalancerAttributesRequest indicates an expected call of ModifyLoadBalancerAttributesRequest.
-func (mr *MockELBAPIMockRecorder) ModifyLoadBalancerAttributesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLoadBalancerAttributesRequest", reflect.TypeOf((*MockELBAPI)(nil).ModifyLoadBalancerAttributesRequest), arg0)
-}
-
-// ModifyLoadBalancerAttributesWithContext mocks base method.
-func (m *MockELBAPI) ModifyLoadBalancerAttributesWithContext(arg0 context.Context, arg1 *elb.ModifyLoadBalancerAttributesInput, arg2 ...request.Option) (*elb.ModifyLoadBalancerAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyLoadBalancerAttributesWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.ModifyLoadBalancerAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyLoadBalancerAttributesWithContext indicates an expected call of ModifyLoadBalancerAttributesWithContext.
-func (mr *MockELBAPIMockRecorder) ModifyLoadBalancerAttributesWithContext(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, "ModifyLoadBalancerAttributesWithContext", reflect.TypeOf((*MockELBAPI)(nil).ModifyLoadBalancerAttributesWithContext), varargs...)
-}
-
-// RegisterInstancesWithLoadBalancer mocks base method.
-func (m *MockELBAPI) RegisterInstancesWithLoadBalancer(arg0 *elb.RegisterInstancesWithLoadBalancerInput) (*elb.RegisterInstancesWithLoadBalancerOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RegisterInstancesWithLoadBalancer", arg0)
-	ret0, _ := ret[0].(*elb.RegisterInstancesWithLoadBalancerOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RegisterInstancesWithLoadBalancer indicates an expected call of RegisterInstancesWithLoadBalancer.
-func (mr *MockELBAPIMockRecorder) RegisterInstancesWithLoadBalancer(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInstancesWithLoadBalancer", reflect.TypeOf((*MockELBAPI)(nil).RegisterInstancesWithLoadBalancer), arg0)
-}
-
-// RegisterInstancesWithLoadBalancerRequest mocks base method.
-func (m *MockELBAPI) RegisterInstancesWithLoadBalancerRequest(arg0 *elb.RegisterInstancesWithLoadBalancerInput) (*request.Request, *elb.RegisterInstancesWithLoadBalancerOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RegisterInstancesWithLoadBalancerRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.RegisterInstancesWithLoadBalancerOutput)
-	return ret0, ret1
-}
-
-// RegisterInstancesWithLoadBalancerRequest indicates an expected call of RegisterInstancesWithLoadBalancerRequest.
-func (mr *MockELBAPIMockRecorder) RegisterInstancesWithLoadBalancerRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInstancesWithLoadBalancerRequest", reflect.TypeOf((*MockELBAPI)(nil).RegisterInstancesWithLoadBalancerRequest), arg0)
-}
-
-// RegisterInstancesWithLoadBalancerWithContext mocks base method.
-func (m *MockELBAPI) RegisterInstancesWithLoadBalancerWithContext(arg0 context.Context, arg1 *elb.RegisterInstancesWithLoadBalancerInput, arg2 ...request.Option) (*elb.RegisterInstancesWithLoadBalancerOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RegisterInstancesWithLoadBalancerWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.RegisterInstancesWithLoadBalancerOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RegisterInstancesWithLoadBalancerWithContext indicates an expected call of RegisterInstancesWithLoadBalancerWithContext.
-func (mr *MockELBAPIMockRecorder) RegisterInstancesWithLoadBalancerWithContext(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, "RegisterInstancesWithLoadBalancerWithContext", reflect.TypeOf((*MockELBAPI)(nil).RegisterInstancesWithLoadBalancerWithContext), varargs...)
-}
-
-// RemoveTags mocks base method.
-func (m *MockELBAPI) RemoveTags(arg0 *elb.RemoveTagsInput) (*elb.RemoveTagsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RemoveTags", arg0)
-	ret0, _ := ret[0].(*elb.RemoveTagsOutput)
+	ret := m.ctrl.Call(m, "RemoveTags", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancing.RemoveTagsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // RemoveTags indicates an expected call of RemoveTags.
-func (mr *MockELBAPIMockRecorder) RemoveTags(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTags", reflect.TypeOf((*MockELBAPI)(nil).RemoveTags), arg0)
-}
-
-// RemoveTagsRequest mocks base method.
-func (m *MockELBAPI) RemoveTagsRequest(arg0 *elb.RemoveTagsInput) (*request.Request, *elb.RemoveTagsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RemoveTagsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.RemoveTagsOutput)
-	return ret0, ret1
-}
-
-// RemoveTagsRequest indicates an expected call of RemoveTagsRequest.
-func (mr *MockELBAPIMockRecorder) RemoveTagsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsRequest", reflect.TypeOf((*MockELBAPI)(nil).RemoveTagsRequest), arg0)
-}
-
-// RemoveTagsWithContext mocks base method.
-func (m *MockELBAPI) RemoveTagsWithContext(arg0 context.Context, arg1 *elb.RemoveTagsInput, arg2 ...request.Option) (*elb.RemoveTagsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RemoveTagsWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.RemoveTagsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RemoveTagsWithContext indicates an expected call of RemoveTagsWithContext.
-func (mr *MockELBAPIMockRecorder) RemoveTagsWithContext(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, "RemoveTagsWithContext", reflect.TypeOf((*MockELBAPI)(nil).RemoveTagsWithContext), varargs...)
-}
-
-// SetLoadBalancerListenerSSLCertificate mocks base method.
-func (m *MockELBAPI) SetLoadBalancerListenerSSLCertificate(arg0 *elb.SetLoadBalancerListenerSSLCertificateInput) (*elb.SetLoadBalancerListenerSSLCertificateOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetLoadBalancerListenerSSLCertificate", arg0)
-	ret0, _ := ret[0].(*elb.SetLoadBalancerListenerSSLCertificateOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SetLoadBalancerListenerSSLCertificate indicates an expected call of SetLoadBalancerListenerSSLCertificate.
-func (mr *MockELBAPIMockRecorder) SetLoadBalancerListenerSSLCertificate(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoadBalancerListenerSSLCertificate", reflect.TypeOf((*MockELBAPI)(nil).SetLoadBalancerListenerSSLCertificate), arg0)
-}
-
-// SetLoadBalancerListenerSSLCertificateRequest mocks base method.
-func (m *MockELBAPI) SetLoadBalancerListenerSSLCertificateRequest(arg0 *elb.SetLoadBalancerListenerSSLCertificateInput) (*request.Request, *elb.SetLoadBalancerListenerSSLCertificateOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetLoadBalancerListenerSSLCertificateRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.SetLoadBalancerListenerSSLCertificateOutput)
-	return ret0, ret1
-}
-
-// SetLoadBalancerListenerSSLCertificateRequest indicates an expected call of SetLoadBalancerListenerSSLCertificateRequest.
-func (mr *MockELBAPIMockRecorder) SetLoadBalancerListenerSSLCertificateRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoadBalancerListenerSSLCertificateRequest", reflect.TypeOf((*MockELBAPI)(nil).SetLoadBalancerListenerSSLCertificateRequest), arg0)
-}
-
-// SetLoadBalancerListenerSSLCertificateWithContext mocks base method.
-func (m *MockELBAPI) SetLoadBalancerListenerSSLCertificateWithContext(arg0 context.Context, arg1 *elb.SetLoadBalancerListenerSSLCertificateInput, arg2 ...request.Option) (*elb.SetLoadBalancerListenerSSLCertificateOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SetLoadBalancerListenerSSLCertificateWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.SetLoadBalancerListenerSSLCertificateOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SetLoadBalancerListenerSSLCertificateWithContext indicates an expected call of SetLoadBalancerListenerSSLCertificateWithContext.
-func (mr *MockELBAPIMockRecorder) SetLoadBalancerListenerSSLCertificateWithContext(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, "SetLoadBalancerListenerSSLCertificateWithContext", reflect.TypeOf((*MockELBAPI)(nil).SetLoadBalancerListenerSSLCertificateWithContext), varargs...)
-}
-
-// SetLoadBalancerPoliciesForBackendServer mocks base method.
-func (m *MockELBAPI) SetLoadBalancerPoliciesForBackendServer(arg0 *elb.SetLoadBalancerPoliciesForBackendServerInput) (*elb.SetLoadBalancerPoliciesForBackendServerOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetLoadBalancerPoliciesForBackendServer", arg0)
-	ret0, _ := ret[0].(*elb.SetLoadBalancerPoliciesForBackendServerOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SetLoadBalancerPoliciesForBackendServer indicates an expected call of SetLoadBalancerPoliciesForBackendServer.
-func (mr *MockELBAPIMockRecorder) SetLoadBalancerPoliciesForBackendServer(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoadBalancerPoliciesForBackendServer", reflect.TypeOf((*MockELBAPI)(nil).SetLoadBalancerPoliciesForBackendServer), arg0)
-}
-
-// SetLoadBalancerPoliciesForBackendServerRequest mocks base method.
-func (m *MockELBAPI) SetLoadBalancerPoliciesForBackendServerRequest(arg0 *elb.SetLoadBalancerPoliciesForBackendServerInput) (*request.Request, *elb.SetLoadBalancerPoliciesForBackendServerOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetLoadBalancerPoliciesForBackendServerRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.SetLoadBalancerPoliciesForBackendServerOutput)
-	return ret0, ret1
-}
-
-// SetLoadBalancerPoliciesForBackendServerRequest indicates an expected call of SetLoadBalancerPoliciesForBackendServerRequest.
-func (mr *MockELBAPIMockRecorder) SetLoadBalancerPoliciesForBackendServerRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoadBalancerPoliciesForBackendServerRequest", reflect.TypeOf((*MockELBAPI)(nil).SetLoadBalancerPoliciesForBackendServerRequest), arg0)
-}
-
-// SetLoadBalancerPoliciesForBackendServerWithContext mocks base method.
-func (m *MockELBAPI) SetLoadBalancerPoliciesForBackendServerWithContext(arg0 context.Context, arg1 *elb.SetLoadBalancerPoliciesForBackendServerInput, arg2 ...request.Option) (*elb.SetLoadBalancerPoliciesForBackendServerOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SetLoadBalancerPoliciesForBackendServerWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.SetLoadBalancerPoliciesForBackendServerOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SetLoadBalancerPoliciesForBackendServerWithContext indicates an expected call of SetLoadBalancerPoliciesForBackendServerWithContext.
-func (mr *MockELBAPIMockRecorder) SetLoadBalancerPoliciesForBackendServerWithContext(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, "SetLoadBalancerPoliciesForBackendServerWithContext", reflect.TypeOf((*MockELBAPI)(nil).SetLoadBalancerPoliciesForBackendServerWithContext), varargs...)
-}
-
-// SetLoadBalancerPoliciesOfListener mocks base method.
-func (m *MockELBAPI) SetLoadBalancerPoliciesOfListener(arg0 *elb.SetLoadBalancerPoliciesOfListenerInput) (*elb.SetLoadBalancerPoliciesOfListenerOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetLoadBalancerPoliciesOfListener", arg0)
-	ret0, _ := ret[0].(*elb.SetLoadBalancerPoliciesOfListenerOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SetLoadBalancerPoliciesOfListener indicates an expected call of SetLoadBalancerPoliciesOfListener.
-func (mr *MockELBAPIMockRecorder) SetLoadBalancerPoliciesOfListener(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoadBalancerPoliciesOfListener", reflect.TypeOf((*MockELBAPI)(nil).SetLoadBalancerPoliciesOfListener), arg0)
-}
-
-// SetLoadBalancerPoliciesOfListenerRequest mocks base method.
-func (m *MockELBAPI) SetLoadBalancerPoliciesOfListenerRequest(arg0 *elb.SetLoadBalancerPoliciesOfListenerInput) (*request.Request, *elb.SetLoadBalancerPoliciesOfListenerOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetLoadBalancerPoliciesOfListenerRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elb.SetLoadBalancerPoliciesOfListenerOutput)
-	return ret0, ret1
-}
-
-// SetLoadBalancerPoliciesOfListenerRequest indicates an expected call of SetLoadBalancerPoliciesOfListenerRequest.
-func (mr *MockELBAPIMockRecorder) SetLoadBalancerPoliciesOfListenerRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoadBalancerPoliciesOfListenerRequest", reflect.TypeOf((*MockELBAPI)(nil).SetLoadBalancerPoliciesOfListenerRequest), arg0)
-}
-
-// SetLoadBalancerPoliciesOfListenerWithContext mocks base method.
-func (m *MockELBAPI) SetLoadBalancerPoliciesOfListenerWithContext(arg0 context.Context, arg1 *elb.SetLoadBalancerPoliciesOfListenerInput, arg2 ...request.Option) (*elb.SetLoadBalancerPoliciesOfListenerOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SetLoadBalancerPoliciesOfListenerWithContext", varargs...)
-	ret0, _ := ret[0].(*elb.SetLoadBalancerPoliciesOfListenerOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SetLoadBalancerPoliciesOfListenerWithContext indicates an expected call of SetLoadBalancerPoliciesOfListenerWithContext.
-func (mr *MockELBAPIMockRecorder) SetLoadBalancerPoliciesOfListenerWithContext(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, "SetLoadBalancerPoliciesOfListenerWithContext", reflect.TypeOf((*MockELBAPI)(nil).SetLoadBalancerPoliciesOfListenerWithContext), varargs...)
-}
-
-// WaitUntilAnyInstanceInService mocks base method.
-func (m *MockELBAPI) WaitUntilAnyInstanceInService(arg0 *elb.DescribeInstanceHealthInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilAnyInstanceInService", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilAnyInstanceInService indicates an expected call of WaitUntilAnyInstanceInService.
-func (mr *MockELBAPIMockRecorder) WaitUntilAnyInstanceInService(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilAnyInstanceInService", reflect.TypeOf((*MockELBAPI)(nil).WaitUntilAnyInstanceInService), arg0)
-}
-
-// WaitUntilAnyInstanceInServiceWithContext mocks base method.
-func (m *MockELBAPI) WaitUntilAnyInstanceInServiceWithContext(arg0 context.Context, arg1 *elb.DescribeInstanceHealthInput, 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, "WaitUntilAnyInstanceInServiceWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilAnyInstanceInServiceWithContext indicates an expected call of WaitUntilAnyInstanceInServiceWithContext.
-func (mr *MockELBAPIMockRecorder) WaitUntilAnyInstanceInServiceWithContext(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, "WaitUntilAnyInstanceInServiceWithContext", reflect.TypeOf((*MockELBAPI)(nil).WaitUntilAnyInstanceInServiceWithContext), varargs...)
-}
-
-// WaitUntilInstanceDeregistered mocks base method.
-func (m *MockELBAPI) WaitUntilInstanceDeregistered(arg0 *elb.DescribeInstanceHealthInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilInstanceDeregistered", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilInstanceDeregistered indicates an expected call of WaitUntilInstanceDeregistered.
-func (mr *MockELBAPIMockRecorder) WaitUntilInstanceDeregistered(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceDeregistered", reflect.TypeOf((*MockELBAPI)(nil).WaitUntilInstanceDeregistered), arg0)
-}
-
-// WaitUntilInstanceDeregisteredWithContext mocks base method.
-func (m *MockELBAPI) WaitUntilInstanceDeregisteredWithContext(arg0 context.Context, arg1 *elb.DescribeInstanceHealthInput, 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, "WaitUntilInstanceDeregisteredWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilInstanceDeregisteredWithContext indicates an expected call of WaitUntilInstanceDeregisteredWithContext.
-func (mr *MockELBAPIMockRecorder) WaitUntilInstanceDeregisteredWithContext(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, "WaitUntilInstanceDeregisteredWithContext", reflect.TypeOf((*MockELBAPI)(nil).WaitUntilInstanceDeregisteredWithContext), varargs...)
-}
-
-// WaitUntilInstanceInService mocks base method.
-func (m *MockELBAPI) WaitUntilInstanceInService(arg0 *elb.DescribeInstanceHealthInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilInstanceInService", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilInstanceInService indicates an expected call of WaitUntilInstanceInService.
-func (mr *MockELBAPIMockRecorder) WaitUntilInstanceInService(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceInService", reflect.TypeOf((*MockELBAPI)(nil).WaitUntilInstanceInService), arg0)
-}
-
-// WaitUntilInstanceInServiceWithContext mocks base method.
-func (m *MockELBAPI) WaitUntilInstanceInServiceWithContext(arg0 context.Context, arg1 *elb.DescribeInstanceHealthInput, 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, "WaitUntilInstanceInServiceWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilInstanceInServiceWithContext indicates an expected call of WaitUntilInstanceInServiceWithContext.
-func (mr *MockELBAPIMockRecorder) WaitUntilInstanceInServiceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *MockELBAPIMockRecorder) RemoveTags(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, "WaitUntilInstanceInServiceWithContext", reflect.TypeOf((*MockELBAPI)(nil).WaitUntilInstanceInServiceWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTags", reflect.TypeOf((*MockELBAPI)(nil).RemoveTags), varargs...)
 }
diff --git a/test/mocks/aws_elbv2_mock.go b/test/mocks/aws_elbv2_mock.go
index 3afd166b6..7e3da85dc 100644
--- a/test/mocks/aws_elbv2_mock.go
+++ b/test/mocks/aws_elbv2_mock.go
@@ -15,7 +15,7 @@ limitations under the License.
 */
 
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/aws/aws-sdk-go/service/elbv2/elbv2iface (interfaces: ELBV2API)
+// Source: sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/elb (interfaces: ELBV2API)
 
 // Package mocks is a generated GoMock package.
 package mocks
@@ -23,9 +23,9 @@ package mocks
 import (
 	context "context"
 	reflect "reflect"
+	time "time"
 
-	request "github.com/aws/aws-sdk-go/aws/request"
-	elbv2 "github.com/aws/aws-sdk-go/service/elbv2"
+	elasticloadbalancingv2 "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2"
 	gomock "github.com/golang/mock/gomock"
 )
 
@@ -52,2665 +52,450 @@ func (m *MockELBV2API) EXPECT() *MockELBV2APIMockRecorder {
 	return m.recorder
 }
 
-// AddListenerCertificates mocks base method.
-func (m *MockELBV2API) AddListenerCertificates(arg0 *elbv2.AddListenerCertificatesInput) (*elbv2.AddListenerCertificatesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AddListenerCertificates", arg0)
-	ret0, _ := ret[0].(*elbv2.AddListenerCertificatesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AddListenerCertificates indicates an expected call of AddListenerCertificates.
-func (mr *MockELBV2APIMockRecorder) AddListenerCertificates(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListenerCertificates", reflect.TypeOf((*MockELBV2API)(nil).AddListenerCertificates), arg0)
-}
-
-// AddListenerCertificatesRequest mocks base method.
-func (m *MockELBV2API) AddListenerCertificatesRequest(arg0 *elbv2.AddListenerCertificatesInput) (*request.Request, *elbv2.AddListenerCertificatesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AddListenerCertificatesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.AddListenerCertificatesOutput)
-	return ret0, ret1
-}
-
-// AddListenerCertificatesRequest indicates an expected call of AddListenerCertificatesRequest.
-func (mr *MockELBV2APIMockRecorder) AddListenerCertificatesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListenerCertificatesRequest", reflect.TypeOf((*MockELBV2API)(nil).AddListenerCertificatesRequest), arg0)
-}
-
-// AddListenerCertificatesWithContext mocks base method.
-func (m *MockELBV2API) AddListenerCertificatesWithContext(arg0 context.Context, arg1 *elbv2.AddListenerCertificatesInput, arg2 ...request.Option) (*elbv2.AddListenerCertificatesOutput, error) {
+// AddTags mocks base method.
+func (m *MockELBV2API) AddTags(arg0 context.Context, arg1 *elasticloadbalancingv2.AddTagsInput, arg2 ...func(*elasticloadbalancingv2.Options)) (*elasticloadbalancingv2.AddTagsOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AddListenerCertificatesWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.AddListenerCertificatesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AddListenerCertificatesWithContext indicates an expected call of AddListenerCertificatesWithContext.
-func (mr *MockELBV2APIMockRecorder) AddListenerCertificatesWithContext(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, "AddListenerCertificatesWithContext", reflect.TypeOf((*MockELBV2API)(nil).AddListenerCertificatesWithContext), varargs...)
-}
-
-// AddTags mocks base method.
-func (m *MockELBV2API) AddTags(arg0 *elbv2.AddTagsInput) (*elbv2.AddTagsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AddTags", arg0)
-	ret0, _ := ret[0].(*elbv2.AddTagsOutput)
+	ret := m.ctrl.Call(m, "AddTags", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancingv2.AddTagsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // AddTags indicates an expected call of AddTags.
-func (mr *MockELBV2APIMockRecorder) AddTags(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTags", reflect.TypeOf((*MockELBV2API)(nil).AddTags), arg0)
-}
-
-// AddTagsRequest mocks base method.
-func (m *MockELBV2API) AddTagsRequest(arg0 *elbv2.AddTagsInput) (*request.Request, *elbv2.AddTagsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AddTagsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.AddTagsOutput)
-	return ret0, ret1
-}
-
-// AddTagsRequest indicates an expected call of AddTagsRequest.
-func (mr *MockELBV2APIMockRecorder) AddTagsRequest(arg0 interface{}) *gomock.Call {
+func (mr *MockELBV2APIMockRecorder) AddTags(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsRequest", reflect.TypeOf((*MockELBV2API)(nil).AddTagsRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTags", reflect.TypeOf((*MockELBV2API)(nil).AddTags), varargs...)
 }
 
-// AddTagsWithContext mocks base method.
-func (m *MockELBV2API) AddTagsWithContext(arg0 context.Context, arg1 *elbv2.AddTagsInput, arg2 ...request.Option) (*elbv2.AddTagsOutput, error) {
+// CreateListener mocks base method.
+func (m *MockELBV2API) CreateListener(arg0 context.Context, arg1 *elasticloadbalancingv2.CreateListenerInput, arg2 ...func(*elasticloadbalancingv2.Options)) (*elasticloadbalancingv2.CreateListenerOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AddTagsWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.AddTagsOutput)
+	ret := m.ctrl.Call(m, "CreateListener", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancingv2.CreateListenerOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AddTagsWithContext indicates an expected call of AddTagsWithContext.
-func (mr *MockELBV2APIMockRecorder) AddTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// CreateListener indicates an expected call of CreateListener.
+func (mr *MockELBV2APIMockRecorder) CreateListener(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, "AddTagsWithContext", reflect.TypeOf((*MockELBV2API)(nil).AddTagsWithContext), varargs...)
-}
-
-// AddTrustStoreRevocations mocks base method.
-func (m *MockELBV2API) AddTrustStoreRevocations(arg0 *elbv2.AddTrustStoreRevocationsInput) (*elbv2.AddTrustStoreRevocationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AddTrustStoreRevocations", arg0)
-	ret0, _ := ret[0].(*elbv2.AddTrustStoreRevocationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AddTrustStoreRevocations indicates an expected call of AddTrustStoreRevocations.
-func (mr *MockELBV2APIMockRecorder) AddTrustStoreRevocations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTrustStoreRevocations", reflect.TypeOf((*MockELBV2API)(nil).AddTrustStoreRevocations), arg0)
-}
-
-// AddTrustStoreRevocationsRequest mocks base method.
-func (m *MockELBV2API) AddTrustStoreRevocationsRequest(arg0 *elbv2.AddTrustStoreRevocationsInput) (*request.Request, *elbv2.AddTrustStoreRevocationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AddTrustStoreRevocationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.AddTrustStoreRevocationsOutput)
-	return ret0, ret1
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateListener", reflect.TypeOf((*MockELBV2API)(nil).CreateListener), varargs...)
 }
 
-// AddTrustStoreRevocationsRequest indicates an expected call of AddTrustStoreRevocationsRequest.
-func (mr *MockELBV2APIMockRecorder) AddTrustStoreRevocationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTrustStoreRevocationsRequest", reflect.TypeOf((*MockELBV2API)(nil).AddTrustStoreRevocationsRequest), arg0)
-}
-
-// AddTrustStoreRevocationsWithContext mocks base method.
-func (m *MockELBV2API) AddTrustStoreRevocationsWithContext(arg0 context.Context, arg1 *elbv2.AddTrustStoreRevocationsInput, arg2 ...request.Option) (*elbv2.AddTrustStoreRevocationsOutput, error) {
+// CreateLoadBalancer mocks base method.
+func (m *MockELBV2API) CreateLoadBalancer(arg0 context.Context, arg1 *elasticloadbalancingv2.CreateLoadBalancerInput, arg2 ...func(*elasticloadbalancingv2.Options)) (*elasticloadbalancingv2.CreateLoadBalancerOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AddTrustStoreRevocationsWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.AddTrustStoreRevocationsOutput)
+	ret := m.ctrl.Call(m, "CreateLoadBalancer", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancingv2.CreateLoadBalancerOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AddTrustStoreRevocationsWithContext indicates an expected call of AddTrustStoreRevocationsWithContext.
-func (mr *MockELBV2APIMockRecorder) AddTrustStoreRevocationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// CreateLoadBalancer indicates an expected call of CreateLoadBalancer.
+func (mr *MockELBV2APIMockRecorder) CreateLoadBalancer(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, "AddTrustStoreRevocationsWithContext", reflect.TypeOf((*MockELBV2API)(nil).AddTrustStoreRevocationsWithContext), varargs...)
-}
-
-// CreateListener mocks base method.
-func (m *MockELBV2API) CreateListener(arg0 *elbv2.CreateListenerInput) (*elbv2.CreateListenerOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateListener", arg0)
-	ret0, _ := ret[0].(*elbv2.CreateListenerOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateListener indicates an expected call of CreateListener.
-func (mr *MockELBV2APIMockRecorder) CreateListener(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateListener", reflect.TypeOf((*MockELBV2API)(nil).CreateListener), arg0)
-}
-
-// CreateListenerRequest mocks base method.
-func (m *MockELBV2API) CreateListenerRequest(arg0 *elbv2.CreateListenerInput) (*request.Request, *elbv2.CreateListenerOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateListenerRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.CreateListenerOutput)
-	return ret0, ret1
-}
-
-// CreateListenerRequest indicates an expected call of CreateListenerRequest.
-func (mr *MockELBV2APIMockRecorder) CreateListenerRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateListenerRequest", reflect.TypeOf((*MockELBV2API)(nil).CreateListenerRequest), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancer", reflect.TypeOf((*MockELBV2API)(nil).CreateLoadBalancer), varargs...)
 }
 
-// CreateListenerWithContext mocks base method.
-func (m *MockELBV2API) CreateListenerWithContext(arg0 context.Context, arg1 *elbv2.CreateListenerInput, arg2 ...request.Option) (*elbv2.CreateListenerOutput, error) {
+// CreateTargetGroup mocks base method.
+func (m *MockELBV2API) CreateTargetGroup(arg0 context.Context, arg1 *elasticloadbalancingv2.CreateTargetGroupInput, arg2 ...func(*elasticloadbalancingv2.Options)) (*elasticloadbalancingv2.CreateTargetGroupOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "CreateListenerWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.CreateListenerOutput)
+	ret := m.ctrl.Call(m, "CreateTargetGroup", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancingv2.CreateTargetGroupOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// CreateListenerWithContext indicates an expected call of CreateListenerWithContext.
-func (mr *MockELBV2APIMockRecorder) CreateListenerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// CreateTargetGroup indicates an expected call of CreateTargetGroup.
+func (mr *MockELBV2APIMockRecorder) CreateTargetGroup(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, "CreateListenerWithContext", reflect.TypeOf((*MockELBV2API)(nil).CreateListenerWithContext), varargs...)
-}
-
-// CreateLoadBalancer mocks base method.
-func (m *MockELBV2API) CreateLoadBalancer(arg0 *elbv2.CreateLoadBalancerInput) (*elbv2.CreateLoadBalancerOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLoadBalancer", arg0)
-	ret0, _ := ret[0].(*elbv2.CreateLoadBalancerOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateLoadBalancer indicates an expected call of CreateLoadBalancer.
-func (mr *MockELBV2APIMockRecorder) CreateLoadBalancer(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancer", reflect.TypeOf((*MockELBV2API)(nil).CreateLoadBalancer), arg0)
-}
-
-// CreateLoadBalancerRequest mocks base method.
-func (m *MockELBV2API) CreateLoadBalancerRequest(arg0 *elbv2.CreateLoadBalancerInput) (*request.Request, *elbv2.CreateLoadBalancerOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLoadBalancerRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.CreateLoadBalancerOutput)
-	return ret0, ret1
-}
-
-// CreateLoadBalancerRequest indicates an expected call of CreateLoadBalancerRequest.
-func (mr *MockELBV2APIMockRecorder) CreateLoadBalancerRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancerRequest", reflect.TypeOf((*MockELBV2API)(nil).CreateLoadBalancerRequest), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTargetGroup", reflect.TypeOf((*MockELBV2API)(nil).CreateTargetGroup), varargs...)
 }
 
-// CreateLoadBalancerWithContext mocks base method.
-func (m *MockELBV2API) CreateLoadBalancerWithContext(arg0 context.Context, arg1 *elbv2.CreateLoadBalancerInput, arg2 ...request.Option) (*elbv2.CreateLoadBalancerOutput, error) {
+// DeleteListener mocks base method.
+func (m *MockELBV2API) DeleteListener(arg0 context.Context, arg1 *elasticloadbalancingv2.DeleteListenerInput, arg2 ...func(*elasticloadbalancingv2.Options)) (*elasticloadbalancingv2.DeleteListenerOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "CreateLoadBalancerWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.CreateLoadBalancerOutput)
+	ret := m.ctrl.Call(m, "DeleteListener", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancingv2.DeleteListenerOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// CreateLoadBalancerWithContext indicates an expected call of CreateLoadBalancerWithContext.
-func (mr *MockELBV2APIMockRecorder) CreateLoadBalancerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DeleteListener indicates an expected call of DeleteListener.
+func (mr *MockELBV2APIMockRecorder) DeleteListener(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, "CreateLoadBalancerWithContext", reflect.TypeOf((*MockELBV2API)(nil).CreateLoadBalancerWithContext), varargs...)
-}
-
-// CreateRule mocks base method.
-func (m *MockELBV2API) CreateRule(arg0 *elbv2.CreateRuleInput) (*elbv2.CreateRuleOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateRule", arg0)
-	ret0, _ := ret[0].(*elbv2.CreateRuleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteListener", reflect.TypeOf((*MockELBV2API)(nil).DeleteListener), varargs...)
 }
 
-// CreateRule indicates an expected call of CreateRule.
-func (mr *MockELBV2APIMockRecorder) CreateRule(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRule", reflect.TypeOf((*MockELBV2API)(nil).CreateRule), arg0)
-}
-
-// CreateRuleRequest mocks base method.
-func (m *MockELBV2API) CreateRuleRequest(arg0 *elbv2.CreateRuleInput) (*request.Request, *elbv2.CreateRuleOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateRuleRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.CreateRuleOutput)
-	return ret0, ret1
-}
-
-// CreateRuleRequest indicates an expected call of CreateRuleRequest.
-func (mr *MockELBV2APIMockRecorder) CreateRuleRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRuleRequest", reflect.TypeOf((*MockELBV2API)(nil).CreateRuleRequest), arg0)
-}
-
-// CreateRuleWithContext mocks base method.
-func (m *MockELBV2API) CreateRuleWithContext(arg0 context.Context, arg1 *elbv2.CreateRuleInput, arg2 ...request.Option) (*elbv2.CreateRuleOutput, error) {
+// DeleteLoadBalancer mocks base method.
+func (m *MockELBV2API) DeleteLoadBalancer(arg0 context.Context, arg1 *elasticloadbalancingv2.DeleteLoadBalancerInput, arg2 ...func(*elasticloadbalancingv2.Options)) (*elasticloadbalancingv2.DeleteLoadBalancerOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "CreateRuleWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.CreateRuleOutput)
+	ret := m.ctrl.Call(m, "DeleteLoadBalancer", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancingv2.DeleteLoadBalancerOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// CreateRuleWithContext indicates an expected call of CreateRuleWithContext.
-func (mr *MockELBV2APIMockRecorder) CreateRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DeleteLoadBalancer indicates an expected call of DeleteLoadBalancer.
+func (mr *MockELBV2APIMockRecorder) DeleteLoadBalancer(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, "CreateRuleWithContext", reflect.TypeOf((*MockELBV2API)(nil).CreateRuleWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancer", reflect.TypeOf((*MockELBV2API)(nil).DeleteLoadBalancer), varargs...)
 }
 
-// CreateTargetGroup mocks base method.
-func (m *MockELBV2API) CreateTargetGroup(arg0 *elbv2.CreateTargetGroupInput) (*elbv2.CreateTargetGroupOutput, error) {
+// DeleteTargetGroup mocks base method.
+func (m *MockELBV2API) DeleteTargetGroup(arg0 context.Context, arg1 *elasticloadbalancingv2.DeleteTargetGroupInput, arg2 ...func(*elasticloadbalancingv2.Options)) (*elasticloadbalancingv2.DeleteTargetGroupOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTargetGroup", arg0)
-	ret0, _ := ret[0].(*elbv2.CreateTargetGroupOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteTargetGroup", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancingv2.DeleteTargetGroupOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// CreateTargetGroup indicates an expected call of CreateTargetGroup.
-func (mr *MockELBV2APIMockRecorder) CreateTargetGroup(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTargetGroup", reflect.TypeOf((*MockELBV2API)(nil).CreateTargetGroup), arg0)
-}
-
-// CreateTargetGroupRequest mocks base method.
-func (m *MockELBV2API) CreateTargetGroupRequest(arg0 *elbv2.CreateTargetGroupInput) (*request.Request, *elbv2.CreateTargetGroupOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTargetGroupRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.CreateTargetGroupOutput)
-	return ret0, ret1
-}
-
-// CreateTargetGroupRequest indicates an expected call of CreateTargetGroupRequest.
-func (mr *MockELBV2APIMockRecorder) CreateTargetGroupRequest(arg0 interface{}) *gomock.Call {
+// DeleteTargetGroup indicates an expected call of DeleteTargetGroup.
+func (mr *MockELBV2APIMockRecorder) DeleteTargetGroup(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTargetGroupRequest", reflect.TypeOf((*MockELBV2API)(nil).CreateTargetGroupRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTargetGroup", reflect.TypeOf((*MockELBV2API)(nil).DeleteTargetGroup), varargs...)
 }
 
-// CreateTargetGroupWithContext mocks base method.
-func (m *MockELBV2API) CreateTargetGroupWithContext(arg0 context.Context, arg1 *elbv2.CreateTargetGroupInput, arg2 ...request.Option) (*elbv2.CreateTargetGroupOutput, error) {
+// DeregisterTargets mocks base method.
+func (m *MockELBV2API) DeregisterTargets(arg0 context.Context, arg1 *elasticloadbalancingv2.DeregisterTargetsInput, arg2 ...func(*elasticloadbalancingv2.Options)) (*elasticloadbalancingv2.DeregisterTargetsOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "CreateTargetGroupWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.CreateTargetGroupOutput)
+	ret := m.ctrl.Call(m, "DeregisterTargets", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancingv2.DeregisterTargetsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// CreateTargetGroupWithContext indicates an expected call of CreateTargetGroupWithContext.
-func (mr *MockELBV2APIMockRecorder) CreateTargetGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DeregisterTargets indicates an expected call of DeregisterTargets.
+func (mr *MockELBV2APIMockRecorder) DeregisterTargets(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, "CreateTargetGroupWithContext", reflect.TypeOf((*MockELBV2API)(nil).CreateTargetGroupWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTargets", reflect.TypeOf((*MockELBV2API)(nil).DeregisterTargets), varargs...)
 }
 
-// CreateTrustStore mocks base method.
-func (m *MockELBV2API) CreateTrustStore(arg0 *elbv2.CreateTrustStoreInput) (*elbv2.CreateTrustStoreOutput, error) {
+// DescribeListeners mocks base method.
+func (m *MockELBV2API) DescribeListeners(arg0 context.Context, arg1 *elasticloadbalancingv2.DescribeListenersInput, arg2 ...func(*elasticloadbalancingv2.Options)) (*elasticloadbalancingv2.DescribeListenersOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTrustStore", arg0)
-	ret0, _ := ret[0].(*elbv2.CreateTrustStoreOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeListeners", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancingv2.DescribeListenersOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// CreateTrustStore indicates an expected call of CreateTrustStore.
-func (mr *MockELBV2APIMockRecorder) CreateTrustStore(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrustStore", reflect.TypeOf((*MockELBV2API)(nil).CreateTrustStore), arg0)
-}
-
-// CreateTrustStoreRequest mocks base method.
-func (m *MockELBV2API) CreateTrustStoreRequest(arg0 *elbv2.CreateTrustStoreInput) (*request.Request, *elbv2.CreateTrustStoreOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTrustStoreRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.CreateTrustStoreOutput)
-	return ret0, ret1
-}
-
-// CreateTrustStoreRequest indicates an expected call of CreateTrustStoreRequest.
-func (mr *MockELBV2APIMockRecorder) CreateTrustStoreRequest(arg0 interface{}) *gomock.Call {
+// DescribeListeners indicates an expected call of DescribeListeners.
+func (mr *MockELBV2APIMockRecorder) DescribeListeners(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrustStoreRequest", reflect.TypeOf((*MockELBV2API)(nil).CreateTrustStoreRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListeners", reflect.TypeOf((*MockELBV2API)(nil).DescribeListeners), varargs...)
 }
 
-// CreateTrustStoreWithContext mocks base method.
-func (m *MockELBV2API) CreateTrustStoreWithContext(arg0 context.Context, arg1 *elbv2.CreateTrustStoreInput, arg2 ...request.Option) (*elbv2.CreateTrustStoreOutput, error) {
+// DescribeLoadBalancerAttributes mocks base method.
+func (m *MockELBV2API) DescribeLoadBalancerAttributes(arg0 context.Context, arg1 *elasticloadbalancingv2.DescribeLoadBalancerAttributesInput, arg2 ...func(*elasticloadbalancingv2.Options)) (*elasticloadbalancingv2.DescribeLoadBalancerAttributesOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "CreateTrustStoreWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.CreateTrustStoreOutput)
+	ret := m.ctrl.Call(m, "DescribeLoadBalancerAttributes", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancingv2.DescribeLoadBalancerAttributesOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// CreateTrustStoreWithContext indicates an expected call of CreateTrustStoreWithContext.
-func (mr *MockELBV2APIMockRecorder) CreateTrustStoreWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DescribeLoadBalancerAttributes indicates an expected call of DescribeLoadBalancerAttributes.
+func (mr *MockELBV2APIMockRecorder) DescribeLoadBalancerAttributes(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, "CreateTrustStoreWithContext", reflect.TypeOf((*MockELBV2API)(nil).CreateTrustStoreWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerAttributes", reflect.TypeOf((*MockELBV2API)(nil).DescribeLoadBalancerAttributes), varargs...)
 }
 
-// DeleteListener mocks base method.
-func (m *MockELBV2API) DeleteListener(arg0 *elbv2.DeleteListenerInput) (*elbv2.DeleteListenerOutput, error) {
+// DescribeLoadBalancers mocks base method.
+func (m *MockELBV2API) DescribeLoadBalancers(arg0 context.Context, arg1 *elasticloadbalancingv2.DescribeLoadBalancersInput, arg2 ...func(*elasticloadbalancingv2.Options)) (*elasticloadbalancingv2.DescribeLoadBalancersOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteListener", arg0)
-	ret0, _ := ret[0].(*elbv2.DeleteListenerOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeLoadBalancers", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancingv2.DescribeLoadBalancersOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// DeleteListener indicates an expected call of DeleteListener.
-func (mr *MockELBV2APIMockRecorder) DeleteListener(arg0 interface{}) *gomock.Call {
+// DescribeLoadBalancers indicates an expected call of DescribeLoadBalancers.
+func (mr *MockELBV2APIMockRecorder) DescribeLoadBalancers(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteListener", reflect.TypeOf((*MockELBV2API)(nil).DeleteListener), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancers", reflect.TypeOf((*MockELBV2API)(nil).DescribeLoadBalancers), varargs...)
 }
 
-// DeleteListenerRequest mocks base method.
-func (m *MockELBV2API) DeleteListenerRequest(arg0 *elbv2.DeleteListenerInput) (*request.Request, *elbv2.DeleteListenerOutput) {
+// DescribeLoadBalancersPages mocks base method.
+func (m *MockELBV2API) DescribeLoadBalancersPages(arg0 context.Context, arg1 *elasticloadbalancingv2.DescribeLoadBalancersInput, arg2 func(*elasticloadbalancingv2.DescribeLoadBalancersOutput)) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteListenerRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.DeleteListenerOutput)
-	return ret0, ret1
+	ret := m.ctrl.Call(m, "DescribeLoadBalancersPages", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
 }
 
-// DeleteListenerRequest indicates an expected call of DeleteListenerRequest.
-func (mr *MockELBV2APIMockRecorder) DeleteListenerRequest(arg0 interface{}) *gomock.Call {
+// DescribeLoadBalancersPages indicates an expected call of DescribeLoadBalancersPages.
+func (mr *MockELBV2APIMockRecorder) DescribeLoadBalancersPages(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteListenerRequest", reflect.TypeOf((*MockELBV2API)(nil).DeleteListenerRequest), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersPages", reflect.TypeOf((*MockELBV2API)(nil).DescribeLoadBalancersPages), arg0, arg1, arg2)
 }
 
-// DeleteListenerWithContext mocks base method.
-func (m *MockELBV2API) DeleteListenerWithContext(arg0 context.Context, arg1 *elbv2.DeleteListenerInput, arg2 ...request.Option) (*elbv2.DeleteListenerOutput, error) {
+// DescribeTags mocks base method.
+func (m *MockELBV2API) DescribeTags(arg0 context.Context, arg1 *elasticloadbalancingv2.DescribeTagsInput, arg2 ...func(*elasticloadbalancingv2.Options)) (*elasticloadbalancingv2.DescribeTagsOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "DeleteListenerWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.DeleteListenerOutput)
+	ret := m.ctrl.Call(m, "DescribeTags", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancingv2.DescribeTagsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// DeleteListenerWithContext indicates an expected call of DeleteListenerWithContext.
-func (mr *MockELBV2APIMockRecorder) DeleteListenerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DescribeTags indicates an expected call of DescribeTags.
+func (mr *MockELBV2APIMockRecorder) DescribeTags(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, "DeleteListenerWithContext", reflect.TypeOf((*MockELBV2API)(nil).DeleteListenerWithContext), varargs...)
-}
-
-// DeleteLoadBalancer mocks base method.
-func (m *MockELBV2API) DeleteLoadBalancer(arg0 *elbv2.DeleteLoadBalancerInput) (*elbv2.DeleteLoadBalancerOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLoadBalancer", arg0)
-	ret0, _ := ret[0].(*elbv2.DeleteLoadBalancerOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteLoadBalancer indicates an expected call of DeleteLoadBalancer.
-func (mr *MockELBV2APIMockRecorder) DeleteLoadBalancer(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancer", reflect.TypeOf((*MockELBV2API)(nil).DeleteLoadBalancer), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTags", reflect.TypeOf((*MockELBV2API)(nil).DescribeTags), varargs...)
 }
 
-// DeleteLoadBalancerRequest mocks base method.
-func (m *MockELBV2API) DeleteLoadBalancerRequest(arg0 *elbv2.DeleteLoadBalancerInput) (*request.Request, *elbv2.DeleteLoadBalancerOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLoadBalancerRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.DeleteLoadBalancerOutput)
-	return ret0, ret1
-}
-
-// DeleteLoadBalancerRequest indicates an expected call of DeleteLoadBalancerRequest.
-func (mr *MockELBV2APIMockRecorder) DeleteLoadBalancerRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerRequest", reflect.TypeOf((*MockELBV2API)(nil).DeleteLoadBalancerRequest), arg0)
-}
-
-// DeleteLoadBalancerWithContext mocks base method.
-func (m *MockELBV2API) DeleteLoadBalancerWithContext(arg0 context.Context, arg1 *elbv2.DeleteLoadBalancerInput, arg2 ...request.Option) (*elbv2.DeleteLoadBalancerOutput, error) {
+// DescribeTargetGroups mocks base method.
+func (m *MockELBV2API) DescribeTargetGroups(arg0 context.Context, arg1 *elasticloadbalancingv2.DescribeTargetGroupsInput, arg2 ...func(*elasticloadbalancingv2.Options)) (*elasticloadbalancingv2.DescribeTargetGroupsOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "DeleteLoadBalancerWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.DeleteLoadBalancerOutput)
+	ret := m.ctrl.Call(m, "DescribeTargetGroups", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancingv2.DescribeTargetGroupsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// DeleteLoadBalancerWithContext indicates an expected call of DeleteLoadBalancerWithContext.
-func (mr *MockELBV2APIMockRecorder) DeleteLoadBalancerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DescribeTargetGroups indicates an expected call of DescribeTargetGroups.
+func (mr *MockELBV2APIMockRecorder) DescribeTargetGroups(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, "DeleteLoadBalancerWithContext", reflect.TypeOf((*MockELBV2API)(nil).DeleteLoadBalancerWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroups", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetGroups), varargs...)
 }
 
-// DeleteRule mocks base method.
-func (m *MockELBV2API) DeleteRule(arg0 *elbv2.DeleteRuleInput) (*elbv2.DeleteRuleOutput, error) {
+// DescribeTargetHealth mocks base method.
+func (m *MockELBV2API) DescribeTargetHealth(arg0 context.Context, arg1 *elasticloadbalancingv2.DescribeTargetHealthInput, arg2 ...func(*elasticloadbalancingv2.Options)) (*elasticloadbalancingv2.DescribeTargetHealthOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteRule", arg0)
-	ret0, _ := ret[0].(*elbv2.DeleteRuleOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeTargetHealth", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancingv2.DescribeTargetHealthOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// DeleteRule indicates an expected call of DeleteRule.
-func (mr *MockELBV2APIMockRecorder) DeleteRule(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRule", reflect.TypeOf((*MockELBV2API)(nil).DeleteRule), arg0)
-}
-
-// DeleteRuleRequest mocks base method.
-func (m *MockELBV2API) DeleteRuleRequest(arg0 *elbv2.DeleteRuleInput) (*request.Request, *elbv2.DeleteRuleOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteRuleRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.DeleteRuleOutput)
-	return ret0, ret1
-}
-
-// DeleteRuleRequest indicates an expected call of DeleteRuleRequest.
-func (mr *MockELBV2APIMockRecorder) DeleteRuleRequest(arg0 interface{}) *gomock.Call {
+// DescribeTargetHealth indicates an expected call of DescribeTargetHealth.
+func (mr *MockELBV2APIMockRecorder) DescribeTargetHealth(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRuleRequest", reflect.TypeOf((*MockELBV2API)(nil).DeleteRuleRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetHealth", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetHealth), varargs...)
 }
 
-// DeleteRuleWithContext mocks base method.
-func (m *MockELBV2API) DeleteRuleWithContext(arg0 context.Context, arg1 *elbv2.DeleteRuleInput, arg2 ...request.Option) (*elbv2.DeleteRuleOutput, error) {
+// ModifyListener mocks base method.
+func (m *MockELBV2API) ModifyListener(arg0 context.Context, arg1 *elasticloadbalancingv2.ModifyListenerInput, arg2 ...func(*elasticloadbalancingv2.Options)) (*elasticloadbalancingv2.ModifyListenerOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "DeleteRuleWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.DeleteRuleOutput)
+	ret := m.ctrl.Call(m, "ModifyListener", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancingv2.ModifyListenerOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// DeleteRuleWithContext indicates an expected call of DeleteRuleWithContext.
-func (mr *MockELBV2APIMockRecorder) DeleteRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// ModifyListener indicates an expected call of ModifyListener.
+func (mr *MockELBV2APIMockRecorder) ModifyListener(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, "DeleteRuleWithContext", reflect.TypeOf((*MockELBV2API)(nil).DeleteRuleWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyListener", reflect.TypeOf((*MockELBV2API)(nil).ModifyListener), varargs...)
 }
 
-// DeleteSharedTrustStoreAssociation mocks base method.
-func (m *MockELBV2API) DeleteSharedTrustStoreAssociation(arg0 *elbv2.DeleteSharedTrustStoreAssociationInput) (*elbv2.DeleteSharedTrustStoreAssociationOutput, error) {
+// ModifyLoadBalancerAttributes mocks base method.
+func (m *MockELBV2API) ModifyLoadBalancerAttributes(arg0 context.Context, arg1 *elasticloadbalancingv2.ModifyLoadBalancerAttributesInput, arg2 ...func(*elasticloadbalancingv2.Options)) (*elasticloadbalancingv2.ModifyLoadBalancerAttributesOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteSharedTrustStoreAssociation", arg0)
-	ret0, _ := ret[0].(*elbv2.DeleteSharedTrustStoreAssociationOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ModifyLoadBalancerAttributes", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancingv2.ModifyLoadBalancerAttributesOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// DeleteSharedTrustStoreAssociation indicates an expected call of DeleteSharedTrustStoreAssociation.
-func (mr *MockELBV2APIMockRecorder) DeleteSharedTrustStoreAssociation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSharedTrustStoreAssociation", reflect.TypeOf((*MockELBV2API)(nil).DeleteSharedTrustStoreAssociation), arg0)
-}
-
-// DeleteSharedTrustStoreAssociationRequest mocks base method.
-func (m *MockELBV2API) DeleteSharedTrustStoreAssociationRequest(arg0 *elbv2.DeleteSharedTrustStoreAssociationInput) (*request.Request, *elbv2.DeleteSharedTrustStoreAssociationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteSharedTrustStoreAssociationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.DeleteSharedTrustStoreAssociationOutput)
-	return ret0, ret1
-}
-
-// DeleteSharedTrustStoreAssociationRequest indicates an expected call of DeleteSharedTrustStoreAssociationRequest.
-func (mr *MockELBV2APIMockRecorder) DeleteSharedTrustStoreAssociationRequest(arg0 interface{}) *gomock.Call {
+// ModifyLoadBalancerAttributes indicates an expected call of ModifyLoadBalancerAttributes.
+func (mr *MockELBV2APIMockRecorder) ModifyLoadBalancerAttributes(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSharedTrustStoreAssociationRequest", reflect.TypeOf((*MockELBV2API)(nil).DeleteSharedTrustStoreAssociationRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLoadBalancerAttributes", reflect.TypeOf((*MockELBV2API)(nil).ModifyLoadBalancerAttributes), varargs...)
 }
 
-// DeleteSharedTrustStoreAssociationWithContext mocks base method.
-func (m *MockELBV2API) DeleteSharedTrustStoreAssociationWithContext(arg0 context.Context, arg1 *elbv2.DeleteSharedTrustStoreAssociationInput, arg2 ...request.Option) (*elbv2.DeleteSharedTrustStoreAssociationOutput, error) {
+// ModifyTargetGroupAttributes mocks base method.
+func (m *MockELBV2API) ModifyTargetGroupAttributes(arg0 context.Context, arg1 *elasticloadbalancingv2.ModifyTargetGroupAttributesInput, arg2 ...func(*elasticloadbalancingv2.Options)) (*elasticloadbalancingv2.ModifyTargetGroupAttributesOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "DeleteSharedTrustStoreAssociationWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.DeleteSharedTrustStoreAssociationOutput)
+	ret := m.ctrl.Call(m, "ModifyTargetGroupAttributes", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancingv2.ModifyTargetGroupAttributesOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// DeleteSharedTrustStoreAssociationWithContext indicates an expected call of DeleteSharedTrustStoreAssociationWithContext.
-func (mr *MockELBV2APIMockRecorder) DeleteSharedTrustStoreAssociationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// ModifyTargetGroupAttributes indicates an expected call of ModifyTargetGroupAttributes.
+func (mr *MockELBV2APIMockRecorder) ModifyTargetGroupAttributes(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, "DeleteSharedTrustStoreAssociationWithContext", reflect.TypeOf((*MockELBV2API)(nil).DeleteSharedTrustStoreAssociationWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTargetGroupAttributes", reflect.TypeOf((*MockELBV2API)(nil).ModifyTargetGroupAttributes), varargs...)
 }
 
-// DeleteTargetGroup mocks base method.
-func (m *MockELBV2API) DeleteTargetGroup(arg0 *elbv2.DeleteTargetGroupInput) (*elbv2.DeleteTargetGroupOutput, error) {
+// RegisterTargets mocks base method.
+func (m *MockELBV2API) RegisterTargets(arg0 context.Context, arg1 *elasticloadbalancingv2.RegisterTargetsInput, arg2 ...func(*elasticloadbalancingv2.Options)) (*elasticloadbalancingv2.RegisterTargetsOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTargetGroup", arg0)
-	ret0, _ := ret[0].(*elbv2.DeleteTargetGroupOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "RegisterTargets", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancingv2.RegisterTargetsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// DeleteTargetGroup indicates an expected call of DeleteTargetGroup.
-func (mr *MockELBV2APIMockRecorder) DeleteTargetGroup(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTargetGroup", reflect.TypeOf((*MockELBV2API)(nil).DeleteTargetGroup), arg0)
-}
-
-// DeleteTargetGroupRequest mocks base method.
-func (m *MockELBV2API) DeleteTargetGroupRequest(arg0 *elbv2.DeleteTargetGroupInput) (*request.Request, *elbv2.DeleteTargetGroupOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTargetGroupRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.DeleteTargetGroupOutput)
-	return ret0, ret1
-}
-
-// DeleteTargetGroupRequest indicates an expected call of DeleteTargetGroupRequest.
-func (mr *MockELBV2APIMockRecorder) DeleteTargetGroupRequest(arg0 interface{}) *gomock.Call {
+// RegisterTargets indicates an expected call of RegisterTargets.
+func (mr *MockELBV2APIMockRecorder) RegisterTargets(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTargetGroupRequest", reflect.TypeOf((*MockELBV2API)(nil).DeleteTargetGroupRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTargets", reflect.TypeOf((*MockELBV2API)(nil).RegisterTargets), varargs...)
 }
 
-// DeleteTargetGroupWithContext mocks base method.
-func (m *MockELBV2API) DeleteTargetGroupWithContext(arg0 context.Context, arg1 *elbv2.DeleteTargetGroupInput, arg2 ...request.Option) (*elbv2.DeleteTargetGroupOutput, error) {
+// RemoveTags mocks base method.
+func (m *MockELBV2API) RemoveTags(arg0 context.Context, arg1 *elasticloadbalancingv2.RemoveTagsInput, arg2 ...func(*elasticloadbalancingv2.Options)) (*elasticloadbalancingv2.RemoveTagsOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "DeleteTargetGroupWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.DeleteTargetGroupOutput)
+	ret := m.ctrl.Call(m, "RemoveTags", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancingv2.RemoveTagsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// DeleteTargetGroupWithContext indicates an expected call of DeleteTargetGroupWithContext.
-func (mr *MockELBV2APIMockRecorder) DeleteTargetGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// RemoveTags indicates an expected call of RemoveTags.
+func (mr *MockELBV2APIMockRecorder) RemoveTags(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, "DeleteTargetGroupWithContext", reflect.TypeOf((*MockELBV2API)(nil).DeleteTargetGroupWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTags", reflect.TypeOf((*MockELBV2API)(nil).RemoveTags), varargs...)
 }
 
-// DeleteTrustStore mocks base method.
-func (m *MockELBV2API) DeleteTrustStore(arg0 *elbv2.DeleteTrustStoreInput) (*elbv2.DeleteTrustStoreOutput, error) {
+// SetSecurityGroups mocks base method.
+func (m *MockELBV2API) SetSecurityGroups(arg0 context.Context, arg1 *elasticloadbalancingv2.SetSecurityGroupsInput, arg2 ...func(*elasticloadbalancingv2.Options)) (*elasticloadbalancingv2.SetSecurityGroupsOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTrustStore", arg0)
-	ret0, _ := ret[0].(*elbv2.DeleteTrustStoreOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SetSecurityGroups", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancingv2.SetSecurityGroupsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// DeleteTrustStore indicates an expected call of DeleteTrustStore.
-func (mr *MockELBV2APIMockRecorder) DeleteTrustStore(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrustStore", reflect.TypeOf((*MockELBV2API)(nil).DeleteTrustStore), arg0)
-}
-
-// DeleteTrustStoreRequest mocks base method.
-func (m *MockELBV2API) DeleteTrustStoreRequest(arg0 *elbv2.DeleteTrustStoreInput) (*request.Request, *elbv2.DeleteTrustStoreOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTrustStoreRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.DeleteTrustStoreOutput)
-	return ret0, ret1
-}
-
-// DeleteTrustStoreRequest indicates an expected call of DeleteTrustStoreRequest.
-func (mr *MockELBV2APIMockRecorder) DeleteTrustStoreRequest(arg0 interface{}) *gomock.Call {
+// SetSecurityGroups indicates an expected call of SetSecurityGroups.
+func (mr *MockELBV2APIMockRecorder) SetSecurityGroups(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrustStoreRequest", reflect.TypeOf((*MockELBV2API)(nil).DeleteTrustStoreRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSecurityGroups", reflect.TypeOf((*MockELBV2API)(nil).SetSecurityGroups), varargs...)
 }
 
-// DeleteTrustStoreWithContext mocks base method.
-func (m *MockELBV2API) DeleteTrustStoreWithContext(arg0 context.Context, arg1 *elbv2.DeleteTrustStoreInput, arg2 ...request.Option) (*elbv2.DeleteTrustStoreOutput, error) {
+// SetSubnets mocks base method.
+func (m *MockELBV2API) SetSubnets(arg0 context.Context, arg1 *elasticloadbalancingv2.SetSubnetsInput, arg2 ...func(*elasticloadbalancingv2.Options)) (*elasticloadbalancingv2.SetSubnetsOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "DeleteTrustStoreWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.DeleteTrustStoreOutput)
+	ret := m.ctrl.Call(m, "SetSubnets", varargs...)
+	ret0, _ := ret[0].(*elasticloadbalancingv2.SetSubnetsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// DeleteTrustStoreWithContext indicates an expected call of DeleteTrustStoreWithContext.
-func (mr *MockELBV2APIMockRecorder) DeleteTrustStoreWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// SetSubnets indicates an expected call of SetSubnets.
+func (mr *MockELBV2APIMockRecorder) SetSubnets(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, "DeleteTrustStoreWithContext", reflect.TypeOf((*MockELBV2API)(nil).DeleteTrustStoreWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSubnets", reflect.TypeOf((*MockELBV2API)(nil).SetSubnets), varargs...)
 }
 
-// DeregisterTargets mocks base method.
-func (m *MockELBV2API) DeregisterTargets(arg0 *elbv2.DeregisterTargetsInput) (*elbv2.DeregisterTargetsOutput, error) {
+// WaitUntilLoadBalancerAvailable mocks base method.
+func (m *MockELBV2API) WaitUntilLoadBalancerAvailable(arg0 context.Context, arg1 *elasticloadbalancingv2.DescribeLoadBalancersInput, arg2 time.Duration) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeregisterTargets", arg0)
-	ret0, _ := ret[0].(*elbv2.DeregisterTargetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
+	ret := m.ctrl.Call(m, "WaitUntilLoadBalancerAvailable", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
 }
 
-// DeregisterTargets indicates an expected call of DeregisterTargets.
-func (mr *MockELBV2APIMockRecorder) DeregisterTargets(arg0 interface{}) *gomock.Call {
+// WaitUntilLoadBalancerAvailable indicates an expected call of WaitUntilLoadBalancerAvailable.
+func (mr *MockELBV2APIMockRecorder) WaitUntilLoadBalancerAvailable(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTargets", reflect.TypeOf((*MockELBV2API)(nil).DeregisterTargets), arg0)
-}
-
-// DeregisterTargetsRequest mocks base method.
-func (m *MockELBV2API) DeregisterTargetsRequest(arg0 *elbv2.DeregisterTargetsInput) (*request.Request, *elbv2.DeregisterTargetsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeregisterTargetsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.DeregisterTargetsOutput)
-	return ret0, ret1
-}
-
-// DeregisterTargetsRequest indicates an expected call of DeregisterTargetsRequest.
-func (mr *MockELBV2APIMockRecorder) DeregisterTargetsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTargetsRequest", reflect.TypeOf((*MockELBV2API)(nil).DeregisterTargetsRequest), arg0)
-}
-
-// DeregisterTargetsWithContext mocks base method.
-func (m *MockELBV2API) DeregisterTargetsWithContext(arg0 context.Context, arg1 *elbv2.DeregisterTargetsInput, arg2 ...request.Option) (*elbv2.DeregisterTargetsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeregisterTargetsWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.DeregisterTargetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeregisterTargetsWithContext indicates an expected call of DeregisterTargetsWithContext.
-func (mr *MockELBV2APIMockRecorder) DeregisterTargetsWithContext(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, "DeregisterTargetsWithContext", reflect.TypeOf((*MockELBV2API)(nil).DeregisterTargetsWithContext), varargs...)
-}
-
-// DescribeAccountLimits mocks base method.
-func (m *MockELBV2API) DescribeAccountLimits(arg0 *elbv2.DescribeAccountLimitsInput) (*elbv2.DescribeAccountLimitsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAccountLimits", arg0)
-	ret0, _ := ret[0].(*elbv2.DescribeAccountLimitsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAccountLimits indicates an expected call of DescribeAccountLimits.
-func (mr *MockELBV2APIMockRecorder) DescribeAccountLimits(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimits", reflect.TypeOf((*MockELBV2API)(nil).DescribeAccountLimits), arg0)
-}
-
-// DescribeAccountLimitsRequest mocks base method.
-func (m *MockELBV2API) DescribeAccountLimitsRequest(arg0 *elbv2.DescribeAccountLimitsInput) (*request.Request, *elbv2.DescribeAccountLimitsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAccountLimitsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.DescribeAccountLimitsOutput)
-	return ret0, ret1
-}
-
-// DescribeAccountLimitsRequest indicates an expected call of DescribeAccountLimitsRequest.
-func (mr *MockELBV2APIMockRecorder) DescribeAccountLimitsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimitsRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeAccountLimitsRequest), arg0)
-}
-
-// DescribeAccountLimitsWithContext mocks base method.
-func (m *MockELBV2API) DescribeAccountLimitsWithContext(arg0 context.Context, arg1 *elbv2.DescribeAccountLimitsInput, arg2 ...request.Option) (*elbv2.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].(*elbv2.DescribeAccountLimitsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAccountLimitsWithContext indicates an expected call of DescribeAccountLimitsWithContext.
-func (mr *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).DescribeAccountLimitsWithContext), varargs...)
-}
-
-// DescribeListenerCertificates mocks base method.
-func (m *MockELBV2API) DescribeListenerCertificates(arg0 *elbv2.DescribeListenerCertificatesInput) (*elbv2.DescribeListenerCertificatesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeListenerCertificates", arg0)
-	ret0, _ := ret[0].(*elbv2.DescribeListenerCertificatesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeListenerCertificates indicates an expected call of DescribeListenerCertificates.
-func (mr *MockELBV2APIMockRecorder) DescribeListenerCertificates(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenerCertificates", reflect.TypeOf((*MockELBV2API)(nil).DescribeListenerCertificates), arg0)
-}
-
-// DescribeListenerCertificatesRequest mocks base method.
-func (m *MockELBV2API) DescribeListenerCertificatesRequest(arg0 *elbv2.DescribeListenerCertificatesInput) (*request.Request, *elbv2.DescribeListenerCertificatesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeListenerCertificatesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.DescribeListenerCertificatesOutput)
-	return ret0, ret1
-}
-
-// DescribeListenerCertificatesRequest indicates an expected call of DescribeListenerCertificatesRequest.
-func (mr *MockELBV2APIMockRecorder) DescribeListenerCertificatesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenerCertificatesRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeListenerCertificatesRequest), arg0)
-}
-
-// DescribeListenerCertificatesWithContext mocks base method.
-func (m *MockELBV2API) DescribeListenerCertificatesWithContext(arg0 context.Context, arg1 *elbv2.DescribeListenerCertificatesInput, arg2 ...request.Option) (*elbv2.DescribeListenerCertificatesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeListenerCertificatesWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.DescribeListenerCertificatesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeListenerCertificatesWithContext indicates an expected call of DescribeListenerCertificatesWithContext.
-func (mr *MockELBV2APIMockRecorder) DescribeListenerCertificatesWithContext(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, "DescribeListenerCertificatesWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeListenerCertificatesWithContext), varargs...)
-}
-
-// DescribeListeners mocks base method.
-func (m *MockELBV2API) DescribeListeners(arg0 *elbv2.DescribeListenersInput) (*elbv2.DescribeListenersOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeListeners", arg0)
-	ret0, _ := ret[0].(*elbv2.DescribeListenersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeListeners indicates an expected call of DescribeListeners.
-func (mr *MockELBV2APIMockRecorder) DescribeListeners(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListeners", reflect.TypeOf((*MockELBV2API)(nil).DescribeListeners), arg0)
-}
-
-// DescribeListenersPages mocks base method.
-func (m *MockELBV2API) DescribeListenersPages(arg0 *elbv2.DescribeListenersInput, arg1 func(*elbv2.DescribeListenersOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeListenersPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeListenersPages indicates an expected call of DescribeListenersPages.
-func (mr *MockELBV2APIMockRecorder) DescribeListenersPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenersPages", reflect.TypeOf((*MockELBV2API)(nil).DescribeListenersPages), arg0, arg1)
-}
-
-// DescribeListenersPagesWithContext mocks base method.
-func (m *MockELBV2API) DescribeListenersPagesWithContext(arg0 context.Context, arg1 *elbv2.DescribeListenersInput, arg2 func(*elbv2.DescribeListenersOutput, 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, "DescribeListenersPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeListenersPagesWithContext indicates an expected call of DescribeListenersPagesWithContext.
-func (mr *MockELBV2APIMockRecorder) DescribeListenersPagesWithContext(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, "DescribeListenersPagesWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeListenersPagesWithContext), varargs...)
-}
-
-// DescribeListenersRequest mocks base method.
-func (m *MockELBV2API) DescribeListenersRequest(arg0 *elbv2.DescribeListenersInput) (*request.Request, *elbv2.DescribeListenersOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeListenersRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.DescribeListenersOutput)
-	return ret0, ret1
-}
-
-// DescribeListenersRequest indicates an expected call of DescribeListenersRequest.
-func (mr *MockELBV2APIMockRecorder) DescribeListenersRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenersRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeListenersRequest), arg0)
-}
-
-// DescribeListenersWithContext mocks base method.
-func (m *MockELBV2API) DescribeListenersWithContext(arg0 context.Context, arg1 *elbv2.DescribeListenersInput, arg2 ...request.Option) (*elbv2.DescribeListenersOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeListenersWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.DescribeListenersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeListenersWithContext indicates an expected call of DescribeListenersWithContext.
-func (mr *MockELBV2APIMockRecorder) DescribeListenersWithContext(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, "DescribeListenersWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeListenersWithContext), varargs...)
-}
-
-// DescribeLoadBalancerAttributes mocks base method.
-func (m *MockELBV2API) DescribeLoadBalancerAttributes(arg0 *elbv2.DescribeLoadBalancerAttributesInput) (*elbv2.DescribeLoadBalancerAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLoadBalancerAttributes", arg0)
-	ret0, _ := ret[0].(*elbv2.DescribeLoadBalancerAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancerAttributes indicates an expected call of DescribeLoadBalancerAttributes.
-func (mr *MockELBV2APIMockRecorder) DescribeLoadBalancerAttributes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerAttributes", reflect.TypeOf((*MockELBV2API)(nil).DescribeLoadBalancerAttributes), arg0)
-}
-
-// DescribeLoadBalancerAttributesRequest mocks base method.
-func (m *MockELBV2API) DescribeLoadBalancerAttributesRequest(arg0 *elbv2.DescribeLoadBalancerAttributesInput) (*request.Request, *elbv2.DescribeLoadBalancerAttributesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLoadBalancerAttributesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.DescribeLoadBalancerAttributesOutput)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancerAttributesRequest indicates an expected call of DescribeLoadBalancerAttributesRequest.
-func (mr *MockELBV2APIMockRecorder) DescribeLoadBalancerAttributesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerAttributesRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeLoadBalancerAttributesRequest), arg0)
-}
-
-// DescribeLoadBalancerAttributesWithContext mocks base method.
-func (m *MockELBV2API) DescribeLoadBalancerAttributesWithContext(arg0 context.Context, arg1 *elbv2.DescribeLoadBalancerAttributesInput, arg2 ...request.Option) (*elbv2.DescribeLoadBalancerAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeLoadBalancerAttributesWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.DescribeLoadBalancerAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancerAttributesWithContext indicates an expected call of DescribeLoadBalancerAttributesWithContext.
-func (mr *MockELBV2APIMockRecorder) DescribeLoadBalancerAttributesWithContext(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, "DescribeLoadBalancerAttributesWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeLoadBalancerAttributesWithContext), varargs...)
-}
-
-// DescribeLoadBalancers mocks base method.
-func (m *MockELBV2API) DescribeLoadBalancers(arg0 *elbv2.DescribeLoadBalancersInput) (*elbv2.DescribeLoadBalancersOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLoadBalancers", arg0)
-	ret0, _ := ret[0].(*elbv2.DescribeLoadBalancersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancers indicates an expected call of DescribeLoadBalancers.
-func (mr *MockELBV2APIMockRecorder) DescribeLoadBalancers(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancers", reflect.TypeOf((*MockELBV2API)(nil).DescribeLoadBalancers), arg0)
-}
-
-// DescribeLoadBalancersPages mocks base method.
-func (m *MockELBV2API) DescribeLoadBalancersPages(arg0 *elbv2.DescribeLoadBalancersInput, arg1 func(*elbv2.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 *MockELBV2APIMockRecorder) DescribeLoadBalancersPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersPages", reflect.TypeOf((*MockELBV2API)(nil).DescribeLoadBalancersPages), arg0, arg1)
-}
-
-// DescribeLoadBalancersPagesWithContext mocks base method.
-func (m *MockELBV2API) DescribeLoadBalancersPagesWithContext(arg0 context.Context, arg1 *elbv2.DescribeLoadBalancersInput, arg2 func(*elbv2.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).DescribeLoadBalancersPagesWithContext), varargs...)
-}
-
-// DescribeLoadBalancersRequest mocks base method.
-func (m *MockELBV2API) DescribeLoadBalancersRequest(arg0 *elbv2.DescribeLoadBalancersInput) (*request.Request, *elbv2.DescribeLoadBalancersOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLoadBalancersRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.DescribeLoadBalancersOutput)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancersRequest indicates an expected call of DescribeLoadBalancersRequest.
-func (mr *MockELBV2APIMockRecorder) DescribeLoadBalancersRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeLoadBalancersRequest), arg0)
-}
-
-// DescribeLoadBalancersWithContext mocks base method.
-func (m *MockELBV2API) DescribeLoadBalancersWithContext(arg0 context.Context, arg1 *elbv2.DescribeLoadBalancersInput, arg2 ...request.Option) (*elbv2.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].(*elbv2.DescribeLoadBalancersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLoadBalancersWithContext indicates an expected call of DescribeLoadBalancersWithContext.
-func (mr *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).DescribeLoadBalancersWithContext), varargs...)
-}
-
-// DescribeRules mocks base method.
-func (m *MockELBV2API) DescribeRules(arg0 *elbv2.DescribeRulesInput) (*elbv2.DescribeRulesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeRules", arg0)
-	ret0, _ := ret[0].(*elbv2.DescribeRulesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeRules indicates an expected call of DescribeRules.
-func (mr *MockELBV2APIMockRecorder) DescribeRules(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRules", reflect.TypeOf((*MockELBV2API)(nil).DescribeRules), arg0)
-}
-
-// DescribeRulesRequest mocks base method.
-func (m *MockELBV2API) DescribeRulesRequest(arg0 *elbv2.DescribeRulesInput) (*request.Request, *elbv2.DescribeRulesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeRulesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.DescribeRulesOutput)
-	return ret0, ret1
-}
-
-// DescribeRulesRequest indicates an expected call of DescribeRulesRequest.
-func (mr *MockELBV2APIMockRecorder) DescribeRulesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRulesRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeRulesRequest), arg0)
-}
-
-// DescribeRulesWithContext mocks base method.
-func (m *MockELBV2API) DescribeRulesWithContext(arg0 context.Context, arg1 *elbv2.DescribeRulesInput, arg2 ...request.Option) (*elbv2.DescribeRulesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeRulesWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.DescribeRulesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeRulesWithContext indicates an expected call of DescribeRulesWithContext.
-func (mr *MockELBV2APIMockRecorder) DescribeRulesWithContext(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, "DescribeRulesWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeRulesWithContext), varargs...)
-}
-
-// DescribeSSLPolicies mocks base method.
-func (m *MockELBV2API) DescribeSSLPolicies(arg0 *elbv2.DescribeSSLPoliciesInput) (*elbv2.DescribeSSLPoliciesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSSLPolicies", arg0)
-	ret0, _ := ret[0].(*elbv2.DescribeSSLPoliciesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSSLPolicies indicates an expected call of DescribeSSLPolicies.
-func (mr *MockELBV2APIMockRecorder) DescribeSSLPolicies(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSSLPolicies", reflect.TypeOf((*MockELBV2API)(nil).DescribeSSLPolicies), arg0)
-}
-
-// DescribeSSLPoliciesRequest mocks base method.
-func (m *MockELBV2API) DescribeSSLPoliciesRequest(arg0 *elbv2.DescribeSSLPoliciesInput) (*request.Request, *elbv2.DescribeSSLPoliciesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSSLPoliciesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.DescribeSSLPoliciesOutput)
-	return ret0, ret1
-}
-
-// DescribeSSLPoliciesRequest indicates an expected call of DescribeSSLPoliciesRequest.
-func (mr *MockELBV2APIMockRecorder) DescribeSSLPoliciesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSSLPoliciesRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeSSLPoliciesRequest), arg0)
-}
-
-// DescribeSSLPoliciesWithContext mocks base method.
-func (m *MockELBV2API) DescribeSSLPoliciesWithContext(arg0 context.Context, arg1 *elbv2.DescribeSSLPoliciesInput, arg2 ...request.Option) (*elbv2.DescribeSSLPoliciesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeSSLPoliciesWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.DescribeSSLPoliciesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSSLPoliciesWithContext indicates an expected call of DescribeSSLPoliciesWithContext.
-func (mr *MockELBV2APIMockRecorder) DescribeSSLPoliciesWithContext(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, "DescribeSSLPoliciesWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeSSLPoliciesWithContext), varargs...)
-}
-
-// DescribeTags mocks base method.
-func (m *MockELBV2API) DescribeTags(arg0 *elbv2.DescribeTagsInput) (*elbv2.DescribeTagsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTags", arg0)
-	ret0, _ := ret[0].(*elbv2.DescribeTagsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTags indicates an expected call of DescribeTags.
-func (mr *MockELBV2APIMockRecorder) DescribeTags(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTags", reflect.TypeOf((*MockELBV2API)(nil).DescribeTags), arg0)
-}
-
-// DescribeTagsRequest mocks base method.
-func (m *MockELBV2API) DescribeTagsRequest(arg0 *elbv2.DescribeTagsInput) (*request.Request, *elbv2.DescribeTagsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTagsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.DescribeTagsOutput)
-	return ret0, ret1
-}
-
-// DescribeTagsRequest indicates an expected call of DescribeTagsRequest.
-func (mr *MockELBV2APIMockRecorder) DescribeTagsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeTagsRequest), arg0)
-}
-
-// DescribeTagsWithContext mocks base method.
-func (m *MockELBV2API) DescribeTagsWithContext(arg0 context.Context, arg1 *elbv2.DescribeTagsInput, arg2 ...request.Option) (*elbv2.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].(*elbv2.DescribeTagsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTagsWithContext indicates an expected call of DescribeTagsWithContext.
-func (mr *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).DescribeTagsWithContext), varargs...)
-}
-
-// DescribeTargetGroupAttributes mocks base method.
-func (m *MockELBV2API) DescribeTargetGroupAttributes(arg0 *elbv2.DescribeTargetGroupAttributesInput) (*elbv2.DescribeTargetGroupAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTargetGroupAttributes", arg0)
-	ret0, _ := ret[0].(*elbv2.DescribeTargetGroupAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTargetGroupAttributes indicates an expected call of DescribeTargetGroupAttributes.
-func (mr *MockELBV2APIMockRecorder) DescribeTargetGroupAttributes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroupAttributes", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetGroupAttributes), arg0)
-}
-
-// DescribeTargetGroupAttributesRequest mocks base method.
-func (m *MockELBV2API) DescribeTargetGroupAttributesRequest(arg0 *elbv2.DescribeTargetGroupAttributesInput) (*request.Request, *elbv2.DescribeTargetGroupAttributesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTargetGroupAttributesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.DescribeTargetGroupAttributesOutput)
-	return ret0, ret1
-}
-
-// DescribeTargetGroupAttributesRequest indicates an expected call of DescribeTargetGroupAttributesRequest.
-func (mr *MockELBV2APIMockRecorder) DescribeTargetGroupAttributesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroupAttributesRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetGroupAttributesRequest), arg0)
-}
-
-// DescribeTargetGroupAttributesWithContext mocks base method.
-func (m *MockELBV2API) DescribeTargetGroupAttributesWithContext(arg0 context.Context, arg1 *elbv2.DescribeTargetGroupAttributesInput, arg2 ...request.Option) (*elbv2.DescribeTargetGroupAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTargetGroupAttributesWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.DescribeTargetGroupAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTargetGroupAttributesWithContext indicates an expected call of DescribeTargetGroupAttributesWithContext.
-func (mr *MockELBV2APIMockRecorder) DescribeTargetGroupAttributesWithContext(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, "DescribeTargetGroupAttributesWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetGroupAttributesWithContext), varargs...)
-}
-
-// DescribeTargetGroups mocks base method.
-func (m *MockELBV2API) DescribeTargetGroups(arg0 *elbv2.DescribeTargetGroupsInput) (*elbv2.DescribeTargetGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTargetGroups", arg0)
-	ret0, _ := ret[0].(*elbv2.DescribeTargetGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTargetGroups indicates an expected call of DescribeTargetGroups.
-func (mr *MockELBV2APIMockRecorder) DescribeTargetGroups(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroups", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetGroups), arg0)
-}
-
-// DescribeTargetGroupsPages mocks base method.
-func (m *MockELBV2API) DescribeTargetGroupsPages(arg0 *elbv2.DescribeTargetGroupsInput, arg1 func(*elbv2.DescribeTargetGroupsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTargetGroupsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTargetGroupsPages indicates an expected call of DescribeTargetGroupsPages.
-func (mr *MockELBV2APIMockRecorder) DescribeTargetGroupsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroupsPages", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetGroupsPages), arg0, arg1)
-}
-
-// DescribeTargetGroupsPagesWithContext mocks base method.
-func (m *MockELBV2API) DescribeTargetGroupsPagesWithContext(arg0 context.Context, arg1 *elbv2.DescribeTargetGroupsInput, arg2 func(*elbv2.DescribeTargetGroupsOutput, 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, "DescribeTargetGroupsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTargetGroupsPagesWithContext indicates an expected call of DescribeTargetGroupsPagesWithContext.
-func (mr *MockELBV2APIMockRecorder) DescribeTargetGroupsPagesWithContext(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, "DescribeTargetGroupsPagesWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetGroupsPagesWithContext), varargs...)
-}
-
-// DescribeTargetGroupsRequest mocks base method.
-func (m *MockELBV2API) DescribeTargetGroupsRequest(arg0 *elbv2.DescribeTargetGroupsInput) (*request.Request, *elbv2.DescribeTargetGroupsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTargetGroupsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.DescribeTargetGroupsOutput)
-	return ret0, ret1
-}
-
-// DescribeTargetGroupsRequest indicates an expected call of DescribeTargetGroupsRequest.
-func (mr *MockELBV2APIMockRecorder) DescribeTargetGroupsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroupsRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetGroupsRequest), arg0)
-}
-
-// DescribeTargetGroupsWithContext mocks base method.
-func (m *MockELBV2API) DescribeTargetGroupsWithContext(arg0 context.Context, arg1 *elbv2.DescribeTargetGroupsInput, arg2 ...request.Option) (*elbv2.DescribeTargetGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTargetGroupsWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.DescribeTargetGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTargetGroupsWithContext indicates an expected call of DescribeTargetGroupsWithContext.
-func (mr *MockELBV2APIMockRecorder) DescribeTargetGroupsWithContext(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, "DescribeTargetGroupsWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetGroupsWithContext), varargs...)
-}
-
-// DescribeTargetHealth mocks base method.
-func (m *MockELBV2API) DescribeTargetHealth(arg0 *elbv2.DescribeTargetHealthInput) (*elbv2.DescribeTargetHealthOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTargetHealth", arg0)
-	ret0, _ := ret[0].(*elbv2.DescribeTargetHealthOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTargetHealth indicates an expected call of DescribeTargetHealth.
-func (mr *MockELBV2APIMockRecorder) DescribeTargetHealth(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetHealth", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetHealth), arg0)
-}
-
-// DescribeTargetHealthRequest mocks base method.
-func (m *MockELBV2API) DescribeTargetHealthRequest(arg0 *elbv2.DescribeTargetHealthInput) (*request.Request, *elbv2.DescribeTargetHealthOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTargetHealthRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.DescribeTargetHealthOutput)
-	return ret0, ret1
-}
-
-// DescribeTargetHealthRequest indicates an expected call of DescribeTargetHealthRequest.
-func (mr *MockELBV2APIMockRecorder) DescribeTargetHealthRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetHealthRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetHealthRequest), arg0)
-}
-
-// DescribeTargetHealthWithContext mocks base method.
-func (m *MockELBV2API) DescribeTargetHealthWithContext(arg0 context.Context, arg1 *elbv2.DescribeTargetHealthInput, arg2 ...request.Option) (*elbv2.DescribeTargetHealthOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTargetHealthWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.DescribeTargetHealthOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTargetHealthWithContext indicates an expected call of DescribeTargetHealthWithContext.
-func (mr *MockELBV2APIMockRecorder) DescribeTargetHealthWithContext(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, "DescribeTargetHealthWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetHealthWithContext), varargs...)
-}
-
-// DescribeTrustStoreAssociations mocks base method.
-func (m *MockELBV2API) DescribeTrustStoreAssociations(arg0 *elbv2.DescribeTrustStoreAssociationsInput) (*elbv2.DescribeTrustStoreAssociationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrustStoreAssociations", arg0)
-	ret0, _ := ret[0].(*elbv2.DescribeTrustStoreAssociationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTrustStoreAssociations indicates an expected call of DescribeTrustStoreAssociations.
-func (mr *MockELBV2APIMockRecorder) DescribeTrustStoreAssociations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustStoreAssociations", reflect.TypeOf((*MockELBV2API)(nil).DescribeTrustStoreAssociations), arg0)
-}
-
-// DescribeTrustStoreAssociationsPages mocks base method.
-func (m *MockELBV2API) DescribeTrustStoreAssociationsPages(arg0 *elbv2.DescribeTrustStoreAssociationsInput, arg1 func(*elbv2.DescribeTrustStoreAssociationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrustStoreAssociationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTrustStoreAssociationsPages indicates an expected call of DescribeTrustStoreAssociationsPages.
-func (mr *MockELBV2APIMockRecorder) DescribeTrustStoreAssociationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustStoreAssociationsPages", reflect.TypeOf((*MockELBV2API)(nil).DescribeTrustStoreAssociationsPages), arg0, arg1)
-}
-
-// DescribeTrustStoreAssociationsPagesWithContext mocks base method.
-func (m *MockELBV2API) DescribeTrustStoreAssociationsPagesWithContext(arg0 context.Context, arg1 *elbv2.DescribeTrustStoreAssociationsInput, arg2 func(*elbv2.DescribeTrustStoreAssociationsOutput, 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, "DescribeTrustStoreAssociationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTrustStoreAssociationsPagesWithContext indicates an expected call of DescribeTrustStoreAssociationsPagesWithContext.
-func (mr *MockELBV2APIMockRecorder) DescribeTrustStoreAssociationsPagesWithContext(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, "DescribeTrustStoreAssociationsPagesWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeTrustStoreAssociationsPagesWithContext), varargs...)
-}
-
-// DescribeTrustStoreAssociationsRequest mocks base method.
-func (m *MockELBV2API) DescribeTrustStoreAssociationsRequest(arg0 *elbv2.DescribeTrustStoreAssociationsInput) (*request.Request, *elbv2.DescribeTrustStoreAssociationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrustStoreAssociationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.DescribeTrustStoreAssociationsOutput)
-	return ret0, ret1
-}
-
-// DescribeTrustStoreAssociationsRequest indicates an expected call of DescribeTrustStoreAssociationsRequest.
-func (mr *MockELBV2APIMockRecorder) DescribeTrustStoreAssociationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustStoreAssociationsRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeTrustStoreAssociationsRequest), arg0)
-}
-
-// DescribeTrustStoreAssociationsWithContext mocks base method.
-func (m *MockELBV2API) DescribeTrustStoreAssociationsWithContext(arg0 context.Context, arg1 *elbv2.DescribeTrustStoreAssociationsInput, arg2 ...request.Option) (*elbv2.DescribeTrustStoreAssociationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTrustStoreAssociationsWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.DescribeTrustStoreAssociationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTrustStoreAssociationsWithContext indicates an expected call of DescribeTrustStoreAssociationsWithContext.
-func (mr *MockELBV2APIMockRecorder) DescribeTrustStoreAssociationsWithContext(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, "DescribeTrustStoreAssociationsWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeTrustStoreAssociationsWithContext), varargs...)
-}
-
-// DescribeTrustStoreRevocations mocks base method.
-func (m *MockELBV2API) DescribeTrustStoreRevocations(arg0 *elbv2.DescribeTrustStoreRevocationsInput) (*elbv2.DescribeTrustStoreRevocationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrustStoreRevocations", arg0)
-	ret0, _ := ret[0].(*elbv2.DescribeTrustStoreRevocationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTrustStoreRevocations indicates an expected call of DescribeTrustStoreRevocations.
-func (mr *MockELBV2APIMockRecorder) DescribeTrustStoreRevocations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustStoreRevocations", reflect.TypeOf((*MockELBV2API)(nil).DescribeTrustStoreRevocations), arg0)
-}
-
-// DescribeTrustStoreRevocationsPages mocks base method.
-func (m *MockELBV2API) DescribeTrustStoreRevocationsPages(arg0 *elbv2.DescribeTrustStoreRevocationsInput, arg1 func(*elbv2.DescribeTrustStoreRevocationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrustStoreRevocationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTrustStoreRevocationsPages indicates an expected call of DescribeTrustStoreRevocationsPages.
-func (mr *MockELBV2APIMockRecorder) DescribeTrustStoreRevocationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustStoreRevocationsPages", reflect.TypeOf((*MockELBV2API)(nil).DescribeTrustStoreRevocationsPages), arg0, arg1)
-}
-
-// DescribeTrustStoreRevocationsPagesWithContext mocks base method.
-func (m *MockELBV2API) DescribeTrustStoreRevocationsPagesWithContext(arg0 context.Context, arg1 *elbv2.DescribeTrustStoreRevocationsInput, arg2 func(*elbv2.DescribeTrustStoreRevocationsOutput, 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, "DescribeTrustStoreRevocationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTrustStoreRevocationsPagesWithContext indicates an expected call of DescribeTrustStoreRevocationsPagesWithContext.
-func (mr *MockELBV2APIMockRecorder) DescribeTrustStoreRevocationsPagesWithContext(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, "DescribeTrustStoreRevocationsPagesWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeTrustStoreRevocationsPagesWithContext), varargs...)
-}
-
-// DescribeTrustStoreRevocationsRequest mocks base method.
-func (m *MockELBV2API) DescribeTrustStoreRevocationsRequest(arg0 *elbv2.DescribeTrustStoreRevocationsInput) (*request.Request, *elbv2.DescribeTrustStoreRevocationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrustStoreRevocationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.DescribeTrustStoreRevocationsOutput)
-	return ret0, ret1
-}
-
-// DescribeTrustStoreRevocationsRequest indicates an expected call of DescribeTrustStoreRevocationsRequest.
-func (mr *MockELBV2APIMockRecorder) DescribeTrustStoreRevocationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustStoreRevocationsRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeTrustStoreRevocationsRequest), arg0)
-}
-
-// DescribeTrustStoreRevocationsWithContext mocks base method.
-func (m *MockELBV2API) DescribeTrustStoreRevocationsWithContext(arg0 context.Context, arg1 *elbv2.DescribeTrustStoreRevocationsInput, arg2 ...request.Option) (*elbv2.DescribeTrustStoreRevocationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTrustStoreRevocationsWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.DescribeTrustStoreRevocationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTrustStoreRevocationsWithContext indicates an expected call of DescribeTrustStoreRevocationsWithContext.
-func (mr *MockELBV2APIMockRecorder) DescribeTrustStoreRevocationsWithContext(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, "DescribeTrustStoreRevocationsWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeTrustStoreRevocationsWithContext), varargs...)
-}
-
-// DescribeTrustStores mocks base method.
-func (m *MockELBV2API) DescribeTrustStores(arg0 *elbv2.DescribeTrustStoresInput) (*elbv2.DescribeTrustStoresOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrustStores", arg0)
-	ret0, _ := ret[0].(*elbv2.DescribeTrustStoresOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTrustStores indicates an expected call of DescribeTrustStores.
-func (mr *MockELBV2APIMockRecorder) DescribeTrustStores(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustStores", reflect.TypeOf((*MockELBV2API)(nil).DescribeTrustStores), arg0)
-}
-
-// DescribeTrustStoresPages mocks base method.
-func (m *MockELBV2API) DescribeTrustStoresPages(arg0 *elbv2.DescribeTrustStoresInput, arg1 func(*elbv2.DescribeTrustStoresOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrustStoresPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTrustStoresPages indicates an expected call of DescribeTrustStoresPages.
-func (mr *MockELBV2APIMockRecorder) DescribeTrustStoresPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustStoresPages", reflect.TypeOf((*MockELBV2API)(nil).DescribeTrustStoresPages), arg0, arg1)
-}
-
-// DescribeTrustStoresPagesWithContext mocks base method.
-func (m *MockELBV2API) DescribeTrustStoresPagesWithContext(arg0 context.Context, arg1 *elbv2.DescribeTrustStoresInput, arg2 func(*elbv2.DescribeTrustStoresOutput, 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, "DescribeTrustStoresPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTrustStoresPagesWithContext indicates an expected call of DescribeTrustStoresPagesWithContext.
-func (mr *MockELBV2APIMockRecorder) DescribeTrustStoresPagesWithContext(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, "DescribeTrustStoresPagesWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeTrustStoresPagesWithContext), varargs...)
-}
-
-// DescribeTrustStoresRequest mocks base method.
-func (m *MockELBV2API) DescribeTrustStoresRequest(arg0 *elbv2.DescribeTrustStoresInput) (*request.Request, *elbv2.DescribeTrustStoresOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrustStoresRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.DescribeTrustStoresOutput)
-	return ret0, ret1
-}
-
-// DescribeTrustStoresRequest indicates an expected call of DescribeTrustStoresRequest.
-func (mr *MockELBV2APIMockRecorder) DescribeTrustStoresRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustStoresRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeTrustStoresRequest), arg0)
-}
-
-// DescribeTrustStoresWithContext mocks base method.
-func (m *MockELBV2API) DescribeTrustStoresWithContext(arg0 context.Context, arg1 *elbv2.DescribeTrustStoresInput, arg2 ...request.Option) (*elbv2.DescribeTrustStoresOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTrustStoresWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.DescribeTrustStoresOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTrustStoresWithContext indicates an expected call of DescribeTrustStoresWithContext.
-func (mr *MockELBV2APIMockRecorder) DescribeTrustStoresWithContext(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, "DescribeTrustStoresWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeTrustStoresWithContext), varargs...)
-}
-
-// GetResourcePolicy mocks base method.
-func (m *MockELBV2API) GetResourcePolicy(arg0 *elbv2.GetResourcePolicyInput) (*elbv2.GetResourcePolicyOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetResourcePolicy", arg0)
-	ret0, _ := ret[0].(*elbv2.GetResourcePolicyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetResourcePolicy indicates an expected call of GetResourcePolicy.
-func (mr *MockELBV2APIMockRecorder) GetResourcePolicy(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourcePolicy", reflect.TypeOf((*MockELBV2API)(nil).GetResourcePolicy), arg0)
-}
-
-// GetResourcePolicyRequest mocks base method.
-func (m *MockELBV2API) GetResourcePolicyRequest(arg0 *elbv2.GetResourcePolicyInput) (*request.Request, *elbv2.GetResourcePolicyOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetResourcePolicyRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.GetResourcePolicyOutput)
-	return ret0, ret1
-}
-
-// GetResourcePolicyRequest indicates an expected call of GetResourcePolicyRequest.
-func (mr *MockELBV2APIMockRecorder) GetResourcePolicyRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourcePolicyRequest", reflect.TypeOf((*MockELBV2API)(nil).GetResourcePolicyRequest), arg0)
-}
-
-// GetResourcePolicyWithContext mocks base method.
-func (m *MockELBV2API) GetResourcePolicyWithContext(arg0 context.Context, arg1 *elbv2.GetResourcePolicyInput, arg2 ...request.Option) (*elbv2.GetResourcePolicyOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetResourcePolicyWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.GetResourcePolicyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetResourcePolicyWithContext indicates an expected call of GetResourcePolicyWithContext.
-func (mr *MockELBV2APIMockRecorder) GetResourcePolicyWithContext(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, "GetResourcePolicyWithContext", reflect.TypeOf((*MockELBV2API)(nil).GetResourcePolicyWithContext), varargs...)
-}
-
-// GetTrustStoreCaCertificatesBundle mocks base method.
-func (m *MockELBV2API) GetTrustStoreCaCertificatesBundle(arg0 *elbv2.GetTrustStoreCaCertificatesBundleInput) (*elbv2.GetTrustStoreCaCertificatesBundleOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTrustStoreCaCertificatesBundle", arg0)
-	ret0, _ := ret[0].(*elbv2.GetTrustStoreCaCertificatesBundleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetTrustStoreCaCertificatesBundle indicates an expected call of GetTrustStoreCaCertificatesBundle.
-func (mr *MockELBV2APIMockRecorder) GetTrustStoreCaCertificatesBundle(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrustStoreCaCertificatesBundle", reflect.TypeOf((*MockELBV2API)(nil).GetTrustStoreCaCertificatesBundle), arg0)
-}
-
-// GetTrustStoreCaCertificatesBundleRequest mocks base method.
-func (m *MockELBV2API) GetTrustStoreCaCertificatesBundleRequest(arg0 *elbv2.GetTrustStoreCaCertificatesBundleInput) (*request.Request, *elbv2.GetTrustStoreCaCertificatesBundleOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTrustStoreCaCertificatesBundleRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.GetTrustStoreCaCertificatesBundleOutput)
-	return ret0, ret1
-}
-
-// GetTrustStoreCaCertificatesBundleRequest indicates an expected call of GetTrustStoreCaCertificatesBundleRequest.
-func (mr *MockELBV2APIMockRecorder) GetTrustStoreCaCertificatesBundleRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrustStoreCaCertificatesBundleRequest", reflect.TypeOf((*MockELBV2API)(nil).GetTrustStoreCaCertificatesBundleRequest), arg0)
-}
-
-// GetTrustStoreCaCertificatesBundleWithContext mocks base method.
-func (m *MockELBV2API) GetTrustStoreCaCertificatesBundleWithContext(arg0 context.Context, arg1 *elbv2.GetTrustStoreCaCertificatesBundleInput, arg2 ...request.Option) (*elbv2.GetTrustStoreCaCertificatesBundleOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetTrustStoreCaCertificatesBundleWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.GetTrustStoreCaCertificatesBundleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetTrustStoreCaCertificatesBundleWithContext indicates an expected call of GetTrustStoreCaCertificatesBundleWithContext.
-func (mr *MockELBV2APIMockRecorder) GetTrustStoreCaCertificatesBundleWithContext(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, "GetTrustStoreCaCertificatesBundleWithContext", reflect.TypeOf((*MockELBV2API)(nil).GetTrustStoreCaCertificatesBundleWithContext), varargs...)
-}
-
-// GetTrustStoreRevocationContent mocks base method.
-func (m *MockELBV2API) GetTrustStoreRevocationContent(arg0 *elbv2.GetTrustStoreRevocationContentInput) (*elbv2.GetTrustStoreRevocationContentOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTrustStoreRevocationContent", arg0)
-	ret0, _ := ret[0].(*elbv2.GetTrustStoreRevocationContentOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetTrustStoreRevocationContent indicates an expected call of GetTrustStoreRevocationContent.
-func (mr *MockELBV2APIMockRecorder) GetTrustStoreRevocationContent(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrustStoreRevocationContent", reflect.TypeOf((*MockELBV2API)(nil).GetTrustStoreRevocationContent), arg0)
-}
-
-// GetTrustStoreRevocationContentRequest mocks base method.
-func (m *MockELBV2API) GetTrustStoreRevocationContentRequest(arg0 *elbv2.GetTrustStoreRevocationContentInput) (*request.Request, *elbv2.GetTrustStoreRevocationContentOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTrustStoreRevocationContentRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.GetTrustStoreRevocationContentOutput)
-	return ret0, ret1
-}
-
-// GetTrustStoreRevocationContentRequest indicates an expected call of GetTrustStoreRevocationContentRequest.
-func (mr *MockELBV2APIMockRecorder) GetTrustStoreRevocationContentRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrustStoreRevocationContentRequest", reflect.TypeOf((*MockELBV2API)(nil).GetTrustStoreRevocationContentRequest), arg0)
-}
-
-// GetTrustStoreRevocationContentWithContext mocks base method.
-func (m *MockELBV2API) GetTrustStoreRevocationContentWithContext(arg0 context.Context, arg1 *elbv2.GetTrustStoreRevocationContentInput, arg2 ...request.Option) (*elbv2.GetTrustStoreRevocationContentOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetTrustStoreRevocationContentWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.GetTrustStoreRevocationContentOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetTrustStoreRevocationContentWithContext indicates an expected call of GetTrustStoreRevocationContentWithContext.
-func (mr *MockELBV2APIMockRecorder) GetTrustStoreRevocationContentWithContext(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, "GetTrustStoreRevocationContentWithContext", reflect.TypeOf((*MockELBV2API)(nil).GetTrustStoreRevocationContentWithContext), varargs...)
-}
-
-// ModifyListener mocks base method.
-func (m *MockELBV2API) ModifyListener(arg0 *elbv2.ModifyListenerInput) (*elbv2.ModifyListenerOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyListener", arg0)
-	ret0, _ := ret[0].(*elbv2.ModifyListenerOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyListener indicates an expected call of ModifyListener.
-func (mr *MockELBV2APIMockRecorder) ModifyListener(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyListener", reflect.TypeOf((*MockELBV2API)(nil).ModifyListener), arg0)
-}
-
-// ModifyListenerRequest mocks base method.
-func (m *MockELBV2API) ModifyListenerRequest(arg0 *elbv2.ModifyListenerInput) (*request.Request, *elbv2.ModifyListenerOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyListenerRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.ModifyListenerOutput)
-	return ret0, ret1
-}
-
-// ModifyListenerRequest indicates an expected call of ModifyListenerRequest.
-func (mr *MockELBV2APIMockRecorder) ModifyListenerRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyListenerRequest", reflect.TypeOf((*MockELBV2API)(nil).ModifyListenerRequest), arg0)
-}
-
-// ModifyListenerWithContext mocks base method.
-func (m *MockELBV2API) ModifyListenerWithContext(arg0 context.Context, arg1 *elbv2.ModifyListenerInput, arg2 ...request.Option) (*elbv2.ModifyListenerOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyListenerWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.ModifyListenerOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyListenerWithContext indicates an expected call of ModifyListenerWithContext.
-func (mr *MockELBV2APIMockRecorder) ModifyListenerWithContext(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, "ModifyListenerWithContext", reflect.TypeOf((*MockELBV2API)(nil).ModifyListenerWithContext), varargs...)
-}
-
-// ModifyLoadBalancerAttributes mocks base method.
-func (m *MockELBV2API) ModifyLoadBalancerAttributes(arg0 *elbv2.ModifyLoadBalancerAttributesInput) (*elbv2.ModifyLoadBalancerAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyLoadBalancerAttributes", arg0)
-	ret0, _ := ret[0].(*elbv2.ModifyLoadBalancerAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyLoadBalancerAttributes indicates an expected call of ModifyLoadBalancerAttributes.
-func (mr *MockELBV2APIMockRecorder) ModifyLoadBalancerAttributes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLoadBalancerAttributes", reflect.TypeOf((*MockELBV2API)(nil).ModifyLoadBalancerAttributes), arg0)
-}
-
-// ModifyLoadBalancerAttributesRequest mocks base method.
-func (m *MockELBV2API) ModifyLoadBalancerAttributesRequest(arg0 *elbv2.ModifyLoadBalancerAttributesInput) (*request.Request, *elbv2.ModifyLoadBalancerAttributesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyLoadBalancerAttributesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.ModifyLoadBalancerAttributesOutput)
-	return ret0, ret1
-}
-
-// ModifyLoadBalancerAttributesRequest indicates an expected call of ModifyLoadBalancerAttributesRequest.
-func (mr *MockELBV2APIMockRecorder) ModifyLoadBalancerAttributesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLoadBalancerAttributesRequest", reflect.TypeOf((*MockELBV2API)(nil).ModifyLoadBalancerAttributesRequest), arg0)
-}
-
-// ModifyLoadBalancerAttributesWithContext mocks base method.
-func (m *MockELBV2API) ModifyLoadBalancerAttributesWithContext(arg0 context.Context, arg1 *elbv2.ModifyLoadBalancerAttributesInput, arg2 ...request.Option) (*elbv2.ModifyLoadBalancerAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyLoadBalancerAttributesWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.ModifyLoadBalancerAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyLoadBalancerAttributesWithContext indicates an expected call of ModifyLoadBalancerAttributesWithContext.
-func (mr *MockELBV2APIMockRecorder) ModifyLoadBalancerAttributesWithContext(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, "ModifyLoadBalancerAttributesWithContext", reflect.TypeOf((*MockELBV2API)(nil).ModifyLoadBalancerAttributesWithContext), varargs...)
-}
-
-// ModifyRule mocks base method.
-func (m *MockELBV2API) ModifyRule(arg0 *elbv2.ModifyRuleInput) (*elbv2.ModifyRuleOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyRule", arg0)
-	ret0, _ := ret[0].(*elbv2.ModifyRuleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyRule indicates an expected call of ModifyRule.
-func (mr *MockELBV2APIMockRecorder) ModifyRule(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyRule", reflect.TypeOf((*MockELBV2API)(nil).ModifyRule), arg0)
-}
-
-// ModifyRuleRequest mocks base method.
-func (m *MockELBV2API) ModifyRuleRequest(arg0 *elbv2.ModifyRuleInput) (*request.Request, *elbv2.ModifyRuleOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyRuleRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.ModifyRuleOutput)
-	return ret0, ret1
-}
-
-// ModifyRuleRequest indicates an expected call of ModifyRuleRequest.
-func (mr *MockELBV2APIMockRecorder) ModifyRuleRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyRuleRequest", reflect.TypeOf((*MockELBV2API)(nil).ModifyRuleRequest), arg0)
-}
-
-// ModifyRuleWithContext mocks base method.
-func (m *MockELBV2API) ModifyRuleWithContext(arg0 context.Context, arg1 *elbv2.ModifyRuleInput, arg2 ...request.Option) (*elbv2.ModifyRuleOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyRuleWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.ModifyRuleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyRuleWithContext indicates an expected call of ModifyRuleWithContext.
-func (mr *MockELBV2APIMockRecorder) ModifyRuleWithContext(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, "ModifyRuleWithContext", reflect.TypeOf((*MockELBV2API)(nil).ModifyRuleWithContext), varargs...)
-}
-
-// ModifyTargetGroup mocks base method.
-func (m *MockELBV2API) ModifyTargetGroup(arg0 *elbv2.ModifyTargetGroupInput) (*elbv2.ModifyTargetGroupOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyTargetGroup", arg0)
-	ret0, _ := ret[0].(*elbv2.ModifyTargetGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyTargetGroup indicates an expected call of ModifyTargetGroup.
-func (mr *MockELBV2APIMockRecorder) ModifyTargetGroup(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTargetGroup", reflect.TypeOf((*MockELBV2API)(nil).ModifyTargetGroup), arg0)
-}
-
-// ModifyTargetGroupAttributes mocks base method.
-func (m *MockELBV2API) ModifyTargetGroupAttributes(arg0 *elbv2.ModifyTargetGroupAttributesInput) (*elbv2.ModifyTargetGroupAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyTargetGroupAttributes", arg0)
-	ret0, _ := ret[0].(*elbv2.ModifyTargetGroupAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyTargetGroupAttributes indicates an expected call of ModifyTargetGroupAttributes.
-func (mr *MockELBV2APIMockRecorder) ModifyTargetGroupAttributes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTargetGroupAttributes", reflect.TypeOf((*MockELBV2API)(nil).ModifyTargetGroupAttributes), arg0)
-}
-
-// ModifyTargetGroupAttributesRequest mocks base method.
-func (m *MockELBV2API) ModifyTargetGroupAttributesRequest(arg0 *elbv2.ModifyTargetGroupAttributesInput) (*request.Request, *elbv2.ModifyTargetGroupAttributesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyTargetGroupAttributesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.ModifyTargetGroupAttributesOutput)
-	return ret0, ret1
-}
-
-// ModifyTargetGroupAttributesRequest indicates an expected call of ModifyTargetGroupAttributesRequest.
-func (mr *MockELBV2APIMockRecorder) ModifyTargetGroupAttributesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTargetGroupAttributesRequest", reflect.TypeOf((*MockELBV2API)(nil).ModifyTargetGroupAttributesRequest), arg0)
-}
-
-// ModifyTargetGroupAttributesWithContext mocks base method.
-func (m *MockELBV2API) ModifyTargetGroupAttributesWithContext(arg0 context.Context, arg1 *elbv2.ModifyTargetGroupAttributesInput, arg2 ...request.Option) (*elbv2.ModifyTargetGroupAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyTargetGroupAttributesWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.ModifyTargetGroupAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyTargetGroupAttributesWithContext indicates an expected call of ModifyTargetGroupAttributesWithContext.
-func (mr *MockELBV2APIMockRecorder) ModifyTargetGroupAttributesWithContext(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, "ModifyTargetGroupAttributesWithContext", reflect.TypeOf((*MockELBV2API)(nil).ModifyTargetGroupAttributesWithContext), varargs...)
-}
-
-// ModifyTargetGroupRequest mocks base method.
-func (m *MockELBV2API) ModifyTargetGroupRequest(arg0 *elbv2.ModifyTargetGroupInput) (*request.Request, *elbv2.ModifyTargetGroupOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyTargetGroupRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.ModifyTargetGroupOutput)
-	return ret0, ret1
-}
-
-// ModifyTargetGroupRequest indicates an expected call of ModifyTargetGroupRequest.
-func (mr *MockELBV2APIMockRecorder) ModifyTargetGroupRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTargetGroupRequest", reflect.TypeOf((*MockELBV2API)(nil).ModifyTargetGroupRequest), arg0)
-}
-
-// ModifyTargetGroupWithContext mocks base method.
-func (m *MockELBV2API) ModifyTargetGroupWithContext(arg0 context.Context, arg1 *elbv2.ModifyTargetGroupInput, arg2 ...request.Option) (*elbv2.ModifyTargetGroupOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyTargetGroupWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.ModifyTargetGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyTargetGroupWithContext indicates an expected call of ModifyTargetGroupWithContext.
-func (mr *MockELBV2APIMockRecorder) ModifyTargetGroupWithContext(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, "ModifyTargetGroupWithContext", reflect.TypeOf((*MockELBV2API)(nil).ModifyTargetGroupWithContext), varargs...)
-}
-
-// ModifyTrustStore mocks base method.
-func (m *MockELBV2API) ModifyTrustStore(arg0 *elbv2.ModifyTrustStoreInput) (*elbv2.ModifyTrustStoreOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyTrustStore", arg0)
-	ret0, _ := ret[0].(*elbv2.ModifyTrustStoreOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyTrustStore indicates an expected call of ModifyTrustStore.
-func (mr *MockELBV2APIMockRecorder) ModifyTrustStore(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrustStore", reflect.TypeOf((*MockELBV2API)(nil).ModifyTrustStore), arg0)
-}
-
-// ModifyTrustStoreRequest mocks base method.
-func (m *MockELBV2API) ModifyTrustStoreRequest(arg0 *elbv2.ModifyTrustStoreInput) (*request.Request, *elbv2.ModifyTrustStoreOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyTrustStoreRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.ModifyTrustStoreOutput)
-	return ret0, ret1
-}
-
-// ModifyTrustStoreRequest indicates an expected call of ModifyTrustStoreRequest.
-func (mr *MockELBV2APIMockRecorder) ModifyTrustStoreRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrustStoreRequest", reflect.TypeOf((*MockELBV2API)(nil).ModifyTrustStoreRequest), arg0)
-}
-
-// ModifyTrustStoreWithContext mocks base method.
-func (m *MockELBV2API) ModifyTrustStoreWithContext(arg0 context.Context, arg1 *elbv2.ModifyTrustStoreInput, arg2 ...request.Option) (*elbv2.ModifyTrustStoreOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyTrustStoreWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.ModifyTrustStoreOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyTrustStoreWithContext indicates an expected call of ModifyTrustStoreWithContext.
-func (mr *MockELBV2APIMockRecorder) ModifyTrustStoreWithContext(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, "ModifyTrustStoreWithContext", reflect.TypeOf((*MockELBV2API)(nil).ModifyTrustStoreWithContext), varargs...)
-}
-
-// RegisterTargets mocks base method.
-func (m *MockELBV2API) RegisterTargets(arg0 *elbv2.RegisterTargetsInput) (*elbv2.RegisterTargetsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RegisterTargets", arg0)
-	ret0, _ := ret[0].(*elbv2.RegisterTargetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RegisterTargets indicates an expected call of RegisterTargets.
-func (mr *MockELBV2APIMockRecorder) RegisterTargets(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTargets", reflect.TypeOf((*MockELBV2API)(nil).RegisterTargets), arg0)
-}
-
-// RegisterTargetsRequest mocks base method.
-func (m *MockELBV2API) RegisterTargetsRequest(arg0 *elbv2.RegisterTargetsInput) (*request.Request, *elbv2.RegisterTargetsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RegisterTargetsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.RegisterTargetsOutput)
-	return ret0, ret1
-}
-
-// RegisterTargetsRequest indicates an expected call of RegisterTargetsRequest.
-func (mr *MockELBV2APIMockRecorder) RegisterTargetsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTargetsRequest", reflect.TypeOf((*MockELBV2API)(nil).RegisterTargetsRequest), arg0)
-}
-
-// RegisterTargetsWithContext mocks base method.
-func (m *MockELBV2API) RegisterTargetsWithContext(arg0 context.Context, arg1 *elbv2.RegisterTargetsInput, arg2 ...request.Option) (*elbv2.RegisterTargetsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RegisterTargetsWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.RegisterTargetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RegisterTargetsWithContext indicates an expected call of RegisterTargetsWithContext.
-func (mr *MockELBV2APIMockRecorder) RegisterTargetsWithContext(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, "RegisterTargetsWithContext", reflect.TypeOf((*MockELBV2API)(nil).RegisterTargetsWithContext), varargs...)
-}
-
-// RemoveListenerCertificates mocks base method.
-func (m *MockELBV2API) RemoveListenerCertificates(arg0 *elbv2.RemoveListenerCertificatesInput) (*elbv2.RemoveListenerCertificatesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RemoveListenerCertificates", arg0)
-	ret0, _ := ret[0].(*elbv2.RemoveListenerCertificatesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RemoveListenerCertificates indicates an expected call of RemoveListenerCertificates.
-func (mr *MockELBV2APIMockRecorder) RemoveListenerCertificates(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveListenerCertificates", reflect.TypeOf((*MockELBV2API)(nil).RemoveListenerCertificates), arg0)
-}
-
-// RemoveListenerCertificatesRequest mocks base method.
-func (m *MockELBV2API) RemoveListenerCertificatesRequest(arg0 *elbv2.RemoveListenerCertificatesInput) (*request.Request, *elbv2.RemoveListenerCertificatesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RemoveListenerCertificatesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.RemoveListenerCertificatesOutput)
-	return ret0, ret1
-}
-
-// RemoveListenerCertificatesRequest indicates an expected call of RemoveListenerCertificatesRequest.
-func (mr *MockELBV2APIMockRecorder) RemoveListenerCertificatesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveListenerCertificatesRequest", reflect.TypeOf((*MockELBV2API)(nil).RemoveListenerCertificatesRequest), arg0)
-}
-
-// RemoveListenerCertificatesWithContext mocks base method.
-func (m *MockELBV2API) RemoveListenerCertificatesWithContext(arg0 context.Context, arg1 *elbv2.RemoveListenerCertificatesInput, arg2 ...request.Option) (*elbv2.RemoveListenerCertificatesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RemoveListenerCertificatesWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.RemoveListenerCertificatesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RemoveListenerCertificatesWithContext indicates an expected call of RemoveListenerCertificatesWithContext.
-func (mr *MockELBV2APIMockRecorder) RemoveListenerCertificatesWithContext(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, "RemoveListenerCertificatesWithContext", reflect.TypeOf((*MockELBV2API)(nil).RemoveListenerCertificatesWithContext), varargs...)
-}
-
-// RemoveTags mocks base method.
-func (m *MockELBV2API) RemoveTags(arg0 *elbv2.RemoveTagsInput) (*elbv2.RemoveTagsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RemoveTags", arg0)
-	ret0, _ := ret[0].(*elbv2.RemoveTagsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RemoveTags indicates an expected call of RemoveTags.
-func (mr *MockELBV2APIMockRecorder) RemoveTags(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTags", reflect.TypeOf((*MockELBV2API)(nil).RemoveTags), arg0)
-}
-
-// RemoveTagsRequest mocks base method.
-func (m *MockELBV2API) RemoveTagsRequest(arg0 *elbv2.RemoveTagsInput) (*request.Request, *elbv2.RemoveTagsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RemoveTagsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.RemoveTagsOutput)
-	return ret0, ret1
-}
-
-// RemoveTagsRequest indicates an expected call of RemoveTagsRequest.
-func (mr *MockELBV2APIMockRecorder) RemoveTagsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsRequest", reflect.TypeOf((*MockELBV2API)(nil).RemoveTagsRequest), arg0)
-}
-
-// RemoveTagsWithContext mocks base method.
-func (m *MockELBV2API) RemoveTagsWithContext(arg0 context.Context, arg1 *elbv2.RemoveTagsInput, arg2 ...request.Option) (*elbv2.RemoveTagsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RemoveTagsWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.RemoveTagsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RemoveTagsWithContext indicates an expected call of RemoveTagsWithContext.
-func (mr *MockELBV2APIMockRecorder) RemoveTagsWithContext(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, "RemoveTagsWithContext", reflect.TypeOf((*MockELBV2API)(nil).RemoveTagsWithContext), varargs...)
-}
-
-// RemoveTrustStoreRevocations mocks base method.
-func (m *MockELBV2API) RemoveTrustStoreRevocations(arg0 *elbv2.RemoveTrustStoreRevocationsInput) (*elbv2.RemoveTrustStoreRevocationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RemoveTrustStoreRevocations", arg0)
-	ret0, _ := ret[0].(*elbv2.RemoveTrustStoreRevocationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RemoveTrustStoreRevocations indicates an expected call of RemoveTrustStoreRevocations.
-func (mr *MockELBV2APIMockRecorder) RemoveTrustStoreRevocations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTrustStoreRevocations", reflect.TypeOf((*MockELBV2API)(nil).RemoveTrustStoreRevocations), arg0)
-}
-
-// RemoveTrustStoreRevocationsRequest mocks base method.
-func (m *MockELBV2API) RemoveTrustStoreRevocationsRequest(arg0 *elbv2.RemoveTrustStoreRevocationsInput) (*request.Request, *elbv2.RemoveTrustStoreRevocationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RemoveTrustStoreRevocationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.RemoveTrustStoreRevocationsOutput)
-	return ret0, ret1
-}
-
-// RemoveTrustStoreRevocationsRequest indicates an expected call of RemoveTrustStoreRevocationsRequest.
-func (mr *MockELBV2APIMockRecorder) RemoveTrustStoreRevocationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTrustStoreRevocationsRequest", reflect.TypeOf((*MockELBV2API)(nil).RemoveTrustStoreRevocationsRequest), arg0)
-}
-
-// RemoveTrustStoreRevocationsWithContext mocks base method.
-func (m *MockELBV2API) RemoveTrustStoreRevocationsWithContext(arg0 context.Context, arg1 *elbv2.RemoveTrustStoreRevocationsInput, arg2 ...request.Option) (*elbv2.RemoveTrustStoreRevocationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RemoveTrustStoreRevocationsWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.RemoveTrustStoreRevocationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RemoveTrustStoreRevocationsWithContext indicates an expected call of RemoveTrustStoreRevocationsWithContext.
-func (mr *MockELBV2APIMockRecorder) RemoveTrustStoreRevocationsWithContext(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, "RemoveTrustStoreRevocationsWithContext", reflect.TypeOf((*MockELBV2API)(nil).RemoveTrustStoreRevocationsWithContext), varargs...)
-}
-
-// SetIpAddressType mocks base method.
-func (m *MockELBV2API) SetIpAddressType(arg0 *elbv2.SetIpAddressTypeInput) (*elbv2.SetIpAddressTypeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetIpAddressType", arg0)
-	ret0, _ := ret[0].(*elbv2.SetIpAddressTypeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SetIpAddressType indicates an expected call of SetIpAddressType.
-func (mr *MockELBV2APIMockRecorder) SetIpAddressType(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIpAddressType", reflect.TypeOf((*MockELBV2API)(nil).SetIpAddressType), arg0)
-}
-
-// SetIpAddressTypeRequest mocks base method.
-func (m *MockELBV2API) SetIpAddressTypeRequest(arg0 *elbv2.SetIpAddressTypeInput) (*request.Request, *elbv2.SetIpAddressTypeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetIpAddressTypeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.SetIpAddressTypeOutput)
-	return ret0, ret1
-}
-
-// SetIpAddressTypeRequest indicates an expected call of SetIpAddressTypeRequest.
-func (mr *MockELBV2APIMockRecorder) SetIpAddressTypeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIpAddressTypeRequest", reflect.TypeOf((*MockELBV2API)(nil).SetIpAddressTypeRequest), arg0)
-}
-
-// SetIpAddressTypeWithContext mocks base method.
-func (m *MockELBV2API) SetIpAddressTypeWithContext(arg0 context.Context, arg1 *elbv2.SetIpAddressTypeInput, arg2 ...request.Option) (*elbv2.SetIpAddressTypeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SetIpAddressTypeWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.SetIpAddressTypeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SetIpAddressTypeWithContext indicates an expected call of SetIpAddressTypeWithContext.
-func (mr *MockELBV2APIMockRecorder) SetIpAddressTypeWithContext(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, "SetIpAddressTypeWithContext", reflect.TypeOf((*MockELBV2API)(nil).SetIpAddressTypeWithContext), varargs...)
-}
-
-// SetRulePriorities mocks base method.
-func (m *MockELBV2API) SetRulePriorities(arg0 *elbv2.SetRulePrioritiesInput) (*elbv2.SetRulePrioritiesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetRulePriorities", arg0)
-	ret0, _ := ret[0].(*elbv2.SetRulePrioritiesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SetRulePriorities indicates an expected call of SetRulePriorities.
-func (mr *MockELBV2APIMockRecorder) SetRulePriorities(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRulePriorities", reflect.TypeOf((*MockELBV2API)(nil).SetRulePriorities), arg0)
-}
-
-// SetRulePrioritiesRequest mocks base method.
-func (m *MockELBV2API) SetRulePrioritiesRequest(arg0 *elbv2.SetRulePrioritiesInput) (*request.Request, *elbv2.SetRulePrioritiesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetRulePrioritiesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.SetRulePrioritiesOutput)
-	return ret0, ret1
-}
-
-// SetRulePrioritiesRequest indicates an expected call of SetRulePrioritiesRequest.
-func (mr *MockELBV2APIMockRecorder) SetRulePrioritiesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRulePrioritiesRequest", reflect.TypeOf((*MockELBV2API)(nil).SetRulePrioritiesRequest), arg0)
-}
-
-// SetRulePrioritiesWithContext mocks base method.
-func (m *MockELBV2API) SetRulePrioritiesWithContext(arg0 context.Context, arg1 *elbv2.SetRulePrioritiesInput, arg2 ...request.Option) (*elbv2.SetRulePrioritiesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SetRulePrioritiesWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.SetRulePrioritiesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SetRulePrioritiesWithContext indicates an expected call of SetRulePrioritiesWithContext.
-func (mr *MockELBV2APIMockRecorder) SetRulePrioritiesWithContext(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, "SetRulePrioritiesWithContext", reflect.TypeOf((*MockELBV2API)(nil).SetRulePrioritiesWithContext), varargs...)
-}
-
-// SetSecurityGroups mocks base method.
-func (m *MockELBV2API) SetSecurityGroups(arg0 *elbv2.SetSecurityGroupsInput) (*elbv2.SetSecurityGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetSecurityGroups", arg0)
-	ret0, _ := ret[0].(*elbv2.SetSecurityGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SetSecurityGroups indicates an expected call of SetSecurityGroups.
-func (mr *MockELBV2APIMockRecorder) SetSecurityGroups(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSecurityGroups", reflect.TypeOf((*MockELBV2API)(nil).SetSecurityGroups), arg0)
-}
-
-// SetSecurityGroupsRequest mocks base method.
-func (m *MockELBV2API) SetSecurityGroupsRequest(arg0 *elbv2.SetSecurityGroupsInput) (*request.Request, *elbv2.SetSecurityGroupsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetSecurityGroupsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.SetSecurityGroupsOutput)
-	return ret0, ret1
-}
-
-// SetSecurityGroupsRequest indicates an expected call of SetSecurityGroupsRequest.
-func (mr *MockELBV2APIMockRecorder) SetSecurityGroupsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSecurityGroupsRequest", reflect.TypeOf((*MockELBV2API)(nil).SetSecurityGroupsRequest), arg0)
-}
-
-// SetSecurityGroupsWithContext mocks base method.
-func (m *MockELBV2API) SetSecurityGroupsWithContext(arg0 context.Context, arg1 *elbv2.SetSecurityGroupsInput, arg2 ...request.Option) (*elbv2.SetSecurityGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SetSecurityGroupsWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.SetSecurityGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SetSecurityGroupsWithContext indicates an expected call of SetSecurityGroupsWithContext.
-func (mr *MockELBV2APIMockRecorder) SetSecurityGroupsWithContext(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, "SetSecurityGroupsWithContext", reflect.TypeOf((*MockELBV2API)(nil).SetSecurityGroupsWithContext), varargs...)
-}
-
-// SetSubnets mocks base method.
-func (m *MockELBV2API) SetSubnets(arg0 *elbv2.SetSubnetsInput) (*elbv2.SetSubnetsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetSubnets", arg0)
-	ret0, _ := ret[0].(*elbv2.SetSubnetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SetSubnets indicates an expected call of SetSubnets.
-func (mr *MockELBV2APIMockRecorder) SetSubnets(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSubnets", reflect.TypeOf((*MockELBV2API)(nil).SetSubnets), arg0)
-}
-
-// SetSubnetsRequest mocks base method.
-func (m *MockELBV2API) SetSubnetsRequest(arg0 *elbv2.SetSubnetsInput) (*request.Request, *elbv2.SetSubnetsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetSubnetsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*elbv2.SetSubnetsOutput)
-	return ret0, ret1
-}
-
-// SetSubnetsRequest indicates an expected call of SetSubnetsRequest.
-func (mr *MockELBV2APIMockRecorder) SetSubnetsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSubnetsRequest", reflect.TypeOf((*MockELBV2API)(nil).SetSubnetsRequest), arg0)
-}
-
-// SetSubnetsWithContext mocks base method.
-func (m *MockELBV2API) SetSubnetsWithContext(arg0 context.Context, arg1 *elbv2.SetSubnetsInput, arg2 ...request.Option) (*elbv2.SetSubnetsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SetSubnetsWithContext", varargs...)
-	ret0, _ := ret[0].(*elbv2.SetSubnetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SetSubnetsWithContext indicates an expected call of SetSubnetsWithContext.
-func (mr *MockELBV2APIMockRecorder) SetSubnetsWithContext(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, "SetSubnetsWithContext", reflect.TypeOf((*MockELBV2API)(nil).SetSubnetsWithContext), varargs...)
-}
-
-// WaitUntilLoadBalancerAvailable mocks base method.
-func (m *MockELBV2API) WaitUntilLoadBalancerAvailable(arg0 *elbv2.DescribeLoadBalancersInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilLoadBalancerAvailable", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilLoadBalancerAvailable indicates an expected call of WaitUntilLoadBalancerAvailable.
-func (mr *MockELBV2APIMockRecorder) WaitUntilLoadBalancerAvailable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilLoadBalancerAvailable", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilLoadBalancerAvailable), arg0)
-}
-
-// WaitUntilLoadBalancerAvailableWithContext mocks base method.
-func (m *MockELBV2API) WaitUntilLoadBalancerAvailableWithContext(arg0 context.Context, arg1 *elbv2.DescribeLoadBalancersInput, 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, "WaitUntilLoadBalancerAvailableWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilLoadBalancerAvailableWithContext indicates an expected call of WaitUntilLoadBalancerAvailableWithContext.
-func (mr *MockELBV2APIMockRecorder) WaitUntilLoadBalancerAvailableWithContext(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, "WaitUntilLoadBalancerAvailableWithContext", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilLoadBalancerAvailableWithContext), varargs...)
-}
-
-// WaitUntilLoadBalancerExists mocks base method.
-func (m *MockELBV2API) WaitUntilLoadBalancerExists(arg0 *elbv2.DescribeLoadBalancersInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilLoadBalancerExists", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilLoadBalancerExists indicates an expected call of WaitUntilLoadBalancerExists.
-func (mr *MockELBV2APIMockRecorder) WaitUntilLoadBalancerExists(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilLoadBalancerExists", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilLoadBalancerExists), arg0)
-}
-
-// WaitUntilLoadBalancerExistsWithContext mocks base method.
-func (m *MockELBV2API) WaitUntilLoadBalancerExistsWithContext(arg0 context.Context, arg1 *elbv2.DescribeLoadBalancersInput, 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, "WaitUntilLoadBalancerExistsWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilLoadBalancerExistsWithContext indicates an expected call of WaitUntilLoadBalancerExistsWithContext.
-func (mr *MockELBV2APIMockRecorder) WaitUntilLoadBalancerExistsWithContext(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, "WaitUntilLoadBalancerExistsWithContext", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilLoadBalancerExistsWithContext), varargs...)
-}
-
-// WaitUntilLoadBalancersDeleted mocks base method.
-func (m *MockELBV2API) WaitUntilLoadBalancersDeleted(arg0 *elbv2.DescribeLoadBalancersInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilLoadBalancersDeleted", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilLoadBalancersDeleted indicates an expected call of WaitUntilLoadBalancersDeleted.
-func (mr *MockELBV2APIMockRecorder) WaitUntilLoadBalancersDeleted(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilLoadBalancersDeleted", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilLoadBalancersDeleted), arg0)
-}
-
-// WaitUntilLoadBalancersDeletedWithContext mocks base method.
-func (m *MockELBV2API) WaitUntilLoadBalancersDeletedWithContext(arg0 context.Context, arg1 *elbv2.DescribeLoadBalancersInput, 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, "WaitUntilLoadBalancersDeletedWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilLoadBalancersDeletedWithContext indicates an expected call of WaitUntilLoadBalancersDeletedWithContext.
-func (mr *MockELBV2APIMockRecorder) WaitUntilLoadBalancersDeletedWithContext(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, "WaitUntilLoadBalancersDeletedWithContext", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilLoadBalancersDeletedWithContext), varargs...)
-}
-
-// WaitUntilTargetDeregistered mocks base method.
-func (m *MockELBV2API) WaitUntilTargetDeregistered(arg0 *elbv2.DescribeTargetHealthInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilTargetDeregistered", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilTargetDeregistered indicates an expected call of WaitUntilTargetDeregistered.
-func (mr *MockELBV2APIMockRecorder) WaitUntilTargetDeregistered(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTargetDeregistered", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilTargetDeregistered), arg0)
-}
-
-// WaitUntilTargetDeregisteredWithContext mocks base method.
-func (m *MockELBV2API) WaitUntilTargetDeregisteredWithContext(arg0 context.Context, arg1 *elbv2.DescribeTargetHealthInput, 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, "WaitUntilTargetDeregisteredWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilTargetDeregisteredWithContext indicates an expected call of WaitUntilTargetDeregisteredWithContext.
-func (mr *MockELBV2APIMockRecorder) WaitUntilTargetDeregisteredWithContext(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, "WaitUntilTargetDeregisteredWithContext", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilTargetDeregisteredWithContext), varargs...)
-}
-
-// WaitUntilTargetInService mocks base method.
-func (m *MockELBV2API) WaitUntilTargetInService(arg0 *elbv2.DescribeTargetHealthInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilTargetInService", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilTargetInService indicates an expected call of WaitUntilTargetInService.
-func (mr *MockELBV2APIMockRecorder) WaitUntilTargetInService(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTargetInService", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilTargetInService), arg0)
-}
-
-// WaitUntilTargetInServiceWithContext mocks base method.
-func (m *MockELBV2API) WaitUntilTargetInServiceWithContext(arg0 context.Context, arg1 *elbv2.DescribeTargetHealthInput, 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, "WaitUntilTargetInServiceWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilTargetInServiceWithContext indicates an expected call of WaitUntilTargetInServiceWithContext.
-func (mr *MockELBV2APIMockRecorder) WaitUntilTargetInServiceWithContext(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, "WaitUntilTargetInServiceWithContext", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilTargetInServiceWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilLoadBalancerAvailable", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilLoadBalancerAvailable), arg0, arg1, arg2)
 }
diff --git a/test/mocks/aws_rgtagging_mock.go b/test/mocks/aws_rgtagging_mock.go
index af231eccb..ce5ee4e47 100644
--- a/test/mocks/aws_rgtagging_mock.go
+++ b/test/mocks/aws_rgtagging_mock.go
@@ -15,7 +15,7 @@ limitations under the License.
 */
 
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi/resourcegroupstaggingapiiface (interfaces: ResourceGroupsTaggingAPIAPI)
+// Source: sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/elb (interfaces: ResourceGroupsTaggingAPIAPI)
 
 // Package mocks is a generated GoMock package.
 package mocks
@@ -24,8 +24,7 @@ import (
 	context "context"
 	reflect "reflect"
 
-	request "github.com/aws/aws-sdk-go/aws/request"
-	resourcegroupstaggingapi "github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi"
+	resourcegroupstaggingapi "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi"
 	gomock "github.com/golang/mock/gomock"
 )
 
@@ -52,534 +51,36 @@ func (m *MockResourceGroupsTaggingAPIAPI) EXPECT() *MockResourceGroupsTaggingAPI
 	return m.recorder
 }
 
-// DescribeReportCreation mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) DescribeReportCreation(arg0 *resourcegroupstaggingapi.DescribeReportCreationInput) (*resourcegroupstaggingapi.DescribeReportCreationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeReportCreation", arg0)
-	ret0, _ := ret[0].(*resourcegroupstaggingapi.DescribeReportCreationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeReportCreation indicates an expected call of DescribeReportCreation.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) DescribeReportCreation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReportCreation", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).DescribeReportCreation), arg0)
-}
-
-// DescribeReportCreationRequest mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) DescribeReportCreationRequest(arg0 *resourcegroupstaggingapi.DescribeReportCreationInput) (*request.Request, *resourcegroupstaggingapi.DescribeReportCreationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeReportCreationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*resourcegroupstaggingapi.DescribeReportCreationOutput)
-	return ret0, ret1
-}
-
-// DescribeReportCreationRequest indicates an expected call of DescribeReportCreationRequest.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) DescribeReportCreationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReportCreationRequest", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).DescribeReportCreationRequest), arg0)
-}
-
-// DescribeReportCreationWithContext mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) DescribeReportCreationWithContext(arg0 context.Context, arg1 *resourcegroupstaggingapi.DescribeReportCreationInput, arg2 ...request.Option) (*resourcegroupstaggingapi.DescribeReportCreationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeReportCreationWithContext", varargs...)
-	ret0, _ := ret[0].(*resourcegroupstaggingapi.DescribeReportCreationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeReportCreationWithContext indicates an expected call of DescribeReportCreationWithContext.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) DescribeReportCreationWithContext(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, "DescribeReportCreationWithContext", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).DescribeReportCreationWithContext), varargs...)
-}
-
-// GetComplianceSummary mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) GetComplianceSummary(arg0 *resourcegroupstaggingapi.GetComplianceSummaryInput) (*resourcegroupstaggingapi.GetComplianceSummaryOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetComplianceSummary", arg0)
-	ret0, _ := ret[0].(*resourcegroupstaggingapi.GetComplianceSummaryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetComplianceSummary indicates an expected call of GetComplianceSummary.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) GetComplianceSummary(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComplianceSummary", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).GetComplianceSummary), arg0)
-}
-
-// GetComplianceSummaryPages mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) GetComplianceSummaryPages(arg0 *resourcegroupstaggingapi.GetComplianceSummaryInput, arg1 func(*resourcegroupstaggingapi.GetComplianceSummaryOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetComplianceSummaryPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetComplianceSummaryPages indicates an expected call of GetComplianceSummaryPages.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) GetComplianceSummaryPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComplianceSummaryPages", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).GetComplianceSummaryPages), arg0, arg1)
-}
-
-// GetComplianceSummaryPagesWithContext mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) GetComplianceSummaryPagesWithContext(arg0 context.Context, arg1 *resourcegroupstaggingapi.GetComplianceSummaryInput, arg2 func(*resourcegroupstaggingapi.GetComplianceSummaryOutput, 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, "GetComplianceSummaryPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetComplianceSummaryPagesWithContext indicates an expected call of GetComplianceSummaryPagesWithContext.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) GetComplianceSummaryPagesWithContext(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, "GetComplianceSummaryPagesWithContext", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).GetComplianceSummaryPagesWithContext), varargs...)
-}
-
-// GetComplianceSummaryRequest mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) GetComplianceSummaryRequest(arg0 *resourcegroupstaggingapi.GetComplianceSummaryInput) (*request.Request, *resourcegroupstaggingapi.GetComplianceSummaryOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetComplianceSummaryRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*resourcegroupstaggingapi.GetComplianceSummaryOutput)
-	return ret0, ret1
-}
-
-// GetComplianceSummaryRequest indicates an expected call of GetComplianceSummaryRequest.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) GetComplianceSummaryRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComplianceSummaryRequest", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).GetComplianceSummaryRequest), arg0)
-}
-
-// GetComplianceSummaryWithContext mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) GetComplianceSummaryWithContext(arg0 context.Context, arg1 *resourcegroupstaggingapi.GetComplianceSummaryInput, arg2 ...request.Option) (*resourcegroupstaggingapi.GetComplianceSummaryOutput, error) {
+// GetResources mocks base method.
+func (m *MockResourceGroupsTaggingAPIAPI) GetResources(arg0 context.Context, arg1 *resourcegroupstaggingapi.GetResourcesInput, arg2 ...func(*resourcegroupstaggingapi.Options)) (*resourcegroupstaggingapi.GetResourcesOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "GetComplianceSummaryWithContext", varargs...)
-	ret0, _ := ret[0].(*resourcegroupstaggingapi.GetComplianceSummaryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetComplianceSummaryWithContext indicates an expected call of GetComplianceSummaryWithContext.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) GetComplianceSummaryWithContext(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, "GetComplianceSummaryWithContext", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).GetComplianceSummaryWithContext), varargs...)
-}
-
-// GetResources mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) GetResources(arg0 *resourcegroupstaggingapi.GetResourcesInput) (*resourcegroupstaggingapi.GetResourcesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetResources", arg0)
+	ret := m.ctrl.Call(m, "GetResources", varargs...)
 	ret0, _ := ret[0].(*resourcegroupstaggingapi.GetResourcesOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // GetResources indicates an expected call of GetResources.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) GetResources(arg0 interface{}) *gomock.Call {
+func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) GetResources(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResources", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).GetResources), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResources", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).GetResources), varargs...)
 }
 
 // GetResourcesPages mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) GetResourcesPages(arg0 *resourcegroupstaggingapi.GetResourcesInput, arg1 func(*resourcegroupstaggingapi.GetResourcesOutput, bool) bool) error {
+func (m *MockResourceGroupsTaggingAPIAPI) GetResourcesPages(arg0 context.Context, arg1 *resourcegroupstaggingapi.GetResourcesInput, arg2 func(*resourcegroupstaggingapi.GetResourcesOutput)) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetResourcesPages", arg0, arg1)
+	ret := m.ctrl.Call(m, "GetResourcesPages", arg0, arg1, arg2)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // GetResourcesPages indicates an expected call of GetResourcesPages.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) GetResourcesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourcesPages", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).GetResourcesPages), arg0, arg1)
-}
-
-// GetResourcesPagesWithContext mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) GetResourcesPagesWithContext(arg0 context.Context, arg1 *resourcegroupstaggingapi.GetResourcesInput, arg2 func(*resourcegroupstaggingapi.GetResourcesOutput, 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, "GetResourcesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetResourcesPagesWithContext indicates an expected call of GetResourcesPagesWithContext.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) GetResourcesPagesWithContext(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, "GetResourcesPagesWithContext", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).GetResourcesPagesWithContext), varargs...)
-}
-
-// GetResourcesRequest mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) GetResourcesRequest(arg0 *resourcegroupstaggingapi.GetResourcesInput) (*request.Request, *resourcegroupstaggingapi.GetResourcesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetResourcesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*resourcegroupstaggingapi.GetResourcesOutput)
-	return ret0, ret1
-}
-
-// GetResourcesRequest indicates an expected call of GetResourcesRequest.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) GetResourcesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourcesRequest", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).GetResourcesRequest), arg0)
-}
-
-// GetResourcesWithContext mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) GetResourcesWithContext(arg0 context.Context, arg1 *resourcegroupstaggingapi.GetResourcesInput, arg2 ...request.Option) (*resourcegroupstaggingapi.GetResourcesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetResourcesWithContext", varargs...)
-	ret0, _ := ret[0].(*resourcegroupstaggingapi.GetResourcesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetResourcesWithContext indicates an expected call of GetResourcesWithContext.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) GetResourcesWithContext(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, "GetResourcesWithContext", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).GetResourcesWithContext), varargs...)
-}
-
-// GetTagKeys mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) GetTagKeys(arg0 *resourcegroupstaggingapi.GetTagKeysInput) (*resourcegroupstaggingapi.GetTagKeysOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTagKeys", arg0)
-	ret0, _ := ret[0].(*resourcegroupstaggingapi.GetTagKeysOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetTagKeys indicates an expected call of GetTagKeys.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) GetTagKeys(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTagKeys", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).GetTagKeys), arg0)
-}
-
-// GetTagKeysPages mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) GetTagKeysPages(arg0 *resourcegroupstaggingapi.GetTagKeysInput, arg1 func(*resourcegroupstaggingapi.GetTagKeysOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTagKeysPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetTagKeysPages indicates an expected call of GetTagKeysPages.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) GetTagKeysPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTagKeysPages", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).GetTagKeysPages), arg0, arg1)
-}
-
-// GetTagKeysPagesWithContext mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) GetTagKeysPagesWithContext(arg0 context.Context, arg1 *resourcegroupstaggingapi.GetTagKeysInput, arg2 func(*resourcegroupstaggingapi.GetTagKeysOutput, 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, "GetTagKeysPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetTagKeysPagesWithContext indicates an expected call of GetTagKeysPagesWithContext.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) GetTagKeysPagesWithContext(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, "GetTagKeysPagesWithContext", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).GetTagKeysPagesWithContext), varargs...)
-}
-
-// GetTagKeysRequest mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) GetTagKeysRequest(arg0 *resourcegroupstaggingapi.GetTagKeysInput) (*request.Request, *resourcegroupstaggingapi.GetTagKeysOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTagKeysRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*resourcegroupstaggingapi.GetTagKeysOutput)
-	return ret0, ret1
-}
-
-// GetTagKeysRequest indicates an expected call of GetTagKeysRequest.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) GetTagKeysRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTagKeysRequest", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).GetTagKeysRequest), arg0)
-}
-
-// GetTagKeysWithContext mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) GetTagKeysWithContext(arg0 context.Context, arg1 *resourcegroupstaggingapi.GetTagKeysInput, arg2 ...request.Option) (*resourcegroupstaggingapi.GetTagKeysOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetTagKeysWithContext", varargs...)
-	ret0, _ := ret[0].(*resourcegroupstaggingapi.GetTagKeysOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetTagKeysWithContext indicates an expected call of GetTagKeysWithContext.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) GetTagKeysWithContext(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, "GetTagKeysWithContext", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).GetTagKeysWithContext), varargs...)
-}
-
-// GetTagValues mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) GetTagValues(arg0 *resourcegroupstaggingapi.GetTagValuesInput) (*resourcegroupstaggingapi.GetTagValuesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTagValues", arg0)
-	ret0, _ := ret[0].(*resourcegroupstaggingapi.GetTagValuesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetTagValues indicates an expected call of GetTagValues.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) GetTagValues(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTagValues", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).GetTagValues), arg0)
-}
-
-// GetTagValuesPages mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) GetTagValuesPages(arg0 *resourcegroupstaggingapi.GetTagValuesInput, arg1 func(*resourcegroupstaggingapi.GetTagValuesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTagValuesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetTagValuesPages indicates an expected call of GetTagValuesPages.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) GetTagValuesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTagValuesPages", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).GetTagValuesPages), arg0, arg1)
-}
-
-// GetTagValuesPagesWithContext mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) GetTagValuesPagesWithContext(arg0 context.Context, arg1 *resourcegroupstaggingapi.GetTagValuesInput, arg2 func(*resourcegroupstaggingapi.GetTagValuesOutput, 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, "GetTagValuesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetTagValuesPagesWithContext indicates an expected call of GetTagValuesPagesWithContext.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) GetTagValuesPagesWithContext(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, "GetTagValuesPagesWithContext", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).GetTagValuesPagesWithContext), varargs...)
-}
-
-// GetTagValuesRequest mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) GetTagValuesRequest(arg0 *resourcegroupstaggingapi.GetTagValuesInput) (*request.Request, *resourcegroupstaggingapi.GetTagValuesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTagValuesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*resourcegroupstaggingapi.GetTagValuesOutput)
-	return ret0, ret1
-}
-
-// GetTagValuesRequest indicates an expected call of GetTagValuesRequest.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) GetTagValuesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTagValuesRequest", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).GetTagValuesRequest), arg0)
-}
-
-// GetTagValuesWithContext mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) GetTagValuesWithContext(arg0 context.Context, arg1 *resourcegroupstaggingapi.GetTagValuesInput, arg2 ...request.Option) (*resourcegroupstaggingapi.GetTagValuesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetTagValuesWithContext", varargs...)
-	ret0, _ := ret[0].(*resourcegroupstaggingapi.GetTagValuesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetTagValuesWithContext indicates an expected call of GetTagValuesWithContext.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) GetTagValuesWithContext(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, "GetTagValuesWithContext", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).GetTagValuesWithContext), varargs...)
-}
-
-// StartReportCreation mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) StartReportCreation(arg0 *resourcegroupstaggingapi.StartReportCreationInput) (*resourcegroupstaggingapi.StartReportCreationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StartReportCreation", arg0)
-	ret0, _ := ret[0].(*resourcegroupstaggingapi.StartReportCreationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StartReportCreation indicates an expected call of StartReportCreation.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) StartReportCreation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartReportCreation", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).StartReportCreation), arg0)
-}
-
-// StartReportCreationRequest mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) StartReportCreationRequest(arg0 *resourcegroupstaggingapi.StartReportCreationInput) (*request.Request, *resourcegroupstaggingapi.StartReportCreationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StartReportCreationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*resourcegroupstaggingapi.StartReportCreationOutput)
-	return ret0, ret1
-}
-
-// StartReportCreationRequest indicates an expected call of StartReportCreationRequest.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) StartReportCreationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartReportCreationRequest", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).StartReportCreationRequest), arg0)
-}
-
-// StartReportCreationWithContext mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) StartReportCreationWithContext(arg0 context.Context, arg1 *resourcegroupstaggingapi.StartReportCreationInput, arg2 ...request.Option) (*resourcegroupstaggingapi.StartReportCreationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "StartReportCreationWithContext", varargs...)
-	ret0, _ := ret[0].(*resourcegroupstaggingapi.StartReportCreationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StartReportCreationWithContext indicates an expected call of StartReportCreationWithContext.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) StartReportCreationWithContext(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, "StartReportCreationWithContext", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).StartReportCreationWithContext), varargs...)
-}
-
-// TagResources mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) TagResources(arg0 *resourcegroupstaggingapi.TagResourcesInput) (*resourcegroupstaggingapi.TagResourcesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "TagResources", arg0)
-	ret0, _ := ret[0].(*resourcegroupstaggingapi.TagResourcesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// TagResources indicates an expected call of TagResources.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) TagResources(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResources", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).TagResources), arg0)
-}
-
-// TagResourcesRequest mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) TagResourcesRequest(arg0 *resourcegroupstaggingapi.TagResourcesInput) (*request.Request, *resourcegroupstaggingapi.TagResourcesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "TagResourcesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*resourcegroupstaggingapi.TagResourcesOutput)
-	return ret0, ret1
-}
-
-// TagResourcesRequest indicates an expected call of TagResourcesRequest.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) TagResourcesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourcesRequest", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).TagResourcesRequest), arg0)
-}
-
-// TagResourcesWithContext mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) TagResourcesWithContext(arg0 context.Context, arg1 *resourcegroupstaggingapi.TagResourcesInput, arg2 ...request.Option) (*resourcegroupstaggingapi.TagResourcesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "TagResourcesWithContext", varargs...)
-	ret0, _ := ret[0].(*resourcegroupstaggingapi.TagResourcesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// TagResourcesWithContext indicates an expected call of TagResourcesWithContext.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) TagResourcesWithContext(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, "TagResourcesWithContext", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).TagResourcesWithContext), varargs...)
-}
-
-// UntagResources mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) UntagResources(arg0 *resourcegroupstaggingapi.UntagResourcesInput) (*resourcegroupstaggingapi.UntagResourcesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UntagResources", arg0)
-	ret0, _ := ret[0].(*resourcegroupstaggingapi.UntagResourcesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UntagResources indicates an expected call of UntagResources.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) UntagResources(arg0 interface{}) *gomock.Call {
+func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) GetResourcesPages(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResources", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).UntagResources), arg0)
-}
-
-// UntagResourcesRequest mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) UntagResourcesRequest(arg0 *resourcegroupstaggingapi.UntagResourcesInput) (*request.Request, *resourcegroupstaggingapi.UntagResourcesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UntagResourcesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*resourcegroupstaggingapi.UntagResourcesOutput)
-	return ret0, ret1
-}
-
-// UntagResourcesRequest indicates an expected call of UntagResourcesRequest.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) UntagResourcesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourcesRequest", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).UntagResourcesRequest), arg0)
-}
-
-// UntagResourcesWithContext mocks base method.
-func (m *MockResourceGroupsTaggingAPIAPI) UntagResourcesWithContext(arg0 context.Context, arg1 *resourcegroupstaggingapi.UntagResourcesInput, arg2 ...request.Option) (*resourcegroupstaggingapi.UntagResourcesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "UntagResourcesWithContext", varargs...)
-	ret0, _ := ret[0].(*resourcegroupstaggingapi.UntagResourcesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UntagResourcesWithContext indicates an expected call of UntagResourcesWithContext.
-func (mr *MockResourceGroupsTaggingAPIAPIMockRecorder) UntagResourcesWithContext(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, "UntagResourcesWithContext", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).UntagResourcesWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourcesPages", reflect.TypeOf((*MockResourceGroupsTaggingAPIAPI)(nil).GetResourcesPages), arg0, arg1, arg2)
 }
diff --git a/test/mocks/capa_clusterscoper_mock.go b/test/mocks/capa_clusterscoper_mock.go
index 42e916a9a..2a45045bf 100644
--- a/test/mocks/capa_clusterscoper_mock.go
+++ b/test/mocks/capa_clusterscoper_mock.go
@@ -22,6 +22,7 @@ package mocks
 
 import (
 	reflect "reflect"
+	time "time"
 
 	aws "github.com/aws/aws-sdk-go-v2/aws"
 	client "github.com/aws/aws-sdk-go/aws/client"
@@ -279,6 +280,20 @@ func (mr *MockClusterScoperMockRecorder) ListOptionsLabelSelector() *gomock.Call
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOptionsLabelSelector", reflect.TypeOf((*MockClusterScoper)(nil).ListOptionsLabelSelector))
 }
 
+// MaxWaitDuration mocks base method.
+func (m *MockClusterScoper) MaxWaitDuration() time.Duration {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MaxWaitDuration")
+	ret0, _ := ret[0].(time.Duration)
+	return ret0
+}
+
+// MaxWaitDuration indicates an expected call of MaxWaitDuration.
+func (mr *MockClusterScoperMockRecorder) MaxWaitDuration() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MaxWaitDuration", reflect.TypeOf((*MockClusterScoper)(nil).MaxWaitDuration))
+}
+
 // Name mocks base method.
 func (m *MockClusterScoper) Name() string {
 	m.ctrl.T.Helper()
diff --git a/test/mocks/generate_aws.go b/test/mocks/generate_aws.go
index f3b08973e..8f8477cc0 100644
--- a/test/mocks/generate_aws.go
+++ b/test/mocks/generate_aws.go
@@ -16,11 +16,11 @@ limitations under the License.
 
 // Package mocks provides a way to generate mock objects for AWS services.
 //
-//go:generate ../../hack/tools/bin/mockgen -destination aws_elbv2_mock.go -package mocks github.com/aws/aws-sdk-go/service/elbv2/elbv2iface ELBV2API
+//go:generate ../../hack/tools/bin/mockgen -destination aws_elbv2_mock.go -package mocks sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/elb ELBV2API
 //go:generate /usr/bin/env bash -c "cat ../../hack/boilerplate/boilerplate.generatego.txt aws_elbv2_mock.go > _aws_elbv2_mock.go && mv _aws_elbv2_mock.go aws_elbv2_mock.go"
-//go:generate ../../hack/tools/bin/mockgen -destination aws_elb_mock.go -package mocks github.com/aws/aws-sdk-go/service/elb/elbiface ELBAPI
+//go:generate ../../hack/tools/bin/mockgen -destination aws_elb_mock.go -package mocks sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/elb ELBAPI
 //go:generate /usr/bin/env bash -c "cat ../../hack/boilerplate/boilerplate.generatego.txt aws_elb_mock.go > _aws_elb_mock.go && mv _aws_elb_mock.go aws_elb_mock.go"
-//go:generate ../../hack/tools/bin/mockgen -destination aws_rgtagging_mock.go -package mocks github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi/resourcegroupstaggingapiiface ResourceGroupsTaggingAPIAPI
+//go:generate ../../hack/tools/bin/mockgen -destination aws_rgtagging_mock.go -package mocks sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/elb ResourceGroupsTaggingAPIAPI
 //go:generate /usr/bin/env bash -c "cat ../../hack/boilerplate/boilerplate.generatego.txt aws_rgtagging_mock.go > _aws_rgtagging_mock.go && mv _aws_rgtagging_mock.go aws_rgtagging_mock.go"
 //go:generate ../../hack/tools/bin/mockgen -destination aws_ec2api_mock.go -package mocks github.com/aws/aws-sdk-go/service/ec2/ec2iface EC2API
 //go:generate /usr/bin/env bash -c "cat ../../hack/boilerplate/boilerplate.generatego.txt aws_ec2api_mock.go > _aws_ec2api_mock.go && mv _aws_ec2api_mock.go aws_ec2api_mock.go"