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

Issue:
Migrate ec2 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_ec2api_mock.go
./pkg/cloud/scope/ec2.go
./pkg/cloud/filter/ec2.go
./pkg/cloud/services/mock_services/ec2_interface_mock.go
./pkg/cloud/services/gc/ec2.go
./pkg/cloud/services/instancestate/ec2events.go
./pkg/cloud/services/ec2
```

Hints from issue comments:
@damdo: See examples on how to migrate here: https://github.com/kubernetes-sigs/cluster-api-provider-aws/pull/5389@yiannistri: /assign

Solution patch:
diff --git a/api/v1beta2/network_types.go b/api/v1beta2/network_types.go
index 00a775a54..0a27a1c4d 100644
--- a/api/v1beta2/network_types.go
+++ b/api/v1beta2/network_types.go
@@ -21,8 +21,8 @@ import (
 	"sort"
 	"time"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"k8s.io/utils/ptr"
 )
 
@@ -667,11 +667,11 @@ func (s *SubnetSpec) IsEdgeWavelength() bool {
 }
 
 // SetZoneInfo updates the subnets with zone information.
-func (s *SubnetSpec) SetZoneInfo(zones []*ec2.AvailabilityZone) error {
-	zoneInfo := func(zoneName string) *ec2.AvailabilityZone {
+func (s *SubnetSpec) SetZoneInfo(zones []types.AvailabilityZone) error {
+	zoneInfo := func(zoneName string) *types.AvailabilityZone {
 		for _, zone := range zones {
 			if aws.StringValue(zone.ZoneName) == zoneName {
-				return zone
+				return &zone
 			}
 		}
 		return nil
@@ -826,7 +826,7 @@ func (s Subnets) GetUniqueZones() []string {
 }
 
 // SetZoneInfo updates the subnets with zone information.
-func (s Subnets) SetZoneInfo(zones []*ec2.AvailabilityZone) error {
+func (s Subnets) SetZoneInfo(zones []types.AvailabilityZone) error {
 	for i := range s {
 		if err := s[i].SetZoneInfo(zones); err != nil {
 			return err
diff --git a/cmd/clusterawsadm/ami/copy.go b/cmd/clusterawsadm/ami/copy.go
index d573c8c80..142b50dff 100644
--- a/cmd/clusterawsadm/ami/copy.go
+++ b/cmd/clusterawsadm/ami/copy.go
@@ -17,13 +17,15 @@ limitations under the License.
 package ami
 
 import (
+	"context"
 	"fmt"
 	"strconv"
 	"time"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/service/ec2"
+	"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"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/go-logr/logr"
 	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -48,14 +50,11 @@ type CopyInput struct {
 
 // Copy will create an AWSAMI from a CopyInput.
 func Copy(input CopyInput) (*amiv1.AWSAMI, error) {
-	sourceSession, err := session.NewSessionWithOptions(session.Options{
-		SharedConfigState: session.SharedConfigEnable,
-		Config:            aws.Config{Region: aws.String(input.SourceRegion)},
-	})
+	sourceCfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion(input.SourceRegion))
 	if err != nil {
 		return nil, err
 	}
-	ec2Client := ec2.New(sourceSession)
+	ec2Client := ec2.NewFromConfig(sourceCfg)
 
 	image, err := ec2service.DefaultAMILookup(ec2Client, input.OwnerID, input.OperatingSystem, input.KubernetesVersion, ec2service.Amd64ArchitectureTag, "")
 	if err != nil {
@@ -64,10 +63,7 @@ func Copy(input CopyInput) (*amiv1.AWSAMI, error) {
 
 	var newImageID, newImageName string
 
-	destSession, err := session.NewSessionWithOptions(session.Options{
-		SharedConfigState: session.SharedConfigEnable,
-		Config:            aws.Config{Region: aws.String(input.DestinationRegion)},
-	})
+	destCfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion(input.DestinationRegion))
 	if err != nil {
 		return nil, err
 	}
@@ -79,7 +75,7 @@ func Copy(input CopyInput) (*amiv1.AWSAMI, error) {
 			destinationRegion: input.DestinationRegion,
 			encrypted:         input.Encrypted,
 			kmsKeyID:          input.KmsKeyID,
-			sess:              destSession,
+			cfg:               destCfg,
 			log:               input.Log,
 		})
 	} else {
@@ -87,7 +83,7 @@ func Copy(input CopyInput) (*amiv1.AWSAMI, error) {
 			sourceRegion: input.SourceRegion,
 			image:        image,
 			dryRun:       input.DryRun,
-			sess:         destSession,
+			cfg:          destCfg,
 			log:          input.Log,
 		})
 	}
@@ -113,9 +109,7 @@ func Copy(input CopyInput) (*amiv1.AWSAMI, error) {
 		},
 	}
 
-	if err == nil {
-		input.Log.Info("Completed!")
-	}
+	input.Log.Info("Completed!")
 
 	return &ami, err
 }
@@ -124,13 +118,13 @@ type copyWithoutSnapshotInput struct {
 	sourceRegion string
 	dryRun       bool
 	log          logr.Logger
-	sess         *session.Session
-	image        *ec2.Image
+	cfg          aws.Config
+	image        *types.Image
 }
 
 func copyWithoutSnapshot(input copyWithoutSnapshotInput) (string, string, error) {
-	imgName := aws.StringValue(input.image.Name)
-	ec2Client := ec2.New(input.sess)
+	imgName := aws.ToString(input.image.Name)
+	ec2Client := ec2.NewFromConfig(input.cfg)
 	in2 := &ec2.CopyImageInput{
 		Description:   input.image.Description,
 		DryRun:        aws.Bool(input.dryRun),
@@ -139,14 +133,14 @@ func copyWithoutSnapshot(input copyWithoutSnapshotInput) (string, string, error)
 		SourceRegion:  aws.String(input.sourceRegion),
 	}
 	log := input.log.WithValues("imageName", imgName)
-	log.Info("Copying the retrieved image", "imageID", aws.StringValue(input.image.ImageId), "ownerID", aws.StringValue(input.image.OwnerId))
-	out, err := ec2Client.CopyImage(in2)
+	log.Info("Copying the retrieved image", "imageID", aws.ToString(input.image.ImageId), "ownerID", aws.ToString(input.image.OwnerId))
+	out, err := ec2Client.CopyImage(context.TODO(), in2)
 	if err != nil {
-		fmt.Printf("version %q\n", out)
+		fmt.Printf("version %v\n", out)
 		return imgName, "", err
 	}
 
-	return imgName, aws.StringValue(out.ImageId), nil
+	return imgName, aws.ToString(out.ImageId), nil
 }
 
 type copyWithSnapshotInput struct {
@@ -156,12 +150,12 @@ type copyWithSnapshotInput struct {
 	dryRun            bool
 	encrypted         bool
 	log               logr.Logger
-	image             *ec2.Image
-	sess              *session.Session
+	image             *types.Image
+	cfg               aws.Config
 }
 
 func copyWithSnapshot(input copyWithSnapshotInput) (string, string, error) {
-	ec2Client := ec2.New(input.sess)
+	ec2Client := ec2.NewFromConfig(input.cfg)
 	imgName := *input.image.Name + util.RandomString(3) + strconv.Itoa(int(time.Now().Unix()))
 	log := input.log.WithValues("imageName", imgName)
 
@@ -175,52 +169,57 @@ func copyWithSnapshot(input copyWithSnapshotInput) (string, string, error) {
 	}
 
 	copyInput := &ec2.CopySnapshotInput{
-		Description:       input.image.Description,
-		DestinationRegion: aws.String(input.destinationRegion),
-		DryRun:            aws.Bool(input.dryRun),
-		Encrypted:         aws.Bool(input.encrypted),
-		SourceRegion:      aws.String(input.sourceRegion),
-		KmsKeyId:          kmsKeyIDPtr,
-		SourceSnapshotId:  input.image.BlockDeviceMappings[0].Ebs.SnapshotId,
+		Description:      input.image.Description,
+		DryRun:           aws.Bool(input.dryRun),
+		Encrypted:        aws.Bool(input.encrypted),
+		SourceRegion:     aws.String(input.sourceRegion),
+		KmsKeyId:         kmsKeyIDPtr,
+		SourceSnapshotId: input.image.BlockDeviceMappings[0].Ebs.SnapshotId,
 	}
 
 	// Generate a presigned url from the CopySnapshotInput
-	req, _ := ec2Client.CopySnapshotRequest(copyInput)
-	str, err := req.Presign(15 * time.Minute)
+	scl := ec2.NewPresignClient(ec2Client)
+	str, err := scl.PresignCopySnapshot(context.TODO(), copyInput, ec2.WithPresignClientFromClientOptions(
+		func(o *ec2.Options) {
+			o.Region = input.destinationRegion
+		},
+	))
 	if err != nil {
 		return imgName, "", errors.Wrap(err, "Failed to generate presigned url")
 	}
-	copyInput.PresignedUrl = aws.String(str)
+	copyInput.PresignedUrl = aws.String(str.URL)
 
-	out, err := ec2Client.CopySnapshot(copyInput)
+	out, err := ec2Client.CopySnapshot(context.TODO(), copyInput, func(o *ec2.Options) {
+		o.Region = input.destinationRegion
+	})
 	if err != nil {
 		return imgName, "", errors.Wrap(err, "Failed copying snapshot")
 	}
 	log.Info("Copying snapshot, this may take a couple of minutes...",
-		"sourceSnapshot", aws.StringValue(input.image.BlockDeviceMappings[0].Ebs.SnapshotId),
-		"destinationSnapshot", aws.StringValue(out.SnapshotId),
+		"sourceSnapshot", aws.ToString(input.image.BlockDeviceMappings[0].Ebs.SnapshotId),
+		"destinationSnapshot", aws.ToString(out.SnapshotId),
 	)
 
-	err = ec2Client.WaitUntilSnapshotCompleted(&ec2.DescribeSnapshotsInput{
+	err = ec2.NewSnapshotCompletedWaiter(ec2Client).Wait(context.TODO(), &ec2.DescribeSnapshotsInput{
 		DryRun:      aws.Bool(input.dryRun),
-		SnapshotIds: []*string{out.SnapshotId},
-	})
+		SnapshotIds: []string{aws.ToString(out.SnapshotId)},
+	}, time.Hour*1)
 	if err != nil {
-		return imgName, "", errors.Wrap(err, fmt.Sprintf("Failed waiting for encrypted snapshot copy completion: %q\n", aws.StringValue(out.SnapshotId)))
+		return imgName, "", errors.Wrap(err, fmt.Sprintf("Failed waiting for encrypted snapshot copy completion: %q\n", aws.ToString(out.SnapshotId)))
 	}
 
-	ebsMapping := &ec2.BlockDeviceMapping{
+	ebsMapping := types.BlockDeviceMapping{
 		DeviceName: input.image.BlockDeviceMappings[0].DeviceName,
-		Ebs: &ec2.EbsBlockDevice{
+		Ebs: &types.EbsBlockDevice{
 			SnapshotId: out.SnapshotId,
 		},
 	}
 
 	log.Info("Registering AMI")
 
-	registerOut, err := ec2Client.RegisterImage(&ec2.RegisterImageInput{
+	registerOut, err := ec2Client.RegisterImage(context.TODO(), &ec2.RegisterImageInput{
 		Architecture:        input.image.Architecture,
-		BlockDeviceMappings: []*ec2.BlockDeviceMapping{ebsMapping},
+		BlockDeviceMappings: []types.BlockDeviceMapping{ebsMapping},
 		Description:         input.image.Description,
 		DryRun:              aws.Bool(input.dryRun),
 		EnaSupport:          input.image.EnaSupport,
@@ -229,12 +228,12 @@ func copyWithSnapshot(input copyWithSnapshotInput) (string, string, error) {
 		RamdiskId:           input.image.RamdiskId,
 		RootDeviceName:      input.image.RootDeviceName,
 		SriovNetSupport:     input.image.SriovNetSupport,
-		VirtualizationType:  input.image.VirtualizationType,
+		VirtualizationType:  aws.String(string(input.image.VirtualizationType)),
 	})
 
 	if err != nil {
 		return imgName, "", err
 	}
 
-	return imgName, aws.StringValue(registerOut.ImageId), err
+	return imgName, aws.ToString(registerOut.ImageId), err
 }
diff --git a/cmd/clusterawsadm/ami/helper.go b/cmd/clusterawsadm/ami/helper.go
index ca9dd4e5c..e804029ee 100644
--- a/cmd/clusterawsadm/ami/helper.go
+++ b/cmd/clusterawsadm/ami/helper.go
@@ -17,18 +17,20 @@ limitations under the License.
 package ami
 
 import (
+	"context"
 	"fmt"
 	"io"
 	"net/http"
 	"strconv"
 	"strings"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
 	"github.com/blang/semver"
 	"github.com/pkg/errors"
 
+	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/common"
 	ec2service "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/ec2"
 )
 
@@ -180,33 +182,33 @@ func latestStableRelease() (string, error) {
 	return latestVersion, nil
 }
 
-func getAllImages(ec2Client ec2iface.EC2API, ownerID string) (map[string][]*ec2.Image, error) {
+func getAllImages(ec2Client common.EC2API, ownerID string) (map[string][]types.Image, error) {
 	if ownerID == "" {
 		ownerID = ec2service.DefaultMachineAMIOwnerID
 	}
 
 	describeImageInput := &ec2.DescribeImagesInput{
-		Filters: []*ec2.Filter{
+		Filters: []types.Filter{
 			{
 				Name:   aws.String("owner-id"),
-				Values: []*string{aws.String(ownerID)},
+				Values: []string{ownerID},
 			},
 			{
 				Name:   aws.String("architecture"),
-				Values: []*string{aws.String("x86_64")},
+				Values: []string{"x86_64"},
 			},
 			{
 				Name:   aws.String("state"),
-				Values: []*string{aws.String("available")},
+				Values: []string{"available"},
 			},
 			{
 				Name:   aws.String("virtualization-type"),
-				Values: []*string{aws.String("hvm")},
+				Values: []string{"hvm"},
 			},
 		},
 	}
 
-	out, err := ec2Client.DescribeImages(describeImageInput)
+	out, err := ec2Client.DescribeImages(context.TODO(), describeImageInput)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to fetch AMIs")
 	}
@@ -214,7 +216,7 @@ func getAllImages(ec2Client ec2iface.EC2API, ownerID string) (map[string][]*ec2.
 		return nil, nil
 	}
 
-	imagesMap := make(map[string][]*ec2.Image)
+	imagesMap := make(map[string][]types.Image)
 	for _, image := range out.Images {
 		arr := strings.Split(aws.StringValue(image.Name), "-")
 		if arr[len(arr)-2] == "00" {
@@ -225,7 +227,7 @@ func getAllImages(ec2Client ec2iface.EC2API, ownerID string) (map[string][]*ec2.
 		name := strings.Join(arr, "-")
 		images, ok := imagesMap[name]
 		if !ok {
-			images = make([]*ec2.Image, 0)
+			images = make([]types.Image, 0)
 		}
 		imagesMap[name] = append(images, image)
 	}
@@ -233,7 +235,7 @@ func getAllImages(ec2Client ec2iface.EC2API, ownerID string) (map[string][]*ec2.
 	return imagesMap, nil
 }
 
-func findAMI(imagesMap map[string][]*ec2.Image, baseOS, kubernetesVersion string) (*ec2.Image, error) {
+func findAMI(imagesMap map[string][]types.Image, baseOS, kubernetesVersion string) (*types.Image, error) {
 	amiNameFormat := "capa-ami-{{.BaseOS}}-{{.K8sVersion}}"
 	// Support new AMI format capa-ami-<os-version>-?<k8s-version>-*
 	amiName, err := ec2service.GenerateAmiName(amiNameFormat, baseOS, kubernetesVersion)
@@ -253,7 +255,7 @@ func findAMI(imagesMap map[string][]*ec2.Image, baseOS, kubernetesVersion string
 	return nil, nil
 }
 
-func latestAMI(val []*ec2.Image) (*ec2.Image, error) {
+func latestAMI(val []types.Image) (*types.Image, error) {
 	latestImage, err := ec2service.GetLatestImage(val)
 	if err != nil {
 		return nil, err
diff --git a/cmd/clusterawsadm/ami/list.go b/cmd/clusterawsadm/ami/list.go
index 2b04f8142..2ba3c0365 100644
--- a/cmd/clusterawsadm/ami/list.go
+++ b/cmd/clusterawsadm/ami/list.go
@@ -18,12 +18,14 @@ limitations under the License.
 package ami
 
 import (
+	"context"
 	"fmt"
 	"time"
 
+	"github.com/aws/aws-sdk-go-v2/config"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	amiv1 "sigs.k8s.io/cluster-api-provider-aws/v2/cmd/clusterawsadm/api/ami/v1beta1"
@@ -73,16 +75,13 @@ func List(input ListInput) (*amiv1.AWSAMIList, error) {
 		Items: []amiv1.AWSAMI{},
 	}
 	for _, region := range imageRegionList {
-		imageMap := make(map[string][]*ec2.Image)
-		sess, err := session.NewSessionWithOptions(session.Options{
-			SharedConfigState: session.SharedConfigEnable,
-			Config:            aws.Config{Region: aws.String(region)},
-		})
+		imageMap := make(map[string][]types.Image)
+		cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion(region))
 		if err != nil {
 			return nil, err
 		}
 
-		ec2Client := ec2.New(sess)
+		ec2Client := ec2.NewFromConfig(cfg)
 		imagesForRegion, err := getAllImages(ec2Client, input.OwnerID)
 		if err != nil {
 			return nil, err
@@ -91,7 +90,7 @@ func List(input ListInput) (*amiv1.AWSAMIList, error) {
 		for key, image := range imagesForRegion {
 			images, ok := imageMap[key]
 			if !ok {
-				images = make([]*ec2.Image, 0)
+				images = make([]types.Image, 0)
 			}
 			imageMap[key] = append(images, image...)
 		}
diff --git a/exp/controllers/rosamachinepool_controller.go b/exp/controllers/rosamachinepool_controller.go
index aab404cf4..eab94fa3e 100644
--- a/exp/controllers/rosamachinepool_controller.go
+++ b/exp/controllers/rosamachinepool_controller.go
@@ -5,8 +5,8 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/service/sts/stsiface"
 	"github.com/blang/semver"
 	"github.com/google/go-cmp/cmp"
@@ -586,7 +586,7 @@ func (r *ROSAMachinePoolReconciler) reconcileProviderIDList(ctx context.Context,
 	}
 
 	ec2Svc := scope.NewEC2Client(machinePoolScope, machinePoolScope, &machinePoolScope.Logger, machinePoolScope.InfraCluster())
-	response, err := ec2Svc.DescribeInstancesWithContext(ctx, &ec2.DescribeInstancesInput{
+	response, err := ec2Svc.DescribeInstances(ctx, &ec2.DescribeInstancesInput{
 		Filters: buildEC2FiltersFromTags(tags),
 	})
 	if err != nil {
@@ -605,23 +605,23 @@ func (r *ROSAMachinePoolReconciler) reconcileProviderIDList(ctx context.Context,
 	return nil
 }
 
-func buildEC2FiltersFromTags(tags map[string]string) []*ec2.Filter {
-	filters := make([]*ec2.Filter, len(tags)+1)
+func buildEC2FiltersFromTags(tags map[string]string) []ec2types.Filter {
+	filters := make([]ec2types.Filter, len(tags)+1)
 	for key, value := range tags {
-		filters = append(filters, &ec2.Filter{
+		filters = append(filters, ec2types.Filter{
 			Name: ptr.To(fmt.Sprintf("tag:%s", key)),
-			Values: aws.StringSlice([]string{
+			Values: []string{
 				value,
-			}),
+			},
 		})
 	}
 
 	// only list instances that are running or just started
-	filters = append(filters, &ec2.Filter{
+	filters = append(filters, ec2types.Filter{
 		Name: ptr.To("instance-state-name"),
-		Values: aws.StringSlice([]string{
+		Values: []string{
 			"running", "pending",
-		}),
+		},
 	})
 
 	return filters
diff --git a/go.mod b/go.mod
index f4faa4a69..0971e1d1c 100644
--- a/go.mod
+++ b/go.mod
@@ -12,7 +12,7 @@ require (
 	github.com/aws/aws-sdk-go-v2/config v1.27.11
 	github.com/aws/aws-sdk-go-v2/credentials v1.17.11
 	github.com/aws/aws-sdk-go-v2/service/autoscaling v1.52.4
-	github.com/aws/aws-sdk-go-v2/service/ec2 v1.159.0
+	github.com/aws/aws-sdk-go-v2/service/ec2 v1.233.0
 	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.45.2
@@ -92,9 +92,9 @@ require (
 	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/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/accept-encoding v1.12.4 // 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/presigned-url v1.12.17 // 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/servicequotas v1.21.4 // indirect
diff --git a/go.sum b/go.sum
index ea5310f7d..f09066c90 100644
--- a/go.sum
+++ b/go.sum
@@ -70,8 +70,8 @@ github.com/aws/aws-sdk-go-v2/service/autoscaling v1.52.4 h1:vzLD0FyNU4uxf2QE5UDG
 github.com/aws/aws-sdk-go-v2/service/autoscaling v1.52.4/go.mod h1:CDqMoc3KRdZJ8qziW96J35lKH01Wq3B2aihtHj2JbRs=
 github.com/aws/aws-sdk-go-v2/service/cloudformation v1.50.0 h1:Ap5tOJfeAH1hO2UQc3X3uMlwP7uryFeZXMvZCXIlLSE=
 github.com/aws/aws-sdk-go-v2/service/cloudformation v1.50.0/go.mod h1:/v2KYdCW4BaHKayenaWEXOOdxItIwEA3oU0XzuQY3F0=
-github.com/aws/aws-sdk-go-v2/service/ec2 v1.159.0 h1:DmmVmiLPlcntOcjWMRwDPMNx/wi2kAVrf2ZmSN5gkAg=
-github.com/aws/aws-sdk-go-v2/service/ec2 v1.159.0/go.mod h1:xejKuuRDjz6z5OqyeLsz01MlOqqW7CqpAB4PabNvpu8=
+github.com/aws/aws-sdk-go-v2/service/ec2 v1.233.0 h1:VxmOsv7MswuKQcSEIurxe4RK9tC6zYnosw9vBvv74lA=
+github.com/aws/aws-sdk-go-v2/service/ec2 v1.233.0/go.mod h1:35jGWx7ECvCwTsApqicFYzZ7JFEnBc6oHUuOQ3xIS54=
 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=
@@ -82,12 +82,12 @@ github.com/aws/aws-sdk-go-v2/service/eventbridge v1.39.3 h1:T6L7fsONflMeXuvsT8qZ
 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=
 github.com/aws/aws-sdk-go-v2/service/iam v1.32.0/go.mod h1:aXWImQV0uTW35LM0A/T4wEg6R1/ReXUu4SM6/lUHYK0=
-github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.2 h1:Ji0DY1xUsUr3I8cHps0G+XM3WWU16lP6yG8qu1GAZAs=
-github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.2/go.mod h1:5CsjAbs3NlGQyZNFACh+zztPDI7fU6eW9QsxjfnuBKg=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.4 h1:CXV68E2dNqhuynZJPB80bhPQwAKqBWVer887figW6Jc=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.4/go.mod h1:/xFi9KtvBXP97ppCz1TAEvU1Uf66qvid89rbem3wCzQ=
 github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.3.7 h1:ZMeFZ5yk+Ek+jNr1+uwCd2tG89t6oTS5yVWpa6yy2es=
 github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.3.7/go.mod h1:mxV05U+4JiHqIpGqqYXOHLPKUC6bDXC44bsUhNjOEwY=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.7 h1:ogRAwT1/gxJBcSWDMZlgyFUM962F51A5CRhDLbxLdmo=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.7/go.mod h1:YCsIZhXfRPLFFCl5xxY+1T9RKzOKjCut+28JSX2DnAk=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.17 h1:t0E6FzREdtCsiLIoLCWsYliNsRBgyGD/MCK571qk4MI=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.17/go.mod h1:ygpklyoaypuyDvOM5ujWGrYWpAK3h7ugnmKCU/76Ys4=
 github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.17.5 h1:f9RyWNtS8oH7cZlbn+/JNPpjUk5+5fLd5lM9M0i49Ys=
 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=
diff --git a/pkg/cloud/converters/tags.go b/pkg/cloud/converters/tags.go
index 0b2284ed4..7ddd1abe8 100644
--- a/pkg/cloud/converters/tags.go
+++ b/pkg/cloud/converters/tags.go
@@ -21,19 +21,19 @@ import (
 	"strings"
 
 	autoscalingtypes "github.com/aws/aws-sdk-go-v2/service/autoscaling/types"
+	ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/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/secretsmanager"
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
 )
 
 // TagsToMap converts a []*ec2.Tag into a infrav1.Tags.
-func TagsToMap(src []*ec2.Tag) infrav1.Tags {
+func TagsToMap(src []ec2types.Tag) infrav1.Tags {
 	tags := make(infrav1.Tags, len(src))
 
 	for _, t := range src {
@@ -55,12 +55,12 @@ func MapPtrToMap(src map[string]string) infrav1.Tags {
 }
 
 // MapToTags converts a infrav1.Tags to a []*ec2.Tag.
-func MapToTags(src infrav1.Tags) []*ec2.Tag {
-	tags := make([]*ec2.Tag, 0, len(src))
+func MapToTags(src infrav1.Tags) []ec2types.Tag {
+	tags := make([]ec2types.Tag, 0, len(src))
 
 	for k, v := range src {
 		if !strings.HasPrefix(k, "aws:") {
-			tag := &ec2.Tag{
+			tag := ec2types.Tag{
 				Key:   aws.String(k),
 				Value: aws.String(v),
 			}
diff --git a/pkg/cloud/endpointsv2/endpoints.go b/pkg/cloud/endpointsv2/endpoints.go
index 4548e1512..b9d92aab1 100644
--- a/pkg/cloud/endpointsv2/endpoints.go
+++ b/pkg/cloud/endpointsv2/endpoints.go
@@ -265,7 +265,7 @@ type EKSEndpointResolver struct {
 	*MultiServiceEndpointResolver
 }
 
-// ResolveEndpoint for S3.
+// ResolveEndpoint for EKS.
 func (s *EKSEndpointResolver) ResolveEndpoint(ctx context.Context, params eks.EndpointParameters) (smithyendpoints.Endpoint, error) {
 	// If custom endpoint not found, return default endpoint for the service
 	log := logger.FromContext(ctx)
diff --git a/pkg/cloud/filter/ec2.go b/pkg/cloud/filter/ec2.go
index b3122039c..dd6261190 100644
--- a/pkg/cloud/filter/ec2.go
+++ b/pkg/cloud/filter/ec2.go
@@ -19,8 +19,8 @@ package filter
 import (
 	"fmt"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
 )
@@ -40,136 +40,156 @@ var EC2 = new(ec2Filters)
 type ec2Filters struct{}
 
 // Cluster returns a filter based on the cluster name.
-func (ec2Filters) Cluster(clusterName string) *ec2.Filter {
-	return &ec2.Filter{
+func (ec2Filters) Cluster(clusterName string) types.Filter {
+	return types.Filter{
 		Name:   aws.String(filterNameTagKey),
-		Values: aws.StringSlice([]string{infrav1.ClusterTagKey(clusterName)}),
+		Values: []string{infrav1.ClusterTagKey(clusterName)},
 	}
 }
 
 // Name returns a filter based on the resource name.
-func (ec2Filters) Name(name string) *ec2.Filter {
-	return &ec2.Filter{
+func (ec2Filters) Name(name string) types.Filter {
+	return types.Filter{
 		Name:   aws.String("tag:Name"),
-		Values: aws.StringSlice([]string{name}),
+		Values: []string{name},
 	}
 }
 
 // ClusterOwned returns a filter using the Cluster API per-cluster tag where
 // the resource is owned.
-func (ec2Filters) ClusterOwned(clusterName string) *ec2.Filter {
-	return &ec2.Filter{
+func (ec2Filters) ClusterOwned(clusterName string) types.Filter {
+	return types.Filter{
 		Name:   aws.String(fmt.Sprintf("tag:%s", infrav1.ClusterTagKey(clusterName))),
-		Values: aws.StringSlice([]string{string(infrav1.ResourceLifecycleOwned)}),
+		Values: []string{string(infrav1.ResourceLifecycleOwned)},
 	}
 }
 
 // ClusterShared returns a filter using the Cluster API per-cluster tag where
 // the resource is shared.
-func (ec2Filters) ClusterShared(clusterName string) *ec2.Filter {
-	return &ec2.Filter{
+func (ec2Filters) ClusterShared(clusterName string) *types.Filter {
+	return &types.Filter{
 		Name:   aws.String(fmt.Sprintf("tag:%s", infrav1.ClusterTagKey(clusterName))),
-		Values: aws.StringSlice([]string{string(infrav1.ResourceLifecycleShared)}),
+		Values: []string{string(infrav1.ResourceLifecycleShared)},
 	}
 }
 
 // ProviderRole returns a filter using cluster-api-provider-aws role tag.
-func (ec2Filters) ProviderRole(role string) *ec2.Filter {
-	return &ec2.Filter{
+func (ec2Filters) ProviderRole(role string) types.Filter {
+	return types.Filter{
 		Name:   aws.String(fmt.Sprintf("tag:%s", infrav1.NameAWSClusterAPIRole)),
-		Values: aws.StringSlice([]string{role}),
+		Values: []string{role},
 	}
 }
 
 // ProviderOwned returns a filter using the cloud provider tag where the resource is owned.
-func (ec2Filters) ProviderOwned(clusterName string) *ec2.Filter {
-	return &ec2.Filter{
+func (ec2Filters) ProviderOwned(clusterName string) types.Filter {
+	return types.Filter{
 		Name:   aws.String(fmt.Sprintf("tag:%s", infrav1.ClusterAWSCloudProviderTagKey(clusterName))),
-		Values: aws.StringSlice([]string{string(infrav1.ResourceLifecycleOwned)}),
+		Values: []string{string(infrav1.ResourceLifecycleOwned)},
 	}
 }
 
 // IPAM returns a filter based on the id of the IPAM Pool.
-func (ec2Filters) IPAM(ipamPoolID string) *ec2.Filter {
-	return &ec2.Filter{
+func (ec2Filters) IPAM(ipamPoolID string) types.Filter {
+	return types.Filter{
 		Name:   aws.String(filterNameIPAMPoolID),
-		Values: aws.StringSlice([]string{ipamPoolID}),
+		Values: []string{ipamPoolID},
 	}
 }
 
 // VPC returns a filter based on the id of the VPC.
-func (ec2Filters) VPC(vpcID string) *ec2.Filter {
-	return &ec2.Filter{
+func (ec2Filters) VPC(vpcID string) types.Filter {
+	return types.Filter{
 		Name:   aws.String(filterNameVpcID),
-		Values: aws.StringSlice([]string{vpcID}),
+		Values: []string{vpcID},
 	}
 }
 
 // VPCAttachment returns a filter based on the vpc id attached to the resource.
-func (ec2Filters) VPCAttachment(vpcID string) *ec2.Filter {
-	return &ec2.Filter{
+func (ec2Filters) VPCAttachment(vpcID string) types.Filter {
+	return types.Filter{
 		Name:   aws.String(filterNameVpcAttachment),
-		Values: aws.StringSlice([]string{vpcID}),
+		Values: []string{vpcID},
 	}
 }
 
 // Available returns a filter based on the state being available.
-func (ec2Filters) Available() *ec2.Filter {
-	return &ec2.Filter{
+func (ec2Filters) Available() types.Filter {
+	return types.Filter{
 		Name:   aws.String(filterNameState),
-		Values: aws.StringSlice([]string{"available"}),
+		Values: []string{"available"},
 	}
 }
 
 // NATGatewayStates returns a filter based on the list of states passed in.
-func (ec2Filters) NATGatewayStates(states ...string) *ec2.Filter {
-	return &ec2.Filter{
+func (ec2Filters) NATGatewayStates(states ...types.NatGatewayState) types.Filter {
+	stateStrings := make([]string, len(states))
+	for i, state := range states {
+		stateStrings[i] = string(state)
+	}
+
+	return types.Filter{
 		Name:   aws.String("state"),
-		Values: aws.StringSlice(states),
+		Values: stateStrings,
 	}
 }
 
 // InstanceStates returns a filter based on the list of states passed in.
-func (ec2Filters) InstanceStates(states ...string) *ec2.Filter {
-	return &ec2.Filter{
+func (ec2Filters) InstanceStates(states ...types.InstanceStateName) types.Filter {
+	stateStrings := make([]string, len(states))
+	for i, state := range states {
+		stateStrings[i] = string(state)
+	}
+
+	return types.Filter{
 		Name:   aws.String("instance-state-name"),
-		Values: aws.StringSlice(states),
+		Values: stateStrings,
 	}
 }
 
 // VPCStates returns a filter based on the list of states passed in.
-func (ec2Filters) VPCStates(states ...string) *ec2.Filter {
-	return &ec2.Filter{
+func (ec2Filters) VPCStates(states ...types.VpcState) types.Filter {
+	stateStrings := make([]string, len(states))
+	for i, state := range states {
+		stateStrings[i] = string(state)
+	}
+
+	return types.Filter{
 		Name:   aws.String("state"),
-		Values: aws.StringSlice(states),
+		Values: stateStrings,
 	}
 }
 
 // SubnetStates returns a filter based on the list of states passed in.
-func (ec2Filters) SubnetStates(states ...string) *ec2.Filter {
-	return &ec2.Filter{
+func (ec2Filters) SubnetStates(states ...types.SubnetState) types.Filter {
+	stateStrings := make([]string, len(states))
+	for i, state := range states {
+		stateStrings[i] = string(state)
+	}
+
+	return types.Filter{
 		Name:   aws.String("state"),
-		Values: aws.StringSlice(states),
+		Values: stateStrings,
 	}
 }
 
-func (ec2Filters) AvailabilityZone(zone string) *ec2.Filter {
-	return &ec2.Filter{
+func (ec2Filters) AvailabilityZone(zone string) *types.Filter {
+	return &types.Filter{
 		Name:   aws.String(filterAvailabilityZone),
-		Values: aws.StringSlice([]string{zone}),
+		Values: []string{zone},
 	}
 }
 
-func (ec2Filters) IgnoreLocalZones() *ec2.Filter {
-	return &ec2.Filter{
+func (ec2Filters) IgnoreLocalZones() types.Filter {
+	return types.Filter{
 		Name:   aws.String("opt-in-status"),
-		Values: aws.StringSlice([]string{"opt-in-not-required"}),
+		Values: []string{"opt-in-not-required"},
 	}
 }
 
-func (ec2Filters) SecurityGroupName(name string) *ec2.Filter {
-	return &ec2.Filter{
+func (ec2Filters) SecurityGroupName(name string) types.Filter {
+	return types.Filter{
 		Name:   aws.String("group-name"),
-		Values: aws.StringSlice([]string{name}),
+		Values: []string{name},
 	}
 }
diff --git a/pkg/cloud/filterv2/ec2.go b/pkg/cloud/filterv2/ec2.go
deleted file mode 100644
index ef87eabd4..000000000
--- a/pkg/cloud/filterv2/ec2.go
+++ /dev/null
@@ -1,176 +0,0 @@
-/*
-Copyright 2025 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Package filterv2 contains the ec2 sdk related filters.
-package filterv2
-
-import (
-	"fmt"
-
-	"github.com/aws/aws-sdk-go-v2/aws"
-	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
-
-	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
-)
-
-const (
-	filterNameTagKey        = "tag-key"
-	filterNameVpcID         = "vpc-id"
-	filterNameState         = "state"
-	filterNameVpcAttachment = "attachment.vpc-id"
-	filterAvailabilityZone  = "availability-zone"
-	filterNameIPAMPoolID    = "ipam-pool-id"
-)
-
-// EC2 exposes the ec2 sdk related filters.
-var EC2 = new(ec2Filters)
-
-type ec2Filters struct{}
-
-// Cluster returns a filter based on the cluster name.
-func (ec2Filters) Cluster(clusterName string) *types.Filter {
-	return &types.Filter{
-		Name:   aws.String(filterNameTagKey),
-		Values: []string{infrav1.ClusterTagKey(clusterName)},
-	}
-}
-
-// Name returns a filter based on the resource name.
-func (ec2Filters) Name(name string) *types.Filter {
-	return &types.Filter{
-		Name:   aws.String("tag:Name"),
-		Values: []string{name},
-	}
-}
-
-// ClusterOwned returns a filter using the Cluster API per-cluster tag where
-// the resource is owned.
-func (ec2Filters) ClusterOwned(clusterName string) *types.Filter {
-	return &types.Filter{
-		Name:   aws.String(fmt.Sprintf("tag:%s", infrav1.ClusterTagKey(clusterName))),
-		Values: []string{string(infrav1.ResourceLifecycleOwned)},
-	}
-}
-
-// ClusterShared returns a filter using the Cluster API per-cluster tag where
-// the resource is shared.
-func (ec2Filters) ClusterShared(clusterName string) *types.Filter {
-	return &types.Filter{
-		Name:   aws.String(fmt.Sprintf("tag:%s", infrav1.ClusterTagKey(clusterName))),
-		Values: []string{string(infrav1.ResourceLifecycleShared)},
-	}
-}
-
-// ProviderRole returns a filter using cluster-api-provider-aws role tag.
-func (ec2Filters) ProviderRole(role string) *types.Filter {
-	return &types.Filter{
-		Name:   aws.String(fmt.Sprintf("tag:%s", infrav1.NameAWSClusterAPIRole)),
-		Values: []string{role},
-	}
-}
-
-// ProviderOwned returns a filter using the cloud provider tag where the resource is owned.
-func (ec2Filters) ProviderOwned(clusterName string) *types.Filter {
-	return &types.Filter{
-		Name:   aws.String(fmt.Sprintf("tag:%s", infrav1.ClusterAWSCloudProviderTagKey(clusterName))),
-		Values: []string{string(infrav1.ResourceLifecycleOwned)},
-	}
-}
-
-// IPAM returns a filter based on the id of the IPAM Pool.
-func (ec2Filters) IPAM(ipamPoolID string) *types.Filter {
-	return &types.Filter{
-		Name:   aws.String(filterNameIPAMPoolID),
-		Values: []string{ipamPoolID},
-	}
-}
-
-// VPC returns a filter based on the id of the VPC.
-func (ec2Filters) VPC(vpcID string) *types.Filter {
-	return &types.Filter{
-		Name:   aws.String(filterNameVpcID),
-		Values: []string{vpcID},
-	}
-}
-
-// VPCAttachment returns a filter based on the vpc id attached to the resource.
-func (ec2Filters) VPCAttachment(vpcID string) *types.Filter {
-	return &types.Filter{
-		Name:   aws.String(filterNameVpcAttachment),
-		Values: []string{vpcID},
-	}
-}
-
-// Available returns a filter based on the state being available.
-func (ec2Filters) Available() *types.Filter {
-	return &types.Filter{
-		Name:   aws.String(filterNameState),
-		Values: []string{"available"},
-	}
-}
-
-// NATGatewayStates returns a filter based on the list of states passed in.
-func (ec2Filters) NATGatewayStates(states ...string) *types.Filter {
-	return &types.Filter{
-		Name:   aws.String("state"),
-		Values: states,
-	}
-}
-
-// InstanceStates returns a filter based on the list of states passed in.
-func (ec2Filters) InstanceStates(states ...string) *types.Filter {
-	return &types.Filter{
-		Name:   aws.String("instance-state-name"),
-		Values: states,
-	}
-}
-
-// VPCStates returns a filter based on the list of states passed in.
-func (ec2Filters) VPCStates(states ...string) *types.Filter {
-	return &types.Filter{
-		Name:   aws.String("state"),
-		Values: states,
-	}
-}
-
-// SubnetStates returns a filter based on the list of states passed in.
-func (ec2Filters) SubnetStates(states ...string) *types.Filter {
-	return &types.Filter{
-		Name:   aws.String("state"),
-		Values: states,
-	}
-}
-
-func (ec2Filters) AvailabilityZone(zone string) *types.Filter {
-	return &types.Filter{
-		Name:   aws.String(filterAvailabilityZone),
-		Values: []string{zone},
-	}
-}
-
-func (ec2Filters) IgnoreLocalZones() *types.Filter {
-	return &types.Filter{
-		Name:   aws.String("opt-in-status"),
-		Values: []string{"opt-in-not-required"},
-	}
-}
-
-func (ec2Filters) SecurityGroupName(name string) *types.Filter {
-	return &types.Filter{
-		Name:   aws.String("group-name"),
-		Values: []string{name},
-	}
-}
diff --git a/pkg/cloud/scope/clients.go b/pkg/cloud/scope/clients.go
index 42acd40cb..1e37a9b20 100644
--- a/pkg/cloud/scope/clients.go
+++ b/pkg/cloud/scope/clients.go
@@ -17,10 +17,8 @@ limitations under the License.
 package scope
 
 import (
-	"context"
-
 	"github.com/aws/aws-sdk-go-v2/service/autoscaling"
-	ec2v2 "github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
 	"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"
@@ -33,8 +31,6 @@ import (
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
 	"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"
@@ -52,13 +48,6 @@ import (
 	"sigs.k8s.io/cluster-api-provider-aws/v2/version"
 )
 
-// EC2API is a compatibility layer for the v1 ec2iface.EC2API interface.
-// It is used to provide a consistent interface for the DeleteSecurityGroup method.
-type EC2API interface {
-	DeleteSecurityGroup(context.Context, *ec2v2.DeleteSecurityGroupInput, ...func(*ec2v2.Options)) (*ec2v2.DeleteSecurityGroupOutput, error)
-	ec2v2.DescribeSecurityGroupsAPIClient
-}
-
 // NewASGClient creates a new ASG API client for a given session.
 func NewASGClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) *autoscaling.Client {
 	cfg := session.SessionV2()
@@ -78,19 +67,27 @@ func NewASGClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logg
 }
 
 // NewEC2Client creates a new EC2 API client for a given session.
-func NewEC2Client(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) ec2iface.EC2API {
-	ec2Client := ec2.New(session.Session(), aws.NewConfig().WithLogLevel(awslogs.GetAWSLogLevel(logger.GetLogger())).WithLogger(awslogs.NewWrapLogr(logger.GetLogger())))
-	ec2Client.Handlers.Build.PushFrontNamed(getUserAgentHandler())
-	if session.ServiceLimiter(ec2.ServiceID) != nil {
-		ec2Client.Handlers.Sign.PushFront(session.ServiceLimiter(ec2.ServiceID).LimitRequest)
+func NewEC2Client(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) *ec2.Client {
+	cfg := session.SessionV2()
+	multiSvcEndpointResolver := endpointsv2.NewMultiServiceEndpointResolver()
+	ec2EndpointResolver := &endpointsv2.EC2EndpointResolver{
+		MultiServiceEndpointResolver: multiSvcEndpointResolver,
 	}
-	ec2Client.Handlers.CompleteAttempt.PushFront(awsmetrics.CaptureRequestMetrics(scopeUser.ControllerName()))
-	if session.ServiceLimiter(ec2.ServiceID) != nil {
-		ec2Client.Handlers.CompleteAttempt.PushFront(session.ServiceLimiter(ec2.ServiceID).ReviewResponse)
+
+	ec2opts := []func(*ec2.Options){
+		func(o *ec2.Options) {
+			o.Logger = logger.GetAWSLogger()
+			o.ClientLogMode = awslogs.GetAWSLogLevelV2(logger.GetLogger())
+			o.EndpointResolverV2 = ec2EndpointResolver
+		},
+		ec2.WithAPIOptions(
+			awsmetricsv2.WithMiddlewares(scopeUser.ControllerName(), target),
+			awsmetricsv2.WithCAPAUserAgentMiddleware(),
+			throttle.WithServiceLimiterMiddleware(session.ServiceLimiter(ec2.ServiceID)),
+		),
 	}
-	ec2Client.Handlers.Complete.PushBack(recordAWSPermissionsIssue(target))
 
-	return ec2Client
+	return ec2.NewFromConfig(cfg, ec2opts...)
 }
 
 // NewELBClient creates a new ELB API client for a given session.
@@ -322,24 +319,6 @@ func NewS3Client(scopeUser cloud.ScopeUsage, session cloud.Session, logger logge
 	return s3.NewFromConfig(cfg, s3Opts...)
 }
 
-// NewEC2ClientV2 creates a new EC2 API client for a given session using AWS SDK v2.
-func NewEC2ClientV2(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) EC2API {
-	cfg := session.SessionV2()
-	multiSvcEndpointResolver := endpointsv2.NewMultiServiceEndpointResolver()
-	ec2EndpointResolver := &endpointsv2.EC2EndpointResolver{
-		MultiServiceEndpointResolver: multiSvcEndpointResolver,
-	}
-	ec2Opts := []func(*ec2v2.Options){
-		func(o *ec2v2.Options) {
-			o.Logger = logger.GetAWSLogger()
-			o.ClientLogMode = awslogs.GetAWSLogLevelV2(logger.GetLogger())
-			o.EndpointResolverV2 = ec2EndpointResolver
-		},
-		ec2v2.WithAPIOptions(awsmetricsv2.WithMiddlewares(scopeUser.ControllerName(), target), awsmetricsv2.WithCAPAUserAgentMiddleware()),
-	}
-	return ec2v2.NewFromConfig(cfg, ec2Opts...)
-}
-
 func recordAWSPermissionsIssue(target runtime.Object) func(r *request.Request) {
 	return func(r *request.Request) {
 		if awsErr, ok := r.Error.(awserr.Error); ok {
@@ -364,7 +343,6 @@ type AWSClients struct {
 	SecretsManager  secretsmanageriface.SecretsManagerAPI
 	ResourceTagging *rgapi.Client
 	ASG             *autoscaling.Client
-	EC2             ec2iface.EC2API
-	EC2V2           *ec2v2.Client
+	EC2             *ec2.Client
 	ELBV2           *elbv2.Client
 }
diff --git a/pkg/cloud/services/autoscaling/autoscalinggroup.go b/pkg/cloud/services/autoscaling/autoscalinggroup.go
index 6a288615d..aa5891809 100644
--- a/pkg/cloud/services/autoscaling/autoscalinggroup.go
+++ b/pkg/cloud/services/autoscaling/autoscalinggroup.go
@@ -26,10 +26,10 @@ import (
 
 	"github.com/aws/aws-sdk-go-v2/service/autoscaling"
 	autoscalingtypes "github.com/aws/aws-sdk-go-v2/service/autoscaling/types"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/pkg/errors"
-	corev1 "k8s.io/api/core/v1"
 	"k8s.io/utils/ptr"
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
@@ -147,7 +147,7 @@ func (s *Service) ASGIfExists(name *string) (*expinfrav1.AutoScalingGroup, error
 		record.Eventf(s.scope.InfraCluster(), "FailedDescribeAutoScalingGroups", "failed to describe ASG %q: %v", *name, err)
 		return nil, errors.Wrapf(err, "failed to describe AutoScaling Group: %q", *name)
 	case len(out.AutoScalingGroups) == 0:
-		record.Eventf(s.scope.InfraCluster(), corev1.EventTypeNormal, expinfrav1.ASGNotFoundReason, "Unable to find ASG matching %q", *name)
+		record.Eventf(s.scope.InfraCluster(), expinfrav1.ASGNotFoundReason, "Unable to find ASG matching %q", *name)
 		return nil, nil
 	}
 	return s.SDKToAutoScalingGroup(&out.AutoScalingGroups[0])
@@ -503,7 +503,7 @@ func mapToTags(input map[string]string, resourceID *string) []autoscalingtypes.T
 // SubnetIDs return subnet IDs of a AWSMachinePool based on given subnetIDs and filters.
 func (s *Service) SubnetIDs(scope *scope.MachinePoolScope) ([]string, error) {
 	subnetIDs := make([]string, 0)
-	var inputFilters = make([]*ec2.Filter, 0)
+	var inputFilters = make([]ec2types.Filter, 0)
 
 	for _, subnet := range scope.AWSMachinePool.Spec.Subnets {
 		switch {
@@ -511,16 +511,16 @@ func (s *Service) SubnetIDs(scope *scope.MachinePoolScope) ([]string, error) {
 			subnetIDs = append(subnetIDs, aws.StringValue(subnet.ID))
 		case subnet.Filters != nil:
 			for _, eachFilter := range subnet.Filters {
-				inputFilters = append(inputFilters, &ec2.Filter{
+				inputFilters = append(inputFilters, ec2types.Filter{
 					Name:   aws.String(eachFilter.Name),
-					Values: aws.StringSlice(eachFilter.Values),
+					Values: eachFilter.Values,
 				})
 			}
 		}
 	}
 
 	if len(inputFilters) > 0 {
-		out, err := s.EC2Client.DescribeSubnetsWithContext(context.TODO(), &ec2.DescribeSubnetsInput{
+		out, err := s.EC2Client.DescribeSubnets(context.TODO(), &ec2.DescribeSubnetsInput{
 			Filters: inputFilters,
 		})
 		if err != nil {
@@ -538,7 +538,7 @@ func (s *Service) SubnetIDs(scope *scope.MachinePoolScope) ([]string, error) {
 		}
 
 		if len(subnetIDs) == 0 {
-			errMessage := fmt.Sprintf("failed to create ASG %q, no subnets available matching criteria %q", scope.Name(), inputFilters)
+			errMessage := fmt.Sprintf("failed to create ASG %q, no subnets available matching criteria %v", scope.Name(), inputFilters)
 			record.Warnf(scope.AWSMachinePool, "FailedCreate", errMessage)
 			return subnetIDs, awserrors.NewFailedDependency(errMessage)
 		}
diff --git a/pkg/cloud/services/autoscaling/service.go b/pkg/cloud/services/autoscaling/service.go
index ec9019bbf..3c1591af2 100644
--- a/pkg/cloud/services/autoscaling/service.go
+++ b/pkg/cloud/services/autoscaling/service.go
@@ -20,10 +20,10 @@ import (
 	"context"
 
 	"github.com/aws/aws-sdk-go-v2/service/autoscaling"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
 
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope"
+	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/common"
 )
 
 // Service holds a collection of interfaces.
@@ -32,7 +32,7 @@ import (
 type Service struct {
 	scope     cloud.ClusterScoper
 	ASGClient AutoScalingAPI
-	EC2Client ec2iface.EC2API
+	EC2Client common.EC2API
 }
 
 // AutoScalingAPI is an interface for the AWS AutoScaling API client.
diff --git a/pkg/cloud/services/common/common.go b/pkg/cloud/services/common/common.go
new file mode 100644
index 000000000..356153464
--- /dev/null
+++ b/pkg/cloud/services/common/common.go
@@ -0,0 +1,95 @@
+/*
+Copyright 2025 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package common defines service contracts used by other services.
+package common
+
+import (
+	"context"
+
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+)
+
+// EC2API defines the EC2 API interface.
+type EC2API interface {
+	AllocateAddress(ctx context.Context, params *ec2.AllocateAddressInput, optFns ...func(*ec2.Options)) (*ec2.AllocateAddressOutput, error)
+	AssociateAddress(ctx context.Context, params *ec2.AssociateAddressInput, optFns ...func(*ec2.Options)) (*ec2.AssociateAddressOutput, error)
+	AssociateRouteTable(ctx context.Context, params *ec2.AssociateRouteTableInput, optFns ...func(*ec2.Options)) (*ec2.AssociateRouteTableOutput, error)
+	AssociateVpcCidrBlock(ctx context.Context, params *ec2.AssociateVpcCidrBlockInput, optFns ...func(*ec2.Options)) (*ec2.AssociateVpcCidrBlockOutput, error)
+	AttachInternetGateway(ctx context.Context, params *ec2.AttachInternetGatewayInput, optFns ...func(*ec2.Options)) (*ec2.AttachInternetGatewayOutput, error)
+	AuthorizeSecurityGroupIngress(ctx context.Context, params *ec2.AuthorizeSecurityGroupIngressInput, optFns ...func(*ec2.Options)) (*ec2.AuthorizeSecurityGroupIngressOutput, error)
+	CreateCarrierGateway(ctx context.Context, params *ec2.CreateCarrierGatewayInput, optFns ...func(*ec2.Options)) (*ec2.CreateCarrierGatewayOutput, error)
+	CreateEgressOnlyInternetGateway(ctx context.Context, params *ec2.CreateEgressOnlyInternetGatewayInput, optFns ...func(*ec2.Options)) (*ec2.CreateEgressOnlyInternetGatewayOutput, error)
+	CreateInternetGateway(ctx context.Context, params *ec2.CreateInternetGatewayInput, optFns ...func(*ec2.Options)) (*ec2.CreateInternetGatewayOutput, error)
+	CreateLaunchTemplate(ctx context.Context, params *ec2.CreateLaunchTemplateInput, optFns ...func(*ec2.Options)) (*ec2.CreateLaunchTemplateOutput, error)
+	CreateLaunchTemplateVersion(ctx context.Context, params *ec2.CreateLaunchTemplateVersionInput, optFns ...func(*ec2.Options)) (*ec2.CreateLaunchTemplateVersionOutput, error)
+	CreateNatGateway(ctx context.Context, params *ec2.CreateNatGatewayInput, optFns ...func(*ec2.Options)) (*ec2.CreateNatGatewayOutput, error)
+	CreateRouteTable(ctx context.Context, params *ec2.CreateRouteTableInput, optFns ...func(*ec2.Options)) (*ec2.CreateRouteTableOutput, error)
+	CreateRoute(ctx context.Context, params *ec2.CreateRouteInput, optFns ...func(*ec2.Options)) (*ec2.CreateRouteOutput, error)
+	CreateSecurityGroup(ctx context.Context, params *ec2.CreateSecurityGroupInput, optFns ...func(*ec2.Options)) (*ec2.CreateSecurityGroupOutput, error)
+	CreateSubnet(ctx context.Context, params *ec2.CreateSubnetInput, optFns ...func(*ec2.Options)) (*ec2.CreateSubnetOutput, error)
+	CreateTags(ctx context.Context, params *ec2.CreateTagsInput, optFns ...func(*ec2.Options)) (*ec2.CreateTagsOutput, error)
+	CreateVpc(ctx context.Context, params *ec2.CreateVpcInput, optFns ...func(*ec2.Options)) (*ec2.CreateVpcOutput, error)
+	CreateVpcEndpoint(ctx context.Context, params *ec2.CreateVpcEndpointInput, optFns ...func(*ec2.Options)) (*ec2.CreateVpcEndpointOutput, error)
+	DeleteCarrierGateway(ctx context.Context, params *ec2.DeleteCarrierGatewayInput, optFns ...func(*ec2.Options)) (*ec2.DeleteCarrierGatewayOutput, error)
+	DeleteEgressOnlyInternetGateway(ctx context.Context, params *ec2.DeleteEgressOnlyInternetGatewayInput, optFns ...func(*ec2.Options)) (*ec2.DeleteEgressOnlyInternetGatewayOutput, error)
+	DeleteInternetGateway(ctx context.Context, params *ec2.DeleteInternetGatewayInput, optFns ...func(*ec2.Options)) (*ec2.DeleteInternetGatewayOutput, error)
+	DeleteLaunchTemplate(ctx context.Context, params *ec2.DeleteLaunchTemplateInput, optFns ...func(*ec2.Options)) (*ec2.DeleteLaunchTemplateOutput, error)
+	DeleteLaunchTemplateVersions(ctx context.Context, params *ec2.DeleteLaunchTemplateVersionsInput, optFns ...func(*ec2.Options)) (*ec2.DeleteLaunchTemplateVersionsOutput, error)
+	DeleteNatGateway(ctx context.Context, params *ec2.DeleteNatGatewayInput, optFns ...func(*ec2.Options)) (*ec2.DeleteNatGatewayOutput, error)
+	DeleteRouteTable(ctx context.Context, params *ec2.DeleteRouteTableInput, optFns ...func(*ec2.Options)) (*ec2.DeleteRouteTableOutput, error)
+	DeleteSecurityGroup(ctx context.Context, params *ec2.DeleteSecurityGroupInput, optFns ...func(*ec2.Options)) (*ec2.DeleteSecurityGroupOutput, error)
+	DeleteSubnet(ctx context.Context, params *ec2.DeleteSubnetInput, optFns ...func(*ec2.Options)) (*ec2.DeleteSubnetOutput, error)
+	DeleteTags(ctx context.Context, params *ec2.DeleteTagsInput, optFns ...func(*ec2.Options)) (*ec2.DeleteTagsOutput, error)
+	DeleteVpc(ctx context.Context, params *ec2.DeleteVpcInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVpcOutput, error)
+	DeleteVpcEndpoints(ctx context.Context, params *ec2.DeleteVpcEndpointsInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVpcEndpointsOutput, error)
+	DescribeAddresses(ctx context.Context, params *ec2.DescribeAddressesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeAddressesOutput, error)
+	DescribeAvailabilityZones(ctx context.Context, params *ec2.DescribeAvailabilityZonesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeAvailabilityZonesOutput, error)
+	DescribeCarrierGateways(ctx context.Context, params *ec2.DescribeCarrierGatewaysInput, optFns ...func(*ec2.Options)) (*ec2.DescribeCarrierGatewaysOutput, error)
+	DescribeDhcpOptions(ctx context.Context, params *ec2.DescribeDhcpOptionsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeDhcpOptionsOutput, error)
+	DescribeEgressOnlyInternetGateways(ctx context.Context, params *ec2.DescribeEgressOnlyInternetGatewaysInput, optFns ...func(*ec2.Options)) (*ec2.DescribeEgressOnlyInternetGatewaysOutput, error)
+	DescribeImages(ctx context.Context, params *ec2.DescribeImagesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeImagesOutput, error)
+	DescribeInstances(ctx context.Context, params *ec2.DescribeInstancesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeInstancesOutput, error)
+	DescribeInstanceTypes(context.Context, *ec2.DescribeInstanceTypesInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceTypesOutput, error)
+	DescribeInternetGateways(ctx context.Context, params *ec2.DescribeInternetGatewaysInput, optFns ...func(*ec2.Options)) (*ec2.DescribeInternetGatewaysOutput, error)
+	DescribeIpamPools(ctx context.Context, params *ec2.DescribeIpamPoolsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeIpamPoolsOutput, error)
+	DescribeLaunchTemplateVersions(ctx context.Context, params *ec2.DescribeLaunchTemplateVersionsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeLaunchTemplateVersionsOutput, error)
+	DescribeNatGateways(context.Context, *ec2.DescribeNatGatewaysInput, ...func(*ec2.Options)) (*ec2.DescribeNatGatewaysOutput, error)
+	DescribeNetworkInterfaceAttribute(ctx context.Context, params *ec2.DescribeNetworkInterfaceAttributeInput, optFns ...func(*ec2.Options)) (*ec2.DescribeNetworkInterfaceAttributeOutput, error)
+	DescribeNetworkInterfaces(ctx context.Context, params *ec2.DescribeNetworkInterfacesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeNetworkInterfacesOutput, error)
+	DescribePublicIpv4Pools(context.Context, *ec2.DescribePublicIpv4PoolsInput, ...func(*ec2.Options)) (*ec2.DescribePublicIpv4PoolsOutput, error)
+	DescribeRouteTables(ctx context.Context, params *ec2.DescribeRouteTablesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeRouteTablesOutput, error)
+	DescribeSecurityGroups(ctx context.Context, params *ec2.DescribeSecurityGroupsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeSecurityGroupsOutput, error)
+	DescribeSubnets(ctx context.Context, params *ec2.DescribeSubnetsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeSubnetsOutput, error)
+	DescribeVpcs(ctx context.Context, params *ec2.DescribeVpcsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcsOutput, error)
+	DescribeVpcAttribute(ctx context.Context, params *ec2.DescribeVpcAttributeInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcAttributeOutput, error)
+	DescribeVpcEndpoints(ctx context.Context, params *ec2.DescribeVpcEndpointsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointsOutput, error)
+	DetachInternetGateway(ctx context.Context, params *ec2.DetachInternetGatewayInput, optFns ...func(*ec2.Options)) (*ec2.DetachInternetGatewayOutput, error)
+	DisassociateAddress(ctx context.Context, params *ec2.DisassociateAddressInput, optFns ...func(*ec2.Options)) (*ec2.DisassociateAddressOutput, error)
+	DisassociateRouteTable(ctx context.Context, params *ec2.DisassociateRouteTableInput, optFns ...func(*ec2.Options)) (*ec2.DisassociateRouteTableOutput, error)
+	DisassociateVpcCidrBlock(ctx context.Context, params *ec2.DisassociateVpcCidrBlockInput, optFns ...func(*ec2.Options)) (*ec2.DisassociateVpcCidrBlockOutput, error)
+	ModifyInstanceMetadataOptions(ctx context.Context, params *ec2.ModifyInstanceMetadataOptionsInput, optFns ...func(*ec2.Options)) (*ec2.ModifyInstanceMetadataOptionsOutput, error)
+	ModifyNetworkInterfaceAttribute(ctx context.Context, params *ec2.ModifyNetworkInterfaceAttributeInput, optFns ...func(*ec2.Options)) (*ec2.ModifyNetworkInterfaceAttributeOutput, error)
+	ModifySubnetAttribute(ctx context.Context, params *ec2.ModifySubnetAttributeInput, optFns ...func(*ec2.Options)) (*ec2.ModifySubnetAttributeOutput, error)
+	ModifyVpcAttribute(ctx context.Context, params *ec2.ModifyVpcAttributeInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVpcAttributeOutput, error)
+	ModifyVpcEndpoint(ctx context.Context, params *ec2.ModifyVpcEndpointInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVpcEndpointOutput, error)
+	ReleaseAddress(ctx context.Context, params *ec2.ReleaseAddressInput, optFns ...func(*ec2.Options)) (*ec2.ReleaseAddressOutput, error)
+	ReplaceRoute(ctx context.Context, params *ec2.ReplaceRouteInput, optFns ...func(*ec2.Options)) (*ec2.ReplaceRouteOutput, error)
+	RevokeSecurityGroupEgress(ctx context.Context, params *ec2.RevokeSecurityGroupEgressInput, optFns ...func(*ec2.Options)) (*ec2.RevokeSecurityGroupEgressOutput, error)
+	RevokeSecurityGroupIngress(ctx context.Context, params *ec2.RevokeSecurityGroupIngressInput, optFns ...func(*ec2.Options)) (*ec2.RevokeSecurityGroupIngressOutput, error)
+	RunInstances(ctx context.Context, params *ec2.RunInstancesInput, optFns ...func(*ec2.Options)) (*ec2.RunInstancesOutput, error)
+	TerminateInstances(ctx context.Context, params *ec2.TerminateInstancesInput, optFns ...func(*ec2.Options)) (*ec2.TerminateInstancesOutput, error)
+}
diff --git a/pkg/cloud/services/ec2/ami.go b/pkg/cloud/services/ec2/ami.go
index d46311abb..e6f476b78 100644
--- a/pkg/cloud/services/ec2/ami.go
+++ b/pkg/cloud/services/ec2/ami.go
@@ -25,16 +25,17 @@ import (
 	"text/template"
 	"time"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go-v2/service/ssm"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
 	"github.com/blang/semver"
 	"github.com/pkg/errors"
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/cmd/clusterawsadm/api/bootstrap/v1beta1"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/awserrors"
+	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/common"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/record"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/util/system"
 )
@@ -122,11 +123,11 @@ func GenerateAmiName(amiNameFormat, baseOS, kubernetesVersion string) (string, e
 }
 
 // Determine architecture based on instance type.
-func (s *Service) pickArchitectureForInstanceType(instanceType string) (string, error) {
+func (s *Service) pickArchitectureForInstanceType(instanceType ec2types.InstanceType) (string, error) {
 	descInstanceTypeInput := &ec2.DescribeInstanceTypesInput{
-		InstanceTypes: []*string{&instanceType},
+		InstanceTypes: []ec2types.InstanceType{instanceType},
 	}
-	describeInstanceTypeResult, err := s.EC2Client.DescribeInstanceTypesWithContext(context.TODO(), descInstanceTypeInput)
+	describeInstanceTypeResult, err := s.EC2Client.DescribeInstanceTypes(context.TODO(), descInstanceTypeInput)
 	if err != nil {
 		// if call to DescribeInstanceTypes fails due to permissions error, log a warning and return the default architecture.
 		if awserrors.IsPermissionsError(err) {
@@ -150,12 +151,12 @@ func (s *Service) pickArchitectureForInstanceType(instanceType string) (string,
 	architecture := ""
 archCheck:
 	for _, a := range supportedArchs {
-		switch *a {
+		switch a {
 		case Amd64ArchitectureTag:
-			architecture = *a
+			architecture = string(a)
 			break archCheck
 		case Arm64ArchitectureTag:
-			architecture = *a
+			architecture = string(a)
 			break archCheck
 		}
 	}
@@ -170,7 +171,7 @@ archCheck:
 }
 
 // DefaultAMILookup will do a default AMI lookup.
-func DefaultAMILookup(ec2Client ec2iface.EC2API, ownerID, baseOS, kubernetesVersion, architecture, amiNameFormat string) (*ec2.Image, error) {
+func DefaultAMILookup(ec2Client common.EC2API, ownerID, baseOS, kubernetesVersion, architecture, amiNameFormat string) (*ec2types.Image, error) {
 	if amiNameFormat == "" {
 		amiNameFormat = DefaultAmiNameFormat
 	}
@@ -186,31 +187,31 @@ func DefaultAMILookup(ec2Client ec2iface.EC2API, ownerID, baseOS, kubernetesVers
 		return nil, errors.Wrapf(err, "failed to process ami format: %q", amiNameFormat)
 	}
 	describeImageInput := &ec2.DescribeImagesInput{
-		Filters: []*ec2.Filter{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("owner-id"),
-				Values: []*string{aws.String(ownerID)},
+				Values: []string{ownerID},
 			},
 			{
 				Name:   aws.String("name"),
-				Values: []*string{aws.String(amiName)},
+				Values: []string{amiName},
 			},
 			{
 				Name:   aws.String("architecture"),
-				Values: []*string{aws.String(architecture)},
+				Values: []string{architecture},
 			},
 			{
 				Name:   aws.String("state"),
-				Values: []*string{aws.String("available")},
+				Values: []string{"available"},
 			},
 			{
 				Name:   aws.String("virtualization-type"),
-				Values: []*string{aws.String("hvm")},
+				Values: []string{"hvm"},
 			},
 		},
 	}
 
-	out, err := ec2Client.DescribeImagesWithContext(context.TODO(), describeImageInput)
+	out, err := ec2Client.DescribeImages(context.TODO(), describeImageInput)
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed to find ami: %q", amiName)
 	}
@@ -237,7 +238,7 @@ func (s *Service) defaultAMIIDLookup(amiNameFormat, ownerID, baseOS, architectur
 	return aws.StringValue(latestImage.ImageId), nil
 }
 
-type images []*ec2.Image
+type images []ec2types.Image
 
 // Len is the number of elements in the collection.
 func (i images) Len() int {
@@ -259,7 +260,7 @@ func (i images) Swap(k, j int) {
 }
 
 // GetLatestImage assumes imgs is not empty. Responsibility of the caller to check.
-func GetLatestImage(imgs []*ec2.Image) (*ec2.Image, error) {
+func GetLatestImage(imgs []ec2types.Image) (*ec2types.Image, error) {
 	for _, img := range imgs {
 		if _, err := time.Parse(createDateTimestampFormat, aws.StringValue(img.CreationDate)); err != nil {
 			return nil, err
@@ -267,27 +268,27 @@ func GetLatestImage(imgs []*ec2.Image) (*ec2.Image, error) {
 	}
 	// old to new (newest one is last)
 	sort.Sort(images(imgs))
-	return imgs[len(imgs)-1], nil
+	return &imgs[len(imgs)-1], nil
 }
 
 func (s *Service) defaultBastionAMILookup() (string, error) {
 	describeImageInput := &ec2.DescribeImagesInput{
-		Filters: []*ec2.Filter{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("architecture"),
-				Values: []*string{aws.String("x86_64")},
+				Values: []string{"x86_64"},
 			},
 			{
 				Name:   aws.String("state"),
-				Values: []*string{aws.String("available")},
+				Values: []string{"available"},
 			},
 			{
 				Name:   aws.String("virtualization-type"),
-				Values: []*string{aws.String("hvm")},
+				Values: []string{"hvm"},
 			},
 			{
 				Name:   aws.String("description"),
-				Values: aws.StringSlice([]string{ubuntuImageDescription}),
+				Values: []string{ubuntuImageDescription},
 			},
 		},
 	}
@@ -298,13 +299,13 @@ func (s *Service) defaultBastionAMILookup() (string, error) {
 		ownerID = ubuntuOwnerIDUsGov
 	}
 
-	filter := &ec2.Filter{
+	filter := ec2types.Filter{
 		Name:   aws.String("owner-id"),
-		Values: []*string{aws.String(ownerID)},
+		Values: []string{ownerID},
 	}
 	describeImageInput.Filters = append(describeImageInput.Filters, filter)
 
-	out, err := s.EC2Client.DescribeImagesWithContext(context.TODO(), describeImageInput)
+	out, err := s.EC2Client.DescribeImages(context.TODO(), describeImageInput)
 	if err != nil {
 		return "", errors.Wrapf(err, "failed to describe images within region: %q", s.scope.Region())
 	}
diff --git a/pkg/cloud/services/ec2/bastion.go b/pkg/cloud/services/ec2/bastion.go
index 77349edb0..72c4f7fd0 100644
--- a/pkg/cloud/services/ec2/bastion.go
+++ b/pkg/cloud/services/ec2/bastion.go
@@ -22,8 +22,9 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/pkg/errors"
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
@@ -136,19 +137,19 @@ func (s *Service) DeleteBastion() error {
 
 func (s *Service) describeBastionInstance() (*infrav1.Instance, error) {
 	input := &ec2.DescribeInstancesInput{
-		Filters: []*ec2.Filter{
+		Filters: []types.Filter{
 			filter.EC2.ProviderRole(infrav1.BastionRoleTagValue),
 			filter.EC2.Cluster(s.scope.Name()),
 			filter.EC2.InstanceStates(
-				ec2.InstanceStateNamePending,
-				ec2.InstanceStateNameRunning,
-				ec2.InstanceStateNameStopping,
-				ec2.InstanceStateNameStopped,
+				types.InstanceStateNamePending,
+				types.InstanceStateNameRunning,
+				types.InstanceStateNameStopping,
+				types.InstanceStateNameStopped,
 			),
 		},
 	}
 
-	out, err := s.EC2Client.DescribeInstancesWithContext(context.TODO(), input)
+	out, err := s.EC2Client.DescribeInstances(context.TODO(), input)
 	if err != nil {
 		record.Eventf(s.scope.InfraCluster(), "FailedDescribeBastionHost", "Failed to describe bastion host: %v", err)
 		return nil, errors.Wrap(err, "failed to describe bastion host")
@@ -158,7 +159,7 @@ func (s *Service) describeBastionInstance() (*infrav1.Instance, error) {
 	// the first non-terminated.
 	for _, res := range out.Reservations {
 		for _, instance := range res.Instances {
-			if aws.StringValue(instance.State.Name) != ec2.InstanceStateNameTerminated {
+			if instance.State.Name != types.InstanceStateNameTerminated {
 				return s.SDKToInstance(instance)
 			}
 		}
diff --git a/pkg/cloud/services/ec2/eip.go b/pkg/cloud/services/ec2/eip.go
index d638ace37..2822ae80b 100644
--- a/pkg/cloud/services/ec2/eip.go
+++ b/pkg/cloud/services/ec2/eip.go
@@ -4,8 +4,8 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"k8s.io/utils/ptr"
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
@@ -77,7 +77,7 @@ func (s *Service) getAndAssociateAddressesToInstance(pool *infrav1.ElasticIPPool
 		record.Warnf(s.scope.InfraCluster(), "FailedAllocateEIP", "Failed to allocate Elastic IP for %q: %v", role, err)
 		return fmt.Errorf("unexpected number of Elastic IP to instance %q, got %d: %w", instance, len(eips), err)
 	}
-	_, err = s.EC2Client.AssociateAddressWithContext(context.TODO(), &ec2.AssociateAddressInput{
+	_, err = s.EC2Client.AssociateAddress(context.TODO(), &ec2.AssociateAddressInput{
 		InstanceId:   aws.String(instance),
 		AllocationId: aws.String(eips[0]),
 	})
diff --git a/pkg/cloud/services/ec2/instances.go b/pkg/cloud/services/ec2/instances.go
index fc4568e0d..8245f9a61 100644
--- a/pkg/cloud/services/ec2/instances.go
+++ b/pkg/cloud/services/ec2/instances.go
@@ -22,10 +22,11 @@ import (
 	"fmt"
 	"sort"
 	"strings"
+	"time"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/pkg/errors"
 	"k8s.io/utils/ptr"
 
@@ -34,8 +35,10 @@ import (
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/converters"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/filter"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope"
+	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/common"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/userdata"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/record"
+	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/utils"
 	clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
 )
 
@@ -44,14 +47,14 @@ func (s *Service) GetRunningInstanceByTags(scope *scope.MachineScope) (*infrav1.
 	s.scope.Debug("Looking for existing machine instance by tags")
 
 	input := &ec2.DescribeInstancesInput{
-		Filters: []*ec2.Filter{
+		Filters: []types.Filter{
 			filter.EC2.ClusterOwned(s.scope.Name()),
 			filter.EC2.Name(scope.Name()),
-			filter.EC2.InstanceStates(ec2.InstanceStateNamePending, ec2.InstanceStateNameRunning),
+			filter.EC2.InstanceStates(types.InstanceStateNamePending, types.InstanceStateNameRunning),
 		},
 	}
 
-	out, err := s.EC2Client.DescribeInstancesWithContext(context.TODO(), input)
+	out, err := s.EC2Client.DescribeInstances(context.TODO(), input)
 	switch {
 	case awserrors.IsNotFound(err):
 		return nil, nil
@@ -83,10 +86,10 @@ func (s *Service) InstanceIfExists(id *string) (*infrav1.Instance, error) {
 	s.scope.Debug("Looking for instance by id", "instance-id", *id)
 
 	input := &ec2.DescribeInstancesInput{
-		InstanceIds: []*string{id},
+		InstanceIds: []string{aws.ToString(id)},
 	}
 
-	out, err := s.EC2Client.DescribeInstancesWithContext(context.TODO(), input)
+	out, err := s.EC2Client.DescribeInstances(context.TODO(), input)
 	switch {
 	case awserrors.IsNotFound(err):
 		record.Eventf(s.scope.InfraCluster(), "FailedFindInstances", "failed to find instance by providerId %q: %v", *id, err)
@@ -132,7 +135,7 @@ func (s *Service) CreateInstance(ctx context.Context, scope *scope.MachineScope,
 
 	var err error
 
-	imageArchitecture, err := s.pickArchitectureForInstanceType(input.Type)
+	imageArchitecture, err := s.pickArchitectureForInstanceType(types.InstanceType(input.Type))
 	if err != nil {
 		return nil, err
 	}
@@ -320,28 +323,28 @@ func (s *Service) findSubnet(scope *scope.MachineScope) (string, error) {
 
 	switch {
 	case scope.AWSMachine.Spec.Subnet != nil && (scope.AWSMachine.Spec.Subnet.ID != nil || scope.AWSMachine.Spec.Subnet.Filters != nil):
-		criteria := []*ec2.Filter{
-			filter.EC2.SubnetStates(ec2.SubnetStatePending, ec2.SubnetStateAvailable),
+		criteria := []types.Filter{
+			filter.EC2.SubnetStates(types.SubnetStatePending, types.SubnetStateAvailable),
 		}
 		if scope.AWSMachine.Spec.Subnet.ID != nil {
-			criteria = append(criteria, &ec2.Filter{Name: aws.String("subnet-id"), Values: aws.StringSlice([]string{*scope.AWSMachine.Spec.Subnet.ID})})
+			criteria = append(criteria, types.Filter{Name: aws.String("subnet-id"), Values: []string{*scope.AWSMachine.Spec.Subnet.ID}})
 		}
 		for _, f := range scope.AWSMachine.Spec.Subnet.Filters {
-			criteria = append(criteria, &ec2.Filter{Name: aws.String(f.Name), Values: aws.StringSlice(f.Values)})
+			criteria = append(criteria, types.Filter{Name: aws.String(f.Name), Values: f.Values})
 		}
 
 		subnets, err := s.getFilteredSubnets(criteria...)
 		if err != nil {
-			return "", errors.Wrapf(err, "failed to filter subnets for criteria %q", criteria)
+			return "", errors.Wrapf(err, "failed to filter subnets for criteria %v", criteria)
 		}
 		if len(subnets) == 0 {
-			errMessage := fmt.Sprintf("failed to run machine %q, no subnets available matching criteria %q",
+			errMessage := fmt.Sprintf("failed to run machine %q, no subnets available matching criteria %v",
 				scope.Name(), criteria)
 			record.Warnf(scope.AWSMachine, "FailedCreate", errMessage)
 			return "", awserrors.NewFailedDependency(errMessage)
 		}
 
-		var filtered []*ec2.Subnet
+		var filtered []types.Subnet
 		var errMessage string
 		for _, subnet := range subnets {
 			if failureDomain != nil && *subnet.AvailabilityZone != *failureDomain {
@@ -428,8 +431,8 @@ func (s *Service) findSubnet(scope *scope.MachineScope) (string, error) {
 }
 
 // getFilteredSubnets fetches subnets filtered based on the criteria passed.
-func (s *Service) getFilteredSubnets(criteria ...*ec2.Filter) ([]*ec2.Subnet, error) {
-	out, err := s.EC2Client.DescribeSubnetsWithContext(context.TODO(), &ec2.DescribeSubnetsInput{Filters: criteria})
+func (s *Service) getFilteredSubnets(criteria ...types.Filter) ([]types.Subnet, error) {
+	out, err := s.EC2Client.DescribeSubnets(context.TODO(), &ec2.DescribeSubnetsInput{Filters: criteria})
 	if err != nil {
 		return nil, err
 	}
@@ -517,10 +520,10 @@ func (s *Service) TerminateInstance(instanceID string) error {
 	s.scope.Debug("Attempting to terminate instance", "instance-id", instanceID)
 
 	input := &ec2.TerminateInstancesInput{
-		InstanceIds: aws.StringSlice([]string{instanceID}),
+		InstanceIds: []string{instanceID},
 	}
 
-	if _, err := s.EC2Client.TerminateInstancesWithContext(context.TODO(), input); err != nil {
+	if _, err := s.EC2Client.TerminateInstances(context.TODO(), input); err != nil {
 		return errors.Wrapf(err, "failed to terminate instance with id %q", instanceID)
 	}
 
@@ -538,10 +541,10 @@ func (s *Service) TerminateInstanceAndWait(instanceID string) error {
 	s.scope.Debug("Waiting for EC2 instance to terminate", "instance-id", instanceID)
 
 	input := &ec2.DescribeInstancesInput{
-		InstanceIds: aws.StringSlice([]string{instanceID}),
+		InstanceIds: []string{instanceID},
 	}
 
-	if err := s.EC2Client.WaitUntilInstanceTerminatedWithContext(context.TODO(), input); err != nil {
+	if err := ec2.NewInstanceTerminatedWaiter(s.EC2Client).Wait(context.TODO(), input, time.Minute*2); err != nil {
 		return errors.Wrapf(err, "failed to wait for instance %q termination", instanceID)
 	}
 
@@ -550,35 +553,35 @@ func (s *Service) TerminateInstanceAndWait(instanceID string) error {
 
 func (s *Service) runInstance(role string, i *infrav1.Instance) (*infrav1.Instance, error) {
 	input := &ec2.RunInstancesInput{
-		InstanceType: aws.String(i.Type),
+		InstanceType: types.InstanceType(i.Type),
 		ImageId:      aws.String(i.ImageID),
 		KeyName:      i.SSHKeyName,
 		EbsOptimized: i.EBSOptimized,
-		MaxCount:     aws.Int64(1),
-		MinCount:     aws.Int64(1),
+		MaxCount:     aws.Int32(1),
+		MinCount:     aws.Int32(1),
 		UserData:     i.UserData,
 	}
 
 	s.scope.Debug("userData size", "bytes", len(*i.UserData), "role", role)
 
 	if len(i.NetworkInterfaces) > 0 {
-		netInterfaces := make([]*ec2.InstanceNetworkInterfaceSpecification, 0, len(i.NetworkInterfaces))
+		netInterfaces := make([]types.InstanceNetworkInterfaceSpecification, 0, len(i.NetworkInterfaces))
 
 		for index, id := range i.NetworkInterfaces {
-			netInterfaces = append(netInterfaces, &ec2.InstanceNetworkInterfaceSpecification{
+			netInterfaces = append(netInterfaces, types.InstanceNetworkInterfaceSpecification{
 				NetworkInterfaceId: aws.String(id),
-				DeviceIndex:        aws.Int64(int64(index)),
+				DeviceIndex:        aws.Int32(int32(index)), //nolint:gosec // disable G115
 			})
 		}
 		netInterfaces[0].AssociatePublicIpAddress = i.PublicIPOnLaunch
 
 		input.NetworkInterfaces = netInterfaces
 	} else {
-		input.NetworkInterfaces = []*ec2.InstanceNetworkInterfaceSpecification{
+		input.NetworkInterfaces = []types.InstanceNetworkInterfaceSpecification{
 			{
-				DeviceIndex:              aws.Int64(0),
+				DeviceIndex:              aws.Int32(0),
 				SubnetId:                 aws.String(i.SubnetID),
-				Groups:                   aws.StringSlice(i.SecurityGroupIDs),
+				Groups:                   i.SecurityGroupIDs,
 				AssociatePublicIpAddress: i.PublicIPOnLaunch,
 			},
 		}
@@ -589,12 +592,12 @@ func (s *Service) runInstance(role string, i *infrav1.Instance) (*infrav1.Instan
 	}
 
 	if i.IAMProfile != "" {
-		input.IamInstanceProfile = &ec2.IamInstanceProfileSpecification{
+		input.IamInstanceProfile = &types.IamInstanceProfileSpecification{
 			Name: aws.String(i.IAMProfile),
 		}
 	}
 
-	blockdeviceMappings := []*ec2.BlockDeviceMapping{}
+	blockdeviceMappings := []types.BlockDeviceMapping{}
 
 	if i.RootVolume != nil {
 		rootDeviceName, err := s.checkRootVolume(i.RootVolume, i.ImageID)
@@ -602,7 +605,7 @@ func (s *Service) runInstance(role string, i *infrav1.Instance) (*infrav1.Instan
 			return nil, err
 		}
 
-		i.RootVolume.DeviceName = aws.StringValue(rootDeviceName)
+		i.RootVolume.DeviceName = aws.ToString(rootDeviceName)
 		blockDeviceMapping := volumeToBlockDeviceMapping(i.RootVolume)
 		blockdeviceMappings = append(blockdeviceMappings, blockDeviceMapping)
 	}
@@ -623,9 +626,9 @@ func (s *Service) runInstance(role string, i *infrav1.Instance) (*infrav1.Instan
 	}
 
 	if len(i.Tags) > 0 {
-		resources := []string{ec2.ResourceTypeInstance, ec2.ResourceTypeVolume, ec2.ResourceTypeNetworkInterface}
+		resources := []types.ResourceType{types.ResourceTypeInstance, types.ResourceTypeVolume, types.ResourceTypeNetworkInterface}
 		for _, r := range resources {
-			spec := &ec2.TagSpecification{ResourceType: aws.String(r)}
+			spec := types.TagSpecification{ResourceType: r}
 
 			// We need to sort keys for tests to work
 			keys := make([]string, 0, len(i.Tags))
@@ -634,7 +637,7 @@ func (s *Service) runInstance(role string, i *infrav1.Instance) (*infrav1.Instan
 			}
 			sort.Strings(keys)
 			for _, key := range keys {
-				spec.Tags = append(spec.Tags, &ec2.Tag{
+				spec.Tags = append(spec.Tags, types.Tag{
 					Key:   aws.String(key),
 					Value: aws.String(i.Tags[key]),
 				})
@@ -655,8 +658,8 @@ func (s *Service) runInstance(role string, i *infrav1.Instance) (*infrav1.Instan
 	input.CapacityReservationSpecification = getCapacityReservationSpecification(i.CapacityReservationID)
 
 	if i.Tenancy != "" {
-		input.Placement = &ec2.Placement{
-			Tenancy: &i.Tenancy,
+		input.Placement = &types.Placement{
+			Tenancy: types.Tenancy(i.Tenancy),
 		}
 	}
 
@@ -666,39 +669,39 @@ func (s *Service) runInstance(role string, i *infrav1.Instance) (*infrav1.Instan
 
 	if i.PlacementGroupName != "" {
 		if input.Placement == nil {
-			input.Placement = &ec2.Placement{}
+			input.Placement = &types.Placement{}
 		}
 		input.Placement.GroupName = &i.PlacementGroupName
 		if i.PlacementGroupPartition != 0 {
-			input.Placement.PartitionNumber = &i.PlacementGroupPartition
+			input.Placement.PartitionNumber = utils.ToInt32Pointer(&i.PlacementGroupPartition)
 		}
 	}
 
-	out, err := s.EC2Client.RunInstancesWithContext(context.TODO(), input)
+	out, err := s.EC2Client.RunInstances(context.TODO(), input)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to run instance")
 	}
 
 	if len(out.Instances) == 0 {
-		return nil, errors.Errorf("no instance returned for reservation %v", out.GoString())
+		return nil, errors.Errorf("no instance returned for reservation %v", out)
 	}
 
 	return s.SDKToInstance(out.Instances[0])
 }
 
-func volumeToBlockDeviceMapping(v *infrav1.Volume) *ec2.BlockDeviceMapping {
-	ebsDevice := &ec2.EbsBlockDevice{
+func volumeToBlockDeviceMapping(v *infrav1.Volume) types.BlockDeviceMapping {
+	ebsDevice := &types.EbsBlockDevice{
 		DeleteOnTermination: aws.Bool(true),
-		VolumeSize:          aws.Int64(v.Size),
+		VolumeSize:          utils.ToInt32Pointer(&v.Size),
 		Encrypted:           v.Encrypted,
 	}
 
 	if v.Throughput != nil {
-		ebsDevice.Throughput = v.Throughput
+		ebsDevice.Throughput = utils.ToInt32Pointer(v.Throughput)
 	}
 
 	if v.IOPS != 0 {
-		ebsDevice.Iops = aws.Int64(v.IOPS)
+		ebsDevice.Iops = utils.ToInt32Pointer(&v.IOPS)
 	}
 
 	if v.EncryptionKey != "" {
@@ -707,10 +710,10 @@ func volumeToBlockDeviceMapping(v *infrav1.Volume) *ec2.BlockDeviceMapping {
 	}
 
 	if v.Type != "" {
-		ebsDevice.VolumeType = aws.String(string(v.Type))
+		ebsDevice.VolumeType = types.VolumeType(string(v.Type))
 	}
 
-	return &ec2.BlockDeviceMapping{
+	return types.BlockDeviceMapping{
 		DeviceName: &v.DeviceName,
 		Ebs:        ebsDevice,
 	}
@@ -728,9 +731,9 @@ func (s *Service) GetInstanceSecurityGroups(instanceID string) (map[string][]str
 	for _, eni := range enis {
 		var groups []string
 		for _, group := range eni.Groups {
-			groups = append(groups, aws.StringValue(group.GroupId))
+			groups = append(groups, aws.ToString(group.GroupId))
 		}
-		out[aws.StringValue(eni.NetworkInterfaceId)] = groups
+		out[aws.ToString(eni.NetworkInterfaceId)] = groups
 	}
 	return out, nil
 }
@@ -748,7 +751,7 @@ func (s *Service) UpdateInstanceSecurityGroups(instanceID string, ids []string)
 	s.scope.Debug("Found ENIs on instance", "number-of-enis", len(enis), "instance-id", instanceID)
 
 	for _, eni := range enis {
-		if err := s.attachSecurityGroupsToNetworkInterface(ids, aws.StringValue(eni.NetworkInterfaceId)); err != nil {
+		if err := s.attachSecurityGroupsToNetworkInterface(ids, aws.ToString(eni.NetworkInterfaceId)); err != nil {
 			return errors.Wrapf(err, "failed to modify network interfaces on instance %q", instanceID)
 		}
 	}
@@ -761,60 +764,60 @@ func (s *Service) UpdateInstanceSecurityGroups(instanceID string, ids []string)
 // We may not always have to perform each action, so we check what we're
 // receiving to avoid calling AWS if we don't need to.
 func (s *Service) UpdateResourceTags(resourceID *string, create, remove map[string]string) error {
-	s.scope.Debug("Attempting to update tags on resource", "resource-id", *resourceID)
+	s.scope.Debug("Attempting to update tags on resource", "resource-id", aws.ToString(resourceID))
 
 	// If we have anything to create or update
 	if len(create) > 0 {
-		s.scope.Debug("Attempting to create tags on resource", "resource-id", *resourceID)
+		s.scope.Debug("Attempting to create tags on resource", "resource-id", aws.ToString(resourceID))
 
 		// Convert our create map into an array of *ec2.Tag
 		createTagsInput := converters.MapToTags(create)
 
 		// Create the CreateTags input.
 		input := &ec2.CreateTagsInput{
-			Resources: []*string{resourceID},
+			Resources: []string{aws.ToString(resourceID)},
 			Tags:      createTagsInput,
 		}
 
 		// Create/Update tags in AWS.
-		if _, err := s.EC2Client.CreateTagsWithContext(context.TODO(), input); err != nil {
-			return errors.Wrapf(err, "failed to create tags for resource %q: %+v", *resourceID, create)
+		if _, err := s.EC2Client.CreateTags(context.TODO(), input); err != nil {
+			return errors.Wrapf(err, "failed to create tags for resource %q: %+v", aws.ToString(resourceID), create)
 		}
 	}
 
 	// If we have anything to remove
 	if len(remove) > 0 {
-		s.scope.Debug("Attempting to delete tags on resource", "resource-id", *resourceID)
+		s.scope.Debug("Attempting to delete tags on resource", "resource-id", aws.ToString(resourceID))
 
 		// Convert our remove map into an array of *ec2.Tag
 		removeTagsInput := converters.MapToTags(remove)
 
 		// Create the DeleteTags input
 		input := &ec2.DeleteTagsInput{
-			Resources: []*string{resourceID},
+			Resources: []string{aws.ToString(resourceID)},
 			Tags:      removeTagsInput,
 		}
 
 		// Delete tags in AWS.
-		if _, err := s.EC2Client.DeleteTagsWithContext(context.TODO(), input); err != nil {
-			return errors.Wrapf(err, "failed to delete tags for resource %q: %v", *resourceID, remove)
+		if _, err := s.EC2Client.DeleteTags(context.TODO(), input); err != nil {
+			return errors.Wrapf(err, "failed to delete tags for resource %q: %v", aws.ToString(resourceID), remove)
 		}
 	}
 
 	return nil
 }
 
-func (s *Service) getInstanceENIs(instanceID string) ([]*ec2.NetworkInterface, error) {
+func (s *Service) getInstanceENIs(instanceID string) ([]types.NetworkInterface, error) {
 	input := &ec2.DescribeNetworkInterfacesInput{
-		Filters: []*ec2.Filter{
+		Filters: []types.Filter{
 			{
 				Name:   aws.String("attachment.instance-id"),
-				Values: []*string{aws.String(instanceID)},
+				Values: []string{instanceID},
 			},
 		},
 	}
 
-	output, err := s.EC2Client.DescribeNetworkInterfacesWithContext(context.TODO(), input)
+	output, err := s.EC2Client.DescribeNetworkInterfaces(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
@@ -824,10 +827,10 @@ func (s *Service) getInstanceENIs(instanceID string) ([]*ec2.NetworkInterface, e
 
 func (s *Service) getImageRootDevice(imageID string) (*string, error) {
 	input := &ec2.DescribeImagesInput{
-		ImageIds: []*string{aws.String(imageID)},
+		ImageIds: []string{imageID},
 	}
 
-	output, err := s.EC2Client.DescribeImagesWithContext(context.TODO(), input)
+	output, err := s.EC2Client.DescribeImages(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
@@ -839,12 +842,12 @@ func (s *Service) getImageRootDevice(imageID string) (*string, error) {
 	return output.Images[0].RootDeviceName, nil
 }
 
-func (s *Service) getImageSnapshotSize(imageID string) (*int64, error) {
+func (s *Service) getImageSnapshotSize(imageID string) (*int32, error) {
 	input := &ec2.DescribeImagesInput{
-		ImageIds: []*string{aws.String(imageID)},
+		ImageIds: []string{imageID},
 	}
 
-	output, err := s.EC2Client.DescribeImagesWithContext(context.TODO(), input)
+	output, err := s.EC2Client.DescribeImages(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
@@ -872,13 +875,13 @@ func (s *Service) getImageSnapshotSize(imageID string) (*int64, error) {
 // SDKToInstance populates all instance fields except for rootVolumeSize,
 // because EC2.DescribeInstances does not return the size of storage devices. An
 // additional call to EC2 is required to get this value.
-func (s *Service) SDKToInstance(v *ec2.Instance) (*infrav1.Instance, error) {
+func (s *Service) SDKToInstance(v types.Instance) (*infrav1.Instance, error) {
 	i := &infrav1.Instance{
-		ID:           aws.StringValue(v.InstanceId),
-		State:        infrav1.InstanceState(*v.State.Name),
-		Type:         aws.StringValue(v.InstanceType),
-		SubnetID:     aws.StringValue(v.SubnetId),
-		ImageID:      aws.StringValue(v.ImageId),
+		ID:           aws.ToString(v.InstanceId),
+		State:        infrav1.InstanceState(string(v.State.Name)),
+		Type:         string(v.InstanceType),
+		SubnetID:     aws.ToString(v.SubnetId),
+		ImageID:      aws.ToString(v.ImageId),
 		SSHKeyName:   v.KeyName,
 		PrivateIP:    v.PrivateIpAddress,
 		PublicIP:     v.PublicIpAddress,
@@ -890,7 +893,7 @@ func (s *Service) SDKToInstance(v *ec2.Instance) (*infrav1.Instance, error) {
 	// TODO: Handle this comparison more safely, perhaps by querying IAM for the
 	// instance profile ARN and comparing to the ARN returned by EC2
 	if v.IamInstanceProfile != nil && v.IamInstanceProfile.Arn != nil {
-		split := strings.Split(aws.StringValue(v.IamInstanceProfile.Arn), "instance-profile/")
+		split := strings.Split(aws.ToString(v.IamInstanceProfile.Arn), "instance-profile/")
 		if len(split) > 1 && split[1] != "" {
 			i.IAMProfile = split[1]
 		}
@@ -906,7 +909,7 @@ func (s *Service) SDKToInstance(v *ec2.Instance) (*infrav1.Instance, error) {
 
 	i.Addresses = s.getInstanceAddresses(v)
 
-	i.AvailabilityZone = aws.StringValue(v.Placement.AvailabilityZone)
+	i.AvailabilityZone = aws.ToString(v.Placement.AvailabilityZone)
 
 	for _, volume := range v.BlockDeviceMappings {
 		i.VolumeIDs = append(i.VolumeIDs, *volume.Ebs.VolumeId)
@@ -914,17 +917,11 @@ func (s *Service) SDKToInstance(v *ec2.Instance) (*infrav1.Instance, error) {
 
 	if v.MetadataOptions != nil {
 		metadataOptions := &infrav1.InstanceMetadataOptions{}
-		if v.MetadataOptions.HttpEndpoint != nil {
-			metadataOptions.HTTPEndpoint = infrav1.InstanceMetadataState(*v.MetadataOptions.HttpEndpoint)
-		}
+		metadataOptions.HTTPEndpoint = infrav1.InstanceMetadataState(string(v.MetadataOptions.HttpEndpoint))
+		metadataOptions.HTTPTokens = infrav1.HTTPTokensState(string(v.MetadataOptions.HttpTokens))
+		metadataOptions.InstanceMetadataTags = infrav1.InstanceMetadataState(string(v.MetadataOptions.InstanceMetadataTags))
 		if v.MetadataOptions.HttpPutResponseHopLimit != nil {
-			metadataOptions.HTTPPutResponseHopLimit = *v.MetadataOptions.HttpPutResponseHopLimit
-		}
-		if v.MetadataOptions.HttpTokens != nil {
-			metadataOptions.HTTPTokens = infrav1.HTTPTokensState(*v.MetadataOptions.HttpTokens)
-		}
-		if v.MetadataOptions.InstanceMetadataTags != nil {
-			metadataOptions.InstanceMetadataTags = infrav1.InstanceMetadataState(*v.MetadataOptions.InstanceMetadataTags)
+			metadataOptions.HTTPPutResponseHopLimit = int64(*v.MetadataOptions.HttpPutResponseHopLimit)
 		}
 
 		i.InstanceMetadataOptions = metadataOptions
@@ -934,19 +931,19 @@ func (s *Service) SDKToInstance(v *ec2.Instance) (*infrav1.Instance, error) {
 		i.PrivateDNSName = &infrav1.PrivateDNSName{
 			EnableResourceNameDNSAAAARecord: v.PrivateDnsNameOptions.EnableResourceNameDnsAAAARecord,
 			EnableResourceNameDNSARecord:    v.PrivateDnsNameOptions.EnableResourceNameDnsARecord,
-			HostnameType:                    v.PrivateDnsNameOptions.HostnameType,
+			HostnameType:                    aws.String(string(v.PrivateDnsNameOptions.HostnameType)),
 		}
 	}
 
 	return i, nil
 }
 
-func (s *Service) getInstanceAddresses(instance *ec2.Instance) []clusterv1.MachineAddress {
+func (s *Service) getInstanceAddresses(instance types.Instance) []clusterv1.MachineAddress {
 	addresses := []clusterv1.MachineAddress{}
 	// Check if the DHCP Option Set has domain name set
 	domainName := s.GetDHCPOptionSetDomainName(s.EC2Client, instance.VpcId)
 	for _, eni := range instance.NetworkInterfaces {
-		if addr := aws.StringValue(eni.PrivateDnsName); addr != "" {
+		if addr := aws.ToString(eni.PrivateDnsName); addr != "" {
 			privateDNSAddress := clusterv1.MachineAddress{
 				Type:    clusterv1.MachineInternalDNS,
 				Address: addr,
@@ -963,7 +960,7 @@ func (s *Service) getInstanceAddresses(instance *ec2.Instance) []clusterv1.Machi
 			}
 		}
 
-		if addr := aws.StringValue(eni.PrivateIpAddress); addr != "" {
+		if addr := aws.ToString(eni.PrivateIpAddress); addr != "" {
 			privateIPAddress := clusterv1.MachineAddress{
 				Type:    clusterv1.MachineInternalIP,
 				Address: addr,
@@ -973,7 +970,7 @@ func (s *Service) getInstanceAddresses(instance *ec2.Instance) []clusterv1.Machi
 
 		// An elastic IP is attached if association is non nil pointer
 		if eni.Association != nil {
-			if addr := aws.StringValue(eni.Association.PublicDnsName); addr != "" {
+			if addr := aws.ToString(eni.Association.PublicDnsName); addr != "" {
 				publicDNSAddress := clusterv1.MachineAddress{
 					Type:    clusterv1.MachineExternalDNS,
 					Address: addr,
@@ -981,7 +978,7 @@ func (s *Service) getInstanceAddresses(instance *ec2.Instance) []clusterv1.Machi
 				addresses = append(addresses, publicDNSAddress)
 			}
 
-			if addr := aws.StringValue(eni.Association.PublicIp); addr != "" {
+			if addr := aws.ToString(eni.Association.PublicIp); addr != "" {
 				publicIPAddress := clusterv1.MachineAddress{
 					Type:    clusterv1.MachineExternalIP,
 					Address: addr,
@@ -996,18 +993,18 @@ func (s *Service) getInstanceAddresses(instance *ec2.Instance) []clusterv1.Machi
 
 func (s *Service) getNetworkInterfaceSecurityGroups(interfaceID string) ([]string, error) {
 	input := &ec2.DescribeNetworkInterfaceAttributeInput{
-		Attribute:          aws.String("groupSet"),
+		Attribute:          types.NetworkInterfaceAttributeGroupSet,
 		NetworkInterfaceId: aws.String(interfaceID),
 	}
 
-	output, err := s.EC2Client.DescribeNetworkInterfaceAttributeWithContext(context.TODO(), input)
+	output, err := s.EC2Client.DescribeNetworkInterfaceAttribute(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
 
 	groups := make([]string, len(output.Groups))
 	for i := range output.Groups {
-		groups[i] = aws.StringValue(output.Groups[i].GroupId)
+		groups[i] = aws.ToString(output.Groups[i].GroupId)
 	}
 
 	return groups, nil
@@ -1018,10 +1015,10 @@ func (s *Service) attachSecurityGroupsToNetworkInterface(groups []string, interf
 
 	input := &ec2.ModifyNetworkInterfaceAttributeInput{
 		NetworkInterfaceId: aws.String(interfaceID),
-		Groups:             aws.StringSlice(groups),
+		Groups:             groups,
 	}
 
-	if _, err := s.EC2Client.ModifyNetworkInterfaceAttributeWithContext(context.TODO(), input); err != nil {
+	if _, err := s.EC2Client.ModifyNetworkInterfaceAttribute(context.TODO(), input); err != nil {
 		return errors.Wrapf(err, "failed to modify interface %q to have security groups %v", interfaceID, groups)
 	}
 	return nil
@@ -1042,10 +1039,10 @@ func (s *Service) DetachSecurityGroupsFromNetworkInterface(groups []string, inte
 
 	input := &ec2.ModifyNetworkInterfaceAttributeInput{
 		NetworkInterfaceId: aws.String(interfaceID),
-		Groups:             aws.StringSlice(remainingGroups),
+		Groups:             remainingGroups,
 	}
 
-	if _, err := s.EC2Client.ModifyNetworkInterfaceAttributeWithContext(context.TODO(), input); err != nil {
+	if _, err := s.EC2Client.ModifyNetworkInterfaceAttribute(context.TODO(), input); err != nil {
 		return errors.Wrapf(err, "failed to modify interface %q", interfaceID)
 	}
 	return nil
@@ -1064,7 +1061,7 @@ func (s *Service) checkRootVolume(rootVolume *infrav1.Volume, imageID string) (*
 		return nil, errors.Wrapf(err, "failed to get root volume from image %q", imageID)
 	}
 
-	if rootVolume.Size < *snapshotSize {
+	if rootVolume.Size < int64(*snapshotSize) {
 		return nil, errors.Errorf("root volume size (%d) must be greater than or equal to snapshot size (%d)", rootVolume.Size, *snapshotSize)
 	}
 
@@ -1074,15 +1071,15 @@ func (s *Service) checkRootVolume(rootVolume *infrav1.Volume, imageID string) (*
 // ModifyInstanceMetadataOptions modifies the metadata options of the given EC2 instance.
 func (s *Service) ModifyInstanceMetadataOptions(instanceID string, options *infrav1.InstanceMetadataOptions) error {
 	input := &ec2.ModifyInstanceMetadataOptionsInput{
-		HttpEndpoint:            aws.String(string(options.HTTPEndpoint)),
-		HttpPutResponseHopLimit: aws.Int64(options.HTTPPutResponseHopLimit),
-		HttpTokens:              aws.String(string(options.HTTPTokens)),
-		InstanceMetadataTags:    aws.String(string(options.InstanceMetadataTags)),
+		HttpEndpoint:            types.InstanceMetadataEndpointState(string(options.HTTPEndpoint)),
+		HttpPutResponseHopLimit: utils.ToInt32Pointer(&options.HTTPPutResponseHopLimit),
+		HttpTokens:              types.HttpTokensState(string(options.HTTPTokens)),
+		InstanceMetadataTags:    types.InstanceMetadataTagsState(string(options.InstanceMetadataTags)),
 		InstanceId:              aws.String(instanceID),
 	}
 
 	s.scope.Info("Updating instance metadata options", "instance id", instanceID, "options", input)
-	if _, err := s.EC2Client.ModifyInstanceMetadataOptionsWithContext(context.TODO(), input); err != nil {
+	if _, err := s.EC2Client.ModifyInstanceMetadataOptions(context.TODO(), input); err != nil {
 		return err
 	}
 
@@ -1090,7 +1087,7 @@ func (s *Service) ModifyInstanceMetadataOptions(instanceID string, options *infr
 }
 
 // GetDHCPOptionSetDomainName returns the domain DNS name for the VPC from the DHCP Options.
-func (s *Service) GetDHCPOptionSetDomainName(ec2client ec2iface.EC2API, vpcID *string) *string {
+func (s *Service) GetDHCPOptionSetDomainName(ec2client common.EC2API, vpcID *string) *string {
 	log := s.scope.GetLogger()
 
 	if vpcID == nil {
@@ -1099,34 +1096,34 @@ func (s *Service) GetDHCPOptionSetDomainName(ec2client ec2iface.EC2API, vpcID *s
 	}
 
 	vpcInput := &ec2.DescribeVpcsInput{
-		VpcIds: []*string{vpcID},
+		VpcIds: []string{aws.ToString(vpcID)},
 	}
 
-	vpcResult, err := ec2client.DescribeVpcs(vpcInput)
+	vpcResult, err := ec2client.DescribeVpcs(context.TODO(), vpcInput)
 	if err != nil {
-		log.Info("failed to describe VPC, skipping DHCP Option Set discovery", "vpcID", *vpcID, "Error", err.Error())
+		log.Info("failed to describe VPC, skipping DHCP Option Set discovery", "vpcID", aws.ToString(vpcID), "Error", err.Error())
 		return nil
 	}
 
 	dhcpInput := &ec2.DescribeDhcpOptionsInput{
-		DhcpOptionsIds: []*string{vpcResult.Vpcs[0].DhcpOptionsId},
+		DhcpOptionsIds: []string{aws.ToString(vpcResult.Vpcs[0].DhcpOptionsId)},
 	}
 
-	dhcpResult, err := ec2client.DescribeDhcpOptions(dhcpInput)
+	dhcpResult, err := ec2client.DescribeDhcpOptions(context.TODO(), dhcpInput)
 	if err != nil {
 		log.Error(err, "failed to describe DHCP Options Set", "DhcpOptionsSet", *dhcpResult)
 		return nil
 	}
 
 	for _, dhcpConfig := range dhcpResult.DhcpOptions[0].DhcpConfigurations {
-		if *dhcpConfig.Key == "domain-name" {
+		if aws.ToString(dhcpConfig.Key) == "domain-name" {
 			if len(dhcpConfig.Values) == 0 {
 				return nil
 			}
 			domainName := dhcpConfig.Values[0].Value
 			// default domainName is 'ec2.internal' in us-east-1 and 'region.compute.internal' in the other regions.
-			if (s.scope.Region() == "us-east-1" && *domainName == "ec2.internal") ||
-				(s.scope.Region() != "us-east-1" && *domainName == fmt.Sprintf("%s.compute.internal", s.scope.Region())) {
+			if (s.scope.Region() == "us-east-1" && aws.ToString(domainName) == "ec2.internal") ||
+				(s.scope.Region() != "us-east-1" && aws.ToString(domainName) == fmt.Sprintf("%s.compute.internal", s.scope.Region())) {
 				return nil
 			}
 
@@ -1147,20 +1144,20 @@ func filterGroups(list []string, strToFilter string) (newList []string) {
 	return
 }
 
-func getCapacityReservationSpecification(capacityReservationID *string) *ec2.CapacityReservationSpecification {
+func getCapacityReservationSpecification(capacityReservationID *string) *types.CapacityReservationSpecification {
 	if capacityReservationID == nil {
 		//  Not targeting any specific Capacity Reservation
 		return nil
 	}
 
-	return &ec2.CapacityReservationSpecification{
-		CapacityReservationTarget: &ec2.CapacityReservationTarget{
+	return &types.CapacityReservationSpecification{
+		CapacityReservationTarget: &types.CapacityReservationTarget{
 			CapacityReservationId: capacityReservationID,
 		},
 	}
 }
 
-func getInstanceMarketOptionsRequest(i *infrav1.Instance) (*ec2.InstanceMarketOptionsRequest, error) {
+func getInstanceMarketOptionsRequest(i *infrav1.Instance) (*types.InstanceMarketOptionsRequest, error) {
 	if i.MarketType != "" && i.MarketType == infrav1.MarketTypeCapacityBlock && i.SpotMarketOptions != nil {
 		return nil, errors.New("can't create spot capacity-blocks, remove spot market request")
 	}
@@ -1187,29 +1184,29 @@ func getInstanceMarketOptionsRequest(i *infrav1.Instance) (*ec2.InstanceMarketOp
 		if i.CapacityReservationID == nil {
 			return nil, errors.Errorf("capacityReservationID is required when CapacityBlock is enabled")
 		}
-		return &ec2.InstanceMarketOptionsRequest{
-			MarketType: aws.String(ec2.MarketTypeCapacityBlock),
+		return &types.InstanceMarketOptionsRequest{
+			MarketType: types.MarketTypeCapacityBlock,
 		}, nil
 
 	case infrav1.MarketTypeSpot:
 		// Set required values for Spot instances
-		spotOpts := &ec2.SpotMarketOptions{
+		spotOpts := &types.SpotMarketOptions{
 			// The following two options ensure that:
 			// - If an instance is interrupted, it is terminated rather than hibernating or stopping
 			// - No replacement instance will be created if the instance is interrupted
 			// - If the spot request cannot immediately be fulfilled, it will not be created
 			// This behaviour should satisfy the 1:1 mapping of Machines to Instances as
 			// assumed by the Cluster API.
-			InstanceInterruptionBehavior: aws.String(ec2.InstanceInterruptionBehaviorTerminate),
-			SpotInstanceType:             aws.String(ec2.SpotInstanceTypeOneTime),
+			InstanceInterruptionBehavior: types.InstanceInterruptionBehaviorTerminate,
+			SpotInstanceType:             types.SpotInstanceTypeOneTime,
 		}
 
-		if maxPrice := aws.StringValue(i.SpotMarketOptions.MaxPrice); maxPrice != "" {
+		if maxPrice := aws.ToString(i.SpotMarketOptions.MaxPrice); maxPrice != "" {
 			spotOpts.MaxPrice = aws.String(maxPrice)
 		}
 
-		return &ec2.InstanceMarketOptionsRequest{
-			MarketType:  aws.String(ec2.MarketTypeSpot),
+		return &types.InstanceMarketOptionsRequest{
+			MarketType:  types.MarketTypeSpot,
 			SpotOptions: spotOpts,
 		}, nil
 	case infrav1.MarketTypeOnDemand:
@@ -1221,36 +1218,36 @@ func getInstanceMarketOptionsRequest(i *infrav1.Instance) (*ec2.InstanceMarketOp
 	}
 }
 
-func getInstanceMetadataOptionsRequest(metadataOptions *infrav1.InstanceMetadataOptions) *ec2.InstanceMetadataOptionsRequest {
+func getInstanceMetadataOptionsRequest(metadataOptions *infrav1.InstanceMetadataOptions) *types.InstanceMetadataOptionsRequest {
 	if metadataOptions == nil {
 		return nil
 	}
 
-	request := &ec2.InstanceMetadataOptionsRequest{}
+	request := &types.InstanceMetadataOptionsRequest{}
 	if metadataOptions.HTTPEndpoint != "" {
-		request.SetHttpEndpoint(string(metadataOptions.HTTPEndpoint))
+		request.HttpEndpoint = types.InstanceMetadataEndpointState(string(metadataOptions.HTTPEndpoint))
 	}
 	if metadataOptions.HTTPPutResponseHopLimit != 0 {
-		request.SetHttpPutResponseHopLimit(metadataOptions.HTTPPutResponseHopLimit)
+		request.HttpPutResponseHopLimit = utils.ToInt32Pointer(&metadataOptions.HTTPPutResponseHopLimit)
 	}
 	if metadataOptions.HTTPTokens != "" {
-		request.SetHttpTokens(string(metadataOptions.HTTPTokens))
+		request.HttpTokens = types.HttpTokensState(string(metadataOptions.HTTPTokens))
 	}
 	if metadataOptions.InstanceMetadataTags != "" {
-		request.SetInstanceMetadataTags(string(metadataOptions.InstanceMetadataTags))
+		request.InstanceMetadataTags = types.InstanceMetadataTagsState(string(metadataOptions.InstanceMetadataTags))
 	}
 
 	return request
 }
 
-func getPrivateDNSNameOptionsRequest(privateDNSName *infrav1.PrivateDNSName) *ec2.PrivateDnsNameOptionsRequest {
+func getPrivateDNSNameOptionsRequest(privateDNSName *infrav1.PrivateDNSName) *types.PrivateDnsNameOptionsRequest {
 	if privateDNSName == nil {
 		return nil
 	}
 
-	return &ec2.PrivateDnsNameOptionsRequest{
+	return &types.PrivateDnsNameOptionsRequest{
 		EnableResourceNameDnsAAAARecord: privateDNSName.EnableResourceNameDNSAAAARecord,
 		EnableResourceNameDnsARecord:    privateDNSName.EnableResourceNameDNSARecord,
-		HostnameType:                    privateDNSName.HostnameType,
+		HostnameType:                    types.HostnameType(aws.ToString(privateDNSName.HostnameType)),
 	}
 }
diff --git a/pkg/cloud/services/ec2/launchtemplate.go b/pkg/cloud/services/ec2/launchtemplate.go
index 163247c15..f0d9b1bde 100644
--- a/pkg/cloud/services/ec2/launchtemplate.go
+++ b/pkg/cloud/services/ec2/launchtemplate.go
@@ -24,8 +24,9 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/blang/semver"
 	ignTypes "github.com/coreos/ignition/config/v2_3/types"
 	ignV3Types "github.com/coreos/ignition/v2/config/v3_4/types"
@@ -43,6 +44,7 @@ import (
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/userdata"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/record"
+	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/utils"
 	clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
 	"sigs.k8s.io/cluster-api/util/conditions"
 )
@@ -267,7 +269,7 @@ func (s *Service) ReconcileLaunchTemplate(
 		// anymore. If this fails, it would still be cleaned by the bucket lifecycle
 		// policy later.
 		if feature.Gates.Enabled(feature.MachinePool) && deletedLaunchTemplateVersion != nil {
-			_, _, _, deletedLaunchTemplateVersionBootstrapDataHash, err := s.SDKToLaunchTemplate(deletedLaunchTemplateVersion)
+			_, _, _, deletedLaunchTemplateVersionBootstrapDataHash, err := s.SDKToLaunchTemplate(*deletedLaunchTemplateVersion)
 			if err != nil {
 				return err
 			}
@@ -474,14 +476,15 @@ func (s *Service) GetLaunchTemplate(launchTemplateName string) (*expinfrav1.AWSL
 
 	input := &ec2.DescribeLaunchTemplateVersionsInput{
 		LaunchTemplateName: aws.String(launchTemplateName),
-		Versions:           aws.StringSlice([]string{expinfrav1.LaunchTemplateLatestVersion}),
+		Versions:           []string{expinfrav1.LaunchTemplateLatestVersion},
 	}
 
-	out, err := s.EC2Client.DescribeLaunchTemplateVersionsWithContext(context.TODO(), input)
-	switch {
-	case awserrors.IsNotFound(err):
-		return nil, "", nil, nil, nil
-	case err != nil:
+	out, err := s.EC2Client.DescribeLaunchTemplateVersions(context.TODO(), input)
+	if err != nil {
+		serr := awserrors.ParseSmithyError(err)
+		if serr.ErrorCode() == awserrors.LaunchTemplateNameNotFound {
+			return nil, "", nil, nil, nil
+		}
 		return nil, "", nil, nil, err
 	}
 
@@ -500,10 +503,10 @@ func (s *Service) GetLaunchTemplateID(launchTemplateName string) (string, error)
 
 	input := &ec2.DescribeLaunchTemplateVersionsInput{
 		LaunchTemplateName: aws.String(launchTemplateName),
-		Versions:           aws.StringSlice([]string{expinfrav1.LaunchTemplateLatestVersion}),
+		Versions:           []string{expinfrav1.LaunchTemplateLatestVersion},
 	}
 
-	out, err := s.EC2Client.DescribeLaunchTemplateVersionsWithContext(context.TODO(), input)
+	out, err := s.EC2Client.DescribeLaunchTemplateVersions(context.TODO(), input)
 	switch {
 	case awserrors.IsNotFound(err):
 		return "", nil
@@ -546,9 +549,9 @@ func (s *Service) CreateLaunchTemplate(scope scope.LaunchTemplateScope, imageID
 	})
 
 	if len(tags) > 0 {
-		spec := &ec2.TagSpecification{ResourceType: aws.String(ec2.ResourceTypeLaunchTemplate)}
+		spec := types.TagSpecification{ResourceType: types.ResourceTypeLaunchTemplate}
 		for key, value := range tags {
-			spec.Tags = append(spec.Tags, &ec2.Tag{
+			spec.Tags = append(spec.Tags, types.Tag{
 				Key:   aws.String(key),
 				Value: aws.String(value),
 			})
@@ -556,7 +559,7 @@ func (s *Service) CreateLaunchTemplate(scope scope.LaunchTemplateScope, imageID
 		input.TagSpecifications = append(input.TagSpecifications, spec)
 	}
 
-	result, err := s.EC2Client.CreateLaunchTemplateWithContext(context.TODO(), input)
+	result, err := s.EC2Client.CreateLaunchTemplate(context.TODO(), input)
 	if err != nil {
 		return "", err
 	}
@@ -581,7 +584,7 @@ func (s *Service) CreateLaunchTemplateVersion(id string, scope scope.LaunchTempl
 		LaunchTemplateId:   &id,
 	}
 
-	_, err = s.EC2Client.CreateLaunchTemplateVersionWithContext(context.TODO(), input)
+	_, err = s.EC2Client.CreateLaunchTemplateVersion(context.TODO(), input)
 	if err != nil {
 		return errors.Wrapf(err, "unable to create launch template version")
 	}
@@ -589,7 +592,7 @@ func (s *Service) CreateLaunchTemplateVersion(id string, scope scope.LaunchTempl
 	return nil
 }
 
-func (s *Service) createLaunchTemplateData(scope scope.LaunchTemplateScope, imageID *string, userDataSecretKey apimachinerytypes.NamespacedName, userDataForLaunchTemplate []byte, bootstrapDataHash string) (*ec2.RequestLaunchTemplateData, error) {
+func (s *Service) createLaunchTemplateData(scope scope.LaunchTemplateScope, imageID *string, userDataSecretKey apimachinerytypes.NamespacedName, userDataForLaunchTemplate []byte, bootstrapDataHash string) (*types.RequestLaunchTemplateData, error) {
 	lt := scope.GetLaunchTemplate()
 
 	// An explicit empty string for SSHKeyName means do not specify a key in the ASG launch
@@ -598,28 +601,28 @@ func (s *Service) createLaunchTemplateData(scope scope.LaunchTemplateScope, imag
 		sshKeyNamePtr = lt.SSHKeyName
 	}
 
-	data := &ec2.RequestLaunchTemplateData{
-		InstanceType: aws.String(lt.InstanceType),
+	data := &types.RequestLaunchTemplateData{
+		InstanceType: types.InstanceType(lt.InstanceType),
 		KeyName:      sshKeyNamePtr,
 		UserData:     ptr.To[string](base64.StdEncoding.EncodeToString(userDataForLaunchTemplate)),
 	}
 
 	if lt.InstanceMetadataOptions != nil {
-		data.MetadataOptions = &ec2.LaunchTemplateInstanceMetadataOptionsRequest{
-			HttpEndpoint:         aws.String(string(lt.InstanceMetadataOptions.HTTPEndpoint)),
-			InstanceMetadataTags: aws.String(string(lt.InstanceMetadataOptions.InstanceMetadataTags)),
+		data.MetadataOptions = &types.LaunchTemplateInstanceMetadataOptionsRequest{
+			HttpEndpoint:         types.LaunchTemplateInstanceMetadataEndpointState(string(lt.InstanceMetadataOptions.HTTPEndpoint)),
+			InstanceMetadataTags: types.LaunchTemplateInstanceMetadataTagsState(string(lt.InstanceMetadataOptions.InstanceMetadataTags)),
 		}
 
 		if lt.InstanceMetadataOptions.HTTPTokens != "" {
-			data.MetadataOptions.HttpTokens = aws.String(string(lt.InstanceMetadataOptions.HTTPTokens))
+			data.MetadataOptions.HttpTokens = types.LaunchTemplateHttpTokensState(string(lt.InstanceMetadataOptions.HTTPTokens))
 		}
 		if lt.InstanceMetadataOptions.HTTPPutResponseHopLimit != 0 {
-			data.MetadataOptions.HttpPutResponseHopLimit = aws.Int64(lt.InstanceMetadataOptions.HTTPPutResponseHopLimit)
+			data.MetadataOptions.HttpPutResponseHopLimit = utils.ToInt32Pointer(&lt.InstanceMetadataOptions.HTTPPutResponseHopLimit)
 		}
 	}
 
 	if len(lt.IamInstanceProfile) > 0 {
-		data.IamInstanceProfile = &ec2.LaunchTemplateIamInstanceProfileSpecificationRequest{
+		data.IamInstanceProfile = &types.LaunchTemplateIamInstanceProfileSpecificationRequest{
 			Name: aws.String(lt.IamInstanceProfile),
 		}
 	}
@@ -629,16 +632,14 @@ func (s *Service) createLaunchTemplateData(scope scope.LaunchTemplateScope, imag
 		return nil, err
 	}
 
-	for _, id := range ids {
-		data.SecurityGroupIds = append(data.SecurityGroupIds, aws.String(id))
-	}
+	data.SecurityGroupIds = append(data.SecurityGroupIds, ids...)
 
 	// add additional security groups as well
 	securityGroupIDs, err := s.GetAdditionalSecurityGroupsIDs(scope.GetLaunchTemplate().AdditionalSecurityGroups)
 	if err != nil {
 		return nil, err
 	}
-	data.SecurityGroupIds = append(data.SecurityGroupIds, aws.StringSlice(securityGroupIDs)...)
+	data.SecurityGroupIds = append(data.SecurityGroupIds, securityGroupIDs...)
 
 	// set the AMI ID
 	data.ImageId = imageID
@@ -650,7 +651,7 @@ func (s *Service) createLaunchTemplateData(scope scope.LaunchTemplateScope, imag
 	data.InstanceMarketOptions = instanceMarketOptions
 	data.PrivateDnsNameOptions = getLaunchTemplatePrivateDNSNameOptionsRequest(scope.GetLaunchTemplate().PrivateDNSName)
 
-	blockDeviceMappings := []*ec2.LaunchTemplateBlockDeviceMappingRequest{}
+	blockDeviceMappings := []types.LaunchTemplateBlockDeviceMappingRequest{}
 
 	// Set up root volume
 	if lt.RootVolume != nil {
@@ -662,14 +663,14 @@ func (s *Service) createLaunchTemplateData(scope scope.LaunchTemplateScope, imag
 		lt.RootVolume.DeviceName = aws.StringValue(rootDeviceName)
 
 		req := volumeToLaunchTemplateBlockDeviceMappingRequest(lt.RootVolume)
-		blockDeviceMappings = append(blockDeviceMappings, req)
+		blockDeviceMappings = append(blockDeviceMappings, *req)
 	}
 
 	for vi := range lt.NonRootVolumes {
 		nonRootVolume := lt.NonRootVolumes[vi]
 
 		blockDeviceMapping := volumeToLaunchTemplateBlockDeviceMappingRequest(&nonRootVolume)
-		blockDeviceMappings = append(blockDeviceMappings, blockDeviceMapping)
+		blockDeviceMappings = append(blockDeviceMappings, *blockDeviceMapping)
 	}
 
 	if len(blockDeviceMappings) > 0 {
@@ -681,19 +682,19 @@ func (s *Service) createLaunchTemplateData(scope scope.LaunchTemplateScope, imag
 	return data, nil
 }
 
-func volumeToLaunchTemplateBlockDeviceMappingRequest(v *infrav1.Volume) *ec2.LaunchTemplateBlockDeviceMappingRequest {
-	ltEbsDevice := &ec2.LaunchTemplateEbsBlockDeviceRequest{
+func volumeToLaunchTemplateBlockDeviceMappingRequest(v *infrav1.Volume) *types.LaunchTemplateBlockDeviceMappingRequest {
+	ltEbsDevice := &types.LaunchTemplateEbsBlockDeviceRequest{
 		DeleteOnTermination: aws.Bool(true),
-		VolumeSize:          aws.Int64(v.Size),
+		VolumeSize:          utils.ToInt32Pointer(&v.Size),
 		Encrypted:           v.Encrypted,
 	}
 
 	if v.Throughput != nil {
-		ltEbsDevice.Throughput = v.Throughput
+		ltEbsDevice.Throughput = utils.ToInt32Pointer(v.Throughput)
 	}
 
 	if v.IOPS != 0 {
-		ltEbsDevice.Iops = aws.Int64(v.IOPS)
+		ltEbsDevice.Iops = utils.ToInt32Pointer(&v.IOPS)
 	}
 
 	if v.EncryptionKey != "" {
@@ -702,10 +703,10 @@ func volumeToLaunchTemplateBlockDeviceMappingRequest(v *infrav1.Volume) *ec2.Lau
 	}
 
 	if v.Type != "" {
-		ltEbsDevice.VolumeType = aws.String(string(v.Type))
+		ltEbsDevice.VolumeType = types.VolumeType(string(v.Type))
 	}
 
-	return &ec2.LaunchTemplateBlockDeviceMappingRequest{
+	return &types.LaunchTemplateBlockDeviceMappingRequest{
 		DeviceName: &v.DeviceName,
 		Ebs:        ltEbsDevice,
 	}
@@ -719,7 +720,7 @@ func (s *Service) DeleteLaunchTemplate(id string) error {
 		LaunchTemplateId: aws.String(id),
 	}
 
-	if _, err := s.EC2Client.DeleteLaunchTemplateWithContext(context.TODO(), input); err != nil {
+	if _, err := s.EC2Client.DeleteLaunchTemplate(context.TODO(), input); err != nil {
 		return errors.Wrapf(err, "failed to delete launch template %q", id)
 	}
 
@@ -732,7 +733,7 @@ func (s *Service) DeleteLaunchTemplate(id string) error {
 // It does not delete the "default" version, because that version cannot be deleted.
 // It does not assume that versions are sequential. Versions may be deleted out of band.
 // If there was an unused version which was successfully deleted, it is returned.
-func (s *Service) PruneLaunchTemplateVersions(id string) (*ec2.LaunchTemplateVersion, error) {
+func (s *Service) PruneLaunchTemplateVersions(id string) (*types.LaunchTemplateVersion, error) {
 	// When there is one version available, it is the default and the latest.
 	// When there are two versions available, one the is the default, the other is the latest.
 	// Therefore we only prune when there are at least 3 versions available.
@@ -742,10 +743,10 @@ func (s *Service) PruneLaunchTemplateVersions(id string) (*ec2.LaunchTemplateVer
 		LaunchTemplateId: aws.String(id),
 		MinVersion:       aws.String("0"),
 		MaxVersion:       aws.String(expinfrav1.LaunchTemplateLatestVersion),
-		MaxResults:       aws.Int64(minCountToAllowPrune),
+		MaxResults:       aws.Int32(minCountToAllowPrune),
 	}
 
-	out, err := s.EC2Client.DescribeLaunchTemplateVersionsWithContext(context.TODO(), input)
+	out, err := s.EC2Client.DescribeLaunchTemplateVersions(context.TODO(), input)
 	if err != nil {
 		s.scope.Info("", "aerr", err.Error())
 		return nil, err
@@ -764,17 +765,17 @@ func (s *Service) PruneLaunchTemplateVersions(id string) (*ec2.LaunchTemplateVer
 	if err != nil {
 		return nil, err
 	}
-	return versionToPrune, nil
+	return &versionToPrune, nil
 }
 
 // GetLaunchTemplateLatestVersion returns the latest version of a launch template.
 func (s *Service) GetLaunchTemplateLatestVersion(id string) (string, error) {
 	input := &ec2.DescribeLaunchTemplateVersionsInput{
 		LaunchTemplateId: aws.String(id),
-		Versions:         aws.StringSlice([]string{expinfrav1.LaunchTemplateLatestVersion}),
+		Versions:         []string{expinfrav1.LaunchTemplateLatestVersion},
 	}
 
-	out, err := s.EC2Client.DescribeLaunchTemplateVersionsWithContext(context.TODO(), input)
+	out, err := s.EC2Client.DescribeLaunchTemplateVersions(context.TODO(), input)
 	if err != nil {
 		s.scope.Info("", "aerr", err.Error())
 		return "", err
@@ -798,10 +799,10 @@ func (s *Service) deleteLaunchTemplateVersion(id string, version *int64) error {
 
 	input := &ec2.DeleteLaunchTemplateVersionsInput{
 		LaunchTemplateId: aws.String(id),
-		Versions:         aws.StringSlice(versions),
+		Versions:         versions,
 	}
 
-	_, err := s.EC2Client.DeleteLaunchTemplateVersionsWithContext(context.TODO(), input)
+	_, err := s.EC2Client.DeleteLaunchTemplateVersions(context.TODO(), input)
 	if err != nil {
 		return err
 	}
@@ -811,8 +812,8 @@ func (s *Service) deleteLaunchTemplateVersion(id string, version *int64) error {
 }
 
 // SDKToSpotMarketOptions converts EC2 instance market options to SpotMarketOptions.
-func SDKToSpotMarketOptions(instanceMarketOptions *ec2.LaunchTemplateInstanceMarketOptions) *infrav1.SpotMarketOptions {
-	if instanceMarketOptions == nil || aws.StringValue(instanceMarketOptions.MarketType) != ec2.MarketTypeSpot {
+func SDKToSpotMarketOptions(instanceMarketOptions *types.LaunchTemplateInstanceMarketOptions) *infrav1.SpotMarketOptions {
+	if instanceMarketOptions == nil || instanceMarketOptions.MarketType != types.MarketTypeSpot {
 		return nil
 	}
 
@@ -829,14 +830,14 @@ func SDKToSpotMarketOptions(instanceMarketOptions *ec2.LaunchTemplateInstanceMar
 }
 
 // SDKToLaunchTemplate converts an AWS EC2 SDK instance to the CAPA instance type.
-func (s *Service) SDKToLaunchTemplate(d *ec2.LaunchTemplateVersion) (*expinfrav1.AWSLaunchTemplate, string, *apimachinerytypes.NamespacedName, *string, error) {
+func (s *Service) SDKToLaunchTemplate(d types.LaunchTemplateVersion) (*expinfrav1.AWSLaunchTemplate, string, *apimachinerytypes.NamespacedName, *string, error) {
 	v := d.LaunchTemplateData
 	i := &expinfrav1.AWSLaunchTemplate{
 		Name: aws.StringValue(d.LaunchTemplateName),
 		AMI: infrav1.AMIReference{
 			ID: v.ImageId,
 		},
-		InstanceType:      aws.StringValue(v.InstanceType),
+		InstanceType:      string(v.InstanceType),
 		SSHKeyName:        v.KeyName,
 		SpotMarketOptions: SDKToSpotMarketOptions(v.InstanceMarketOptions),
 		VersionNumber:     d.VersionNumber,
@@ -850,15 +851,15 @@ func (s *Service) SDKToLaunchTemplate(d *ec2.LaunchTemplateVersion) (*expinfrav1
 
 	if v.MetadataOptions != nil {
 		i.InstanceMetadataOptions = &infrav1.InstanceMetadataOptions{
-			HTTPPutResponseHopLimit: aws.Int64Value(v.MetadataOptions.HttpPutResponseHopLimit),
-			HTTPTokens:              infrav1.HTTPTokensState(aws.StringValue(v.MetadataOptions.HttpTokens)),
+			HTTPPutResponseHopLimit: utils.ToInt64Value(v.MetadataOptions.HttpPutResponseHopLimit),
+			HTTPTokens:              infrav1.HTTPTokensState(string(v.MetadataOptions.HttpTokens)),
 			HTTPEndpoint:            infrav1.InstanceMetadataEndpointStateEnabled,
 			InstanceMetadataTags:    infrav1.InstanceMetadataEndpointStateDisabled,
 		}
-		if v.MetadataOptions.HttpEndpoint != nil && aws.StringValue(v.MetadataOptions.HttpEndpoint) == "disabled" {
+		if v.MetadataOptions.HttpEndpoint == types.LaunchTemplateInstanceMetadataEndpointStateDisabled {
 			i.InstanceMetadataOptions.HTTPEndpoint = infrav1.InstanceMetadataEndpointStateDisabled
 		}
-		if v.MetadataOptions.InstanceMetadataTags != nil && aws.StringValue(v.MetadataOptions.InstanceMetadataTags) == "enabled" {
+		if v.MetadataOptions.InstanceMetadataTags == types.LaunchTemplateInstanceMetadataTagsStateEnabled {
 			i.InstanceMetadataOptions.InstanceMetadataTags = infrav1.InstanceMetadataEndpointStateEnabled
 		}
 	}
@@ -867,7 +868,7 @@ func (s *Service) SDKToLaunchTemplate(d *ec2.LaunchTemplateVersion) (*expinfrav1
 		i.PrivateDNSName = &infrav1.PrivateDNSName{
 			EnableResourceNameDNSAAAARecord: v.PrivateDnsNameOptions.EnableResourceNameDnsAAAARecord,
 			EnableResourceNameDNSARecord:    v.PrivateDnsNameOptions.EnableResourceNameDnsARecord,
-			HostnameType:                    v.PrivateDnsNameOptions.HostnameType,
+			HostnameType:                    aws.String(string(v.PrivateDnsNameOptions.HostnameType)),
 		}
 	}
 
@@ -887,7 +888,7 @@ func (s *Service) SDKToLaunchTemplate(d *ec2.LaunchTemplateVersion) (*expinfrav1
 		// FIXME(dlipovetsky): This will include the core security groups as well, making the
 		// "Additional" a bit dishonest. However, including the core groups drastically simplifies
 		// comparison with the incoming security groups.
-		i.AdditionalSecurityGroups = append(i.AdditionalSecurityGroups, infrav1.AWSResourceReference{ID: id})
+		i.AdditionalSecurityGroups = append(i.AdditionalSecurityGroups, infrav1.AWSResourceReference{ID: aws.String(id)})
 	}
 
 	if v.UserData == nil {
@@ -902,7 +903,7 @@ func (s *Service) SDKToLaunchTemplate(d *ec2.LaunchTemplateVersion) (*expinfrav1
 	var launchTemplateUserDataSecretKey *apimachinerytypes.NamespacedName
 	var bootstrapDataHash *string
 	for _, tagSpecification := range v.TagSpecifications {
-		if tagSpecification.ResourceType != nil && *tagSpecification.ResourceType == ec2.ResourceTypeInstance {
+		if tagSpecification.ResourceType == types.ResourceTypeInstance {
 			for _, tag := range tagSpecification.Tags {
 				if tag.Key != nil && *tag.Key == infrav1.LaunchTemplateBootstrapDataSecret && tag.Value != nil && strings.Contains(*tag.Value, "/") {
 					parts := strings.SplitN(*tag.Value, "/", 2)
@@ -1021,7 +1022,7 @@ func (s *Service) DiscoverLaunchTemplateAMI(ctx context.Context, scope scope.Lau
 	imageArchitecture := Amd64ArchitectureTag
 
 	if instanceType != "" {
-		imageArchitecture, err = s.pickArchitectureForInstanceType(instanceType)
+		imageArchitecture, err = s.pickArchitectureForInstanceType(types.InstanceType(instanceType))
 		if err != nil {
 			return nil, err
 		}
@@ -1073,8 +1074,8 @@ func (s *Service) GetAdditionalSecurityGroupsIDs(securityGroups []infrav1.AWSRes
 	return additionalSecurityGroupsIDs, nil
 }
 
-func (s *Service) buildLaunchTemplateTagSpecificationRequest(scope scope.LaunchTemplateScope, userDataSecretKey apimachinerytypes.NamespacedName, bootstrapDataHash string) []*ec2.LaunchTemplateTagSpecificationRequest {
-	tagSpecifications := make([]*ec2.LaunchTemplateTagSpecificationRequest, 0)
+func (s *Service) buildLaunchTemplateTagSpecificationRequest(scope scope.LaunchTemplateScope, userDataSecretKey apimachinerytypes.NamespacedName, bootstrapDataHash string) []types.LaunchTemplateTagSpecificationRequest {
+	tagSpecifications := make([]types.LaunchTemplateTagSpecificationRequest, 0)
 	additionalTags := scope.AdditionalTags()
 	// Set the cloud provider tag
 	additionalTags[infrav1.ClusterAWSCloudProviderTagKey(s.scope.KubernetesClusterName())] = string(infrav1.ResourceLifecycleOwned)
@@ -1093,9 +1094,9 @@ func (s *Service) buildLaunchTemplateTagSpecificationRequest(scope scope.LaunchT
 		instanceTags[infrav1.LaunchTemplateBootstrapDataSecret] = userDataSecretKey.String()
 		instanceTags[infrav1.LaunchTemplateBootstrapDataHash] = bootstrapDataHash
 
-		spec := &ec2.LaunchTemplateTagSpecificationRequest{ResourceType: aws.String(ec2.ResourceTypeInstance)}
+		spec := types.LaunchTemplateTagSpecificationRequest{ResourceType: types.ResourceTypeInstance}
 		for key, value := range instanceTags {
-			spec.Tags = append(spec.Tags, &ec2.Tag{
+			spec.Tags = append(spec.Tags, types.Tag{
 				Key:   aws.String(key),
 				Value: aws.String(value),
 			})
@@ -1107,9 +1108,9 @@ func (s *Service) buildLaunchTemplateTagSpecificationRequest(scope scope.LaunchT
 
 	// tag EBS volumes
 	if len(tags) > 0 {
-		spec := &ec2.LaunchTemplateTagSpecificationRequest{ResourceType: aws.String(ec2.ResourceTypeVolume)}
+		spec := types.LaunchTemplateTagSpecificationRequest{ResourceType: types.ResourceTypeVolume}
 		for key, value := range tags {
-			spec.Tags = append(spec.Tags, &ec2.Tag{
+			spec.Tags = append(spec.Tags, types.Tag{
 				Key:   aws.String(key),
 				Value: aws.String(value),
 			})
@@ -1128,12 +1129,12 @@ func (s *Service) getFilteredSecurityGroupIDs(securityGroup infrav1.AWSResourceR
 		return nil, nil
 	}
 
-	filters := []*ec2.Filter{}
+	filters := []types.Filter{}
 	for _, f := range securityGroup.Filters {
-		filters = append(filters, &ec2.Filter{Name: aws.String(f.Name), Values: aws.StringSlice(f.Values)})
+		filters = append(filters, types.Filter{Name: aws.String(f.Name), Values: f.Values})
 	}
 
-	sgs, err := s.EC2Client.DescribeSecurityGroupsWithContext(context.TODO(), &ec2.DescribeSecurityGroupsInput{Filters: filters})
+	sgs, err := s.EC2Client.DescribeSecurityGroups(context.TODO(), &ec2.DescribeSecurityGroupsInput{Filters: filters})
 	if err != nil {
 		return nil, err
 	}
@@ -1145,7 +1146,7 @@ func (s *Service) getFilteredSecurityGroupIDs(securityGroup infrav1.AWSResourceR
 	return ids, nil
 }
 
-func getLaunchTemplateInstanceMarketOptionsRequest(i *expinfrav1.AWSLaunchTemplate) (*ec2.LaunchTemplateInstanceMarketOptionsRequest, error) {
+func getLaunchTemplateInstanceMarketOptionsRequest(i *expinfrav1.AWSLaunchTemplate) (*types.LaunchTemplateInstanceMarketOptionsRequest, error) {
 	if i.MarketType != "" && i.MarketType == infrav1.MarketTypeCapacityBlock && i.SpotMarketOptions != nil {
 		return nil, errors.New("can't create spot capacity-blocks, remove spot market request")
 	}
@@ -1166,24 +1167,24 @@ func getLaunchTemplateInstanceMarketOptionsRequest(i *expinfrav1.AWSLaunchTempla
 		if i.CapacityReservationID == nil {
 			return nil, errors.Errorf("capacityReservationID is required when CapacityBlock is enabled")
 		}
-		return &ec2.LaunchTemplateInstanceMarketOptionsRequest{
-			MarketType: aws.String(ec2.MarketTypeCapacityBlock),
+		return &types.LaunchTemplateInstanceMarketOptionsRequest{
+			MarketType: types.MarketTypeCapacityBlock,
 		}, nil
 
 	case infrav1.MarketTypeSpot:
 		// Set required values for Spot instances
-		spotOptions := &ec2.LaunchTemplateSpotMarketOptionsRequest{}
+		spotOptions := &types.LaunchTemplateSpotMarketOptionsRequest{}
 
 		// Persistent option is not available for EC2 autoscaling, EC2 makes a one-time request by default and setting request type should not be allowed.
 		// For one-time requests, only terminate option is available as interruption behavior, and default for spotOptions.SetInstanceInterruptionBehavior() is terminate, so it is not set here explicitly.
 
 		if maxPrice := aws.StringValue(i.SpotMarketOptions.MaxPrice); maxPrice != "" {
-			spotOptions.SetMaxPrice(maxPrice)
+			spotOptions.MaxPrice = aws.String(maxPrice)
 		}
 
-		launchTemplateInstanceMarketOptionsRequest := &ec2.LaunchTemplateInstanceMarketOptionsRequest{}
-		launchTemplateInstanceMarketOptionsRequest.SetMarketType(ec2.MarketTypeSpot)
-		launchTemplateInstanceMarketOptionsRequest.SetSpotOptions(spotOptions)
+		launchTemplateInstanceMarketOptionsRequest := &types.LaunchTemplateInstanceMarketOptionsRequest{}
+		launchTemplateInstanceMarketOptionsRequest.MarketType = types.MarketTypeSpot
+		launchTemplateInstanceMarketOptionsRequest.SpotOptions = spotOptions
 
 		return launchTemplateInstanceMarketOptionsRequest, nil
 	case infrav1.MarketTypeOnDemand:
@@ -1195,14 +1196,14 @@ func getLaunchTemplateInstanceMarketOptionsRequest(i *expinfrav1.AWSLaunchTempla
 	}
 }
 
-func getLaunchTemplatePrivateDNSNameOptionsRequest(privateDNSName *infrav1.PrivateDNSName) *ec2.LaunchTemplatePrivateDnsNameOptionsRequest {
+func getLaunchTemplatePrivateDNSNameOptionsRequest(privateDNSName *infrav1.PrivateDNSName) *types.LaunchTemplatePrivateDnsNameOptionsRequest {
 	if privateDNSName == nil {
 		return nil
 	}
 
-	return &ec2.LaunchTemplatePrivateDnsNameOptionsRequest{
+	return &types.LaunchTemplatePrivateDnsNameOptionsRequest{
 		EnableResourceNameDnsAAAARecord: privateDNSName.EnableResourceNameDNSAAAARecord,
 		EnableResourceNameDnsARecord:    privateDNSName.EnableResourceNameDNSARecord,
-		HostnameType:                    privateDNSName.HostnameType,
+		HostnameType:                    types.HostnameType(aws.StringValue(privateDNSName.HostnameType)),
 	}
 }
diff --git a/pkg/cloud/services/ec2/service.go b/pkg/cloud/services/ec2/service.go
index a833b54ad..e9bd12c79 100644
--- a/pkg/cloud/services/ec2/service.go
+++ b/pkg/cloud/services/ec2/service.go
@@ -18,9 +18,8 @@ limitations under the License.
 package ec2
 
 import (
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
-
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope"
+	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/common"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/network"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/ssm"
 )
@@ -30,7 +29,7 @@ import (
 // One alternative is to have a large list of functions from the ec2 client.
 type Service struct {
 	scope      scope.EC2Scope
-	EC2Client  ec2iface.EC2API
+	EC2Client  common.EC2API
 	netService *network.Service
 
 	// SSMClient is used to look up the official EKS AMI ID
diff --git a/pkg/cloud/services/eks/securitygroup.go b/pkg/cloud/services/eks/securitygroup.go
index 61e56798d..685d7f814 100644
--- a/pkg/cloud/services/eks/securitygroup.go
+++ b/pkg/cloud/services/eks/securitygroup.go
@@ -21,8 +21,9 @@ import (
 	"fmt"
 
 	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	ekstypes "github.com/aws/aws-sdk-go-v2/service/eks/types"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"k8s.io/utils/ptr"
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
@@ -30,7 +31,7 @@ import (
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/converters"
 )
 
-func (s *Service) reconcileSecurityGroups(ctx context.Context, cluster *ekstypes.Cluster) error {
+func (s *Service) reconcileSecurityGroups(_ context.Context, cluster *ekstypes.Cluster) error {
 	s.scope.Info("Reconciling EKS security groups", "cluster-name", ptr.Deref(cluster.Name, ""))
 
 	if s.scope.Network().SecurityGroups == nil {
@@ -38,15 +39,15 @@ func (s *Service) reconcileSecurityGroups(ctx context.Context, cluster *ekstypes
 	}
 
 	input := &ec2.DescribeSecurityGroupsInput{
-		Filters: []*ec2.Filter{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("tag:aws:eks:cluster-name"),
-				Values: []*string{cluster.Name},
+				Values: []string{aws.ToString(cluster.Name)},
 			},
 		},
 	}
 
-	output, err := s.EC2Client.DescribeSecurityGroupsWithContext(ctx, input)
+	output, err := s.EC2Client.DescribeSecurityGroups(context.TODO(), input)
 	if err != nil {
 		return fmt.Errorf("describing security groups: %w", err)
 	}
@@ -63,12 +64,12 @@ func (s *Service) reconcileSecurityGroups(ctx context.Context, cluster *ekstypes
 	s.scope.ControlPlane.Status.Network.SecurityGroups[infrav1.SecurityGroupNode] = sg
 
 	input = &ec2.DescribeSecurityGroupsInput{
-		GroupIds: []*string{
-			cluster.ResourcesVpcConfig.ClusterSecurityGroupId,
+		GroupIds: []string{
+			aws.ToString(cluster.ResourcesVpcConfig.ClusterSecurityGroupId),
 		},
 	}
 
-	output, err = s.EC2Client.DescribeSecurityGroupsWithContext(ctx, input)
+	output, err = s.EC2Client.DescribeSecurityGroups(context.TODO(), input)
 	if err != nil || len(output.SecurityGroups) == 0 {
 		return fmt.Errorf("describing EKS cluster security group: %w", err)
 	}
diff --git a/pkg/cloud/services/eks/service.go b/pkg/cloud/services/eks/service.go
index c4c274a12..b89380196 100644
--- a/pkg/cloud/services/eks/service.go
+++ b/pkg/cloud/services/eks/service.go
@@ -23,11 +23,11 @@ import (
 
 	"github.com/aws/aws-sdk-go-v2/service/autoscaling"
 	"github.com/aws/aws-sdk-go-v2/service/eks"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
 	"github.com/aws/aws-sdk-go/service/sts/stsiface"
 
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services"
+	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/common"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/eks/iam"
 )
 
@@ -86,7 +86,7 @@ type EKSClient struct {
 // One alternative is to have a large list of functions from the ec2 client.
 type Service struct {
 	scope     *scope.ManagedControlPlaneScope
-	EC2Client ec2iface.EC2API
+	EC2Client common.EC2API
 	EKSClient EKSAPI
 	iam.IAMService
 	STSClient stsiface.STSAPI
diff --git a/pkg/cloud/services/elb/loadbalancer.go b/pkg/cloud/services/elb/loadbalancer.go
index 6887692dd..874ea2d81 100644
--- a/pkg/cloud/services/elb/loadbalancer.go
+++ b/pkg/cloud/services/elb/loadbalancer.go
@@ -25,13 +25,13 @@ import (
 
 	"github.com/aws/aws-sdk-go-v2/aws"
 	"github.com/aws/aws-sdk-go-v2/aws/arn"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
 	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/google/go-cmp/cmp"
 	"github.com/pkg/errors"
 	kerrors "k8s.io/apimachinery/pkg/util/errors"
@@ -387,9 +387,9 @@ func (s *Service) getAPIServerLBSpec(ctx context.Context, elbName string, lbSpec
 		// This set of subnets may not match the subnets specified on the Cluster, so we may not have already discovered them
 		// We need to call out to AWS to describe them just in case
 		input := &ec2.DescribeSubnetsInput{
-			SubnetIds: aws.StringSlice(lbSpec.Subnets),
+			SubnetIds: lbSpec.Subnets,
 		}
-		out, err := s.EC2Client.DescribeSubnetsWithContext(ctx, input)
+		out, err := s.EC2Client.DescribeSubnets(ctx, input)
 		if err != nil {
 			return nil, err
 		}
@@ -1001,9 +1001,9 @@ func (s *Service) getControlPlaneLoadBalancerSubnets(ctx context.Context) (infra
 	var subnets infrav1.Subnets
 
 	input := &ec2.DescribeSubnetsInput{
-		SubnetIds: aws.StringSlice(s.scope.ControlPlaneLoadBalancer().Subnets),
+		SubnetIds: s.scope.ControlPlaneLoadBalancer().Subnets,
 	}
-	res, err := s.EC2Client.DescribeSubnetsWithContext(ctx, input)
+	res, err := s.EC2Client.DescribeSubnets(ctx, input)
 	if err != nil {
 		return nil, err
 	}
@@ -1194,9 +1194,9 @@ func (s *Service) getAPIServerClassicELBSpec(ctx context.Context, elbName string
 		// This set of subnets may not match the subnets specified on the Cluster, so we may not have already discovered them
 		// We need to call out to AWS to describe them just in case
 		input := &ec2.DescribeSubnetsInput{
-			SubnetIds: aws.StringSlice(s.scope.ControlPlaneLoadBalancer().Subnets),
+			SubnetIds: s.scope.ControlPlaneLoadBalancer().Subnets,
 		}
-		out, err := s.EC2Client.DescribeSubnetsWithContext(ctx, input)
+		out, err := s.EC2Client.DescribeSubnets(ctx, input)
 		if err != nil {
 			return nil, err
 		}
diff --git a/pkg/cloud/services/elb/service.go b/pkg/cloud/services/elb/service.go
index 09c50e615..e2847438a 100644
--- a/pkg/cloud/services/elb/service.go
+++ b/pkg/cloud/services/elb/service.go
@@ -24,9 +24,9 @@ import (
 	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"
 
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope"
+	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/common"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/network"
 )
 
@@ -35,7 +35,7 @@ import (
 // One alternative is to have a large list of functions from the ec2 client.
 type Service struct {
 	scope                 scope.ELBScope
-	EC2Client             ec2iface.EC2API
+	EC2Client             common.EC2API
 	ELBClient             ELBAPI
 	ELBV2Client           ELBV2API
 	ResourceTaggingClient ResourceGroupsTaggingAPIAPI
diff --git a/pkg/cloud/services/gc/ec2.go b/pkg/cloud/services/gc/ec2.go
index f9d4727db..6b60cf07b 100644
--- a/pkg/cloud/services/gc/ec2.go
+++ b/pkg/cloud/services/gc/ec2.go
@@ -26,7 +26,7 @@ import (
 	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 
 	converters "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/convertersv2"
-	filter "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/filterv2"
+	filter "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/filter"
 )
 
 func (s *Service) deleteSecurityGroups(ctx context.Context, resources []*AWSResource) error {
@@ -76,7 +76,7 @@ func (s *Service) deleteSecurityGroup(ctx context.Context, securityGroupID strin
 func (s *Service) getProviderOwnedSecurityGroups(ctx context.Context) ([]*AWSResource, error) {
 	input := &ec2.DescribeSecurityGroupsInput{
 		Filters: []types.Filter{
-			*filter.EC2.ProviderOwned(s.scope.KubernetesClusterName()),
+			filter.EC2.ProviderOwned(s.scope.KubernetesClusterName()),
 		},
 	}
 
diff --git a/pkg/cloud/services/gc/options.go b/pkg/cloud/services/gc/options.go
index 1b4b7b606..0a18af73e 100644
--- a/pkg/cloud/services/gc/options.go
+++ b/pkg/cloud/services/gc/options.go
@@ -17,7 +17,7 @@ limitations under the License.
 package gc
 
 import (
-	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope"
+	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/common"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/elb"
 )
 
@@ -46,7 +46,7 @@ func withResourceTaggingClient(client elb.ResourceGroupsTaggingAPIAPI) ServiceOp
 }
 
 // withEC2Client is an option for specifying a AWS EC2 Client.
-func withEC2Client(client scope.EC2API) ServiceOption {
+func withEC2Client(client common.EC2API) ServiceOption {
 	return func(s *Service) {
 		s.ec2Client = client
 	}
diff --git a/pkg/cloud/services/gc/service.go b/pkg/cloud/services/gc/service.go
index 2aa98e709..7ac856d9a 100644
--- a/pkg/cloud/services/gc/service.go
+++ b/pkg/cloud/services/gc/service.go
@@ -24,6 +24,7 @@ import (
 
 	"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/common"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/elb"
 )
 
@@ -33,7 +34,7 @@ type Service struct {
 	elbClient             elb.ELBAPI
 	elbv2Client           elb.ELBV2API
 	resourceTaggingClient elb.ResourceGroupsTaggingAPIAPI
-	ec2Client             scope.EC2API
+	ec2Client             common.EC2API
 	cleanupFuncs          ResourceCleanupFuncs
 	collectFuncs          ResourceCollectFuncs
 }
@@ -53,7 +54,7 @@ func NewService(clusterScope cloud.ClusterScoper, opts ...ServiceOption) *Servic
 		},
 		cleanupFuncs: ResourceCleanupFuncs{},
 		collectFuncs: ResourceCollectFuncs{},
-		ec2Client:    scope.NewEC2ClientV2(clusterScope, clusterScope, clusterScope, clusterScope.InfraCluster()),
+		ec2Client:    scope.NewEC2Client(clusterScope, clusterScope, clusterScope, clusterScope.InfraCluster()),
 	}
 	addDefaultCleanupFuncs(svc)
 
diff --git a/pkg/cloud/services/interfaces.go b/pkg/cloud/services/interfaces.go
index 385572d10..f36788d4a 100644
--- a/pkg/cloud/services/interfaces.go
+++ b/pkg/cloud/services/interfaces.go
@@ -20,7 +20,7 @@ package services
 import (
 	"context"
 
-	"github.com/aws/aws-sdk-go/service/ec2"
+	ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	apimachinerytypes "k8s.io/apimachinery/pkg/types"
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
@@ -81,7 +81,7 @@ type EC2Interface interface {
 	GetLaunchTemplateLatestVersion(id string) (string, error)
 	CreateLaunchTemplate(scope scope.LaunchTemplateScope, imageID *string, userDataSecretKey apimachinerytypes.NamespacedName, userData []byte, bootstrapDataHash string) (string, error)
 	CreateLaunchTemplateVersion(id string, scope scope.LaunchTemplateScope, imageID *string, userDataSecretKey apimachinerytypes.NamespacedName, userData []byte, bootstrapDataHash string) error
-	PruneLaunchTemplateVersions(id string) (*ec2.LaunchTemplateVersion, error)
+	PruneLaunchTemplateVersions(id string) (*ec2types.LaunchTemplateVersion, error)
 	DeleteLaunchTemplate(id string) error
 	LaunchTemplateNeedsUpdate(scope scope.LaunchTemplateScope, incoming *expinfrav1.AWSLaunchTemplate, existing *expinfrav1.AWSLaunchTemplate) (bool, error)
 	DeleteBastion() error
diff --git a/pkg/cloud/services/mock_services/ec2_interface_mock.go b/pkg/cloud/services/mock_services/ec2_interface_mock.go
index e6e6932a7..78b52d93d 100644
--- a/pkg/cloud/services/mock_services/ec2_interface_mock.go
+++ b/pkg/cloud/services/mock_services/ec2_interface_mock.go
@@ -24,9 +24,9 @@ import (
 	context "context"
 	reflect "reflect"
 
-	ec2 "github.com/aws/aws-sdk-go/service/ec2"
+	types "github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	gomock "github.com/golang/mock/gomock"
-	types "k8s.io/apimachinery/pkg/types"
+	types0 "k8s.io/apimachinery/pkg/types"
 	v1beta2 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
 	v1beta20 "sigs.k8s.io/cluster-api-provider-aws/v2/exp/api/v1beta2"
 	scope "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope"
@@ -71,7 +71,7 @@ func (mr *MockEC2InterfaceMockRecorder) CreateInstance(arg0, arg1, arg2, arg3 in
 }
 
 // CreateLaunchTemplate mocks base method.
-func (m *MockEC2Interface) CreateLaunchTemplate(arg0 scope.LaunchTemplateScope, arg1 *string, arg2 types.NamespacedName, arg3 []byte, arg4 string) (string, error) {
+func (m *MockEC2Interface) CreateLaunchTemplate(arg0 scope.LaunchTemplateScope, arg1 *string, arg2 types0.NamespacedName, arg3 []byte, arg4 string) (string, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CreateLaunchTemplate", arg0, arg1, arg2, arg3, arg4)
 	ret0, _ := ret[0].(string)
@@ -86,7 +86,7 @@ func (mr *MockEC2InterfaceMockRecorder) CreateLaunchTemplate(arg0, arg1, arg2, a
 }
 
 // CreateLaunchTemplateVersion mocks base method.
-func (m *MockEC2Interface) CreateLaunchTemplateVersion(arg0 string, arg1 scope.LaunchTemplateScope, arg2 *string, arg3 types.NamespacedName, arg4 []byte, arg5 string) error {
+func (m *MockEC2Interface) CreateLaunchTemplateVersion(arg0 string, arg1 scope.LaunchTemplateScope, arg2 *string, arg3 types0.NamespacedName, arg4 []byte, arg5 string) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CreateLaunchTemplateVersion", arg0, arg1, arg2, arg3, arg4, arg5)
 	ret0, _ := ret[0].(error)
@@ -202,12 +202,12 @@ func (mr *MockEC2InterfaceMockRecorder) GetInstanceSecurityGroups(arg0 interface
 }
 
 // GetLaunchTemplate mocks base method.
-func (m *MockEC2Interface) GetLaunchTemplate(arg0 string) (*v1beta20.AWSLaunchTemplate, string, *types.NamespacedName, *string, error) {
+func (m *MockEC2Interface) GetLaunchTemplate(arg0 string) (*v1beta20.AWSLaunchTemplate, string, *types0.NamespacedName, *string, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetLaunchTemplate", arg0)
 	ret0, _ := ret[0].(*v1beta20.AWSLaunchTemplate)
 	ret1, _ := ret[1].(string)
-	ret2, _ := ret[2].(*types.NamespacedName)
+	ret2, _ := ret[2].(*types0.NamespacedName)
 	ret3, _ := ret[3].(*string)
 	ret4, _ := ret[4].(error)
 	return ret0, ret1, ret2, ret3, ret4
@@ -309,10 +309,10 @@ func (mr *MockEC2InterfaceMockRecorder) ModifyInstanceMetadataOptions(arg0, arg1
 }
 
 // PruneLaunchTemplateVersions mocks base method.
-func (m *MockEC2Interface) PruneLaunchTemplateVersions(arg0 string) (*ec2.LaunchTemplateVersion, error) {
+func (m *MockEC2Interface) PruneLaunchTemplateVersions(arg0 string) (*types.LaunchTemplateVersion, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "PruneLaunchTemplateVersions", arg0)
-	ret0, _ := ret[0].(*ec2.LaunchTemplateVersion)
+	ret0, _ := ret[0].(*types.LaunchTemplateVersion)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
diff --git a/pkg/cloud/services/network/account.go b/pkg/cloud/services/network/account.go
index e719426ba..58e062825 100644
--- a/pkg/cloud/services/network/account.go
+++ b/pkg/cloud/services/network/account.go
@@ -20,7 +20,8 @@ import (
 	"context"
 	"sort"
 
-	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/pkg/errors"
 
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/filter"
@@ -28,8 +29,8 @@ import (
 )
 
 func (s *Service) getAvailableZones() ([]string, error) {
-	out, err := s.EC2Client.DescribeAvailabilityZonesWithContext(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
-		Filters: []*ec2.Filter{
+	out, err := s.EC2Client.DescribeAvailabilityZones(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
+		Filters: []types.Filter{
 			filter.EC2.Available(),
 			filter.EC2.IgnoreLocalZones(),
 		},
diff --git a/pkg/cloud/services/network/carriergateways.go b/pkg/cloud/services/network/carriergateways.go
index 6237df905..5a4fa05b6 100644
--- a/pkg/cloud/services/network/carriergateways.go
+++ b/pkg/cloud/services/network/carriergateways.go
@@ -20,8 +20,9 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/pkg/errors"
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
@@ -98,7 +99,7 @@ func (s *Service) deleteCarrierGateway() error {
 		CarrierGatewayId: cagw.CarrierGatewayId,
 	}
 
-	if _, err = s.EC2Client.DeleteCarrierGatewayWithContext(context.TODO(), deleteReq); err != nil {
+	if _, err = s.EC2Client.DeleteCarrierGateway(context.TODO(), deleteReq); err != nil {
 		record.Warnf(s.scope.InfraCluster(), "FailedDeleteCarrierGateway", "Failed to delete Carrier Gateway %q previously attached to VPC %q: %v", *cagw.CarrierGatewayId, s.scope.VPC().ID, err)
 		return errors.Wrapf(err, "failed to delete carrier gateway %q", *cagw.CarrierGatewayId)
 	}
@@ -109,11 +110,11 @@ func (s *Service) deleteCarrierGateway() error {
 	return nil
 }
 
-func (s *Service) createCarrierGateway() (*ec2.CarrierGateway, error) {
-	ig, err := s.EC2Client.CreateCarrierGatewayWithContext(context.TODO(), &ec2.CreateCarrierGatewayInput{
+func (s *Service) createCarrierGateway() (*types.CarrierGateway, error) {
+	ig, err := s.EC2Client.CreateCarrierGateway(context.TODO(), &ec2.CreateCarrierGatewayInput{
 		VpcId: aws.String(s.scope.VPC().ID),
-		TagSpecifications: []*ec2.TagSpecification{
-			tags.BuildParamsToTagSpecification(ec2.ResourceTypeCarrierGateway, s.getGatewayTagParams(services.TemporaryResourceID)),
+		TagSpecifications: []types.TagSpecification{
+			tags.BuildParamsToTagSpecification(types.ResourceTypeCarrierGateway, s.getGatewayTagParams(services.TemporaryResourceID)),
 		},
 	})
 	if err != nil {
@@ -126,9 +127,9 @@ func (s *Service) createCarrierGateway() (*ec2.CarrierGateway, error) {
 	return ig.CarrierGateway, nil
 }
 
-func (s *Service) describeVpcCarrierGateway() (*ec2.CarrierGateway, error) {
-	out, err := s.EC2Client.DescribeCarrierGatewaysWithContext(context.TODO(), &ec2.DescribeCarrierGatewaysInput{
-		Filters: []*ec2.Filter{
+func (s *Service) describeVpcCarrierGateway() (*types.CarrierGateway, error) {
+	out, err := s.EC2Client.DescribeCarrierGateways(context.TODO(), &ec2.DescribeCarrierGatewaysInput{
+		Filters: []types.Filter{
 			filter.EC2.VPC(s.scope.VPC().ID),
 		},
 	})
@@ -141,5 +142,5 @@ func (s *Service) describeVpcCarrierGateway() (*ec2.CarrierGateway, error) {
 		return nil, awserrors.NewNotFound(fmt.Sprintf("no carrier gateways found in vpc %q", s.scope.VPC().ID))
 	}
 
-	return out.CarrierGateways[0], nil
+	return &out.CarrierGateways[0], nil
 }
diff --git a/pkg/cloud/services/network/egress_only_gateways.go b/pkg/cloud/services/network/egress_only_gateways.go
index cfdfc71bc..8c734d8e4 100644
--- a/pkg/cloud/services/network/egress_only_gateways.go
+++ b/pkg/cloud/services/network/egress_only_gateways.go
@@ -20,8 +20,9 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/pkg/errors"
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
@@ -58,7 +59,7 @@ func (s *Service) reconcileEgressOnlyInternetGateways() error {
 		if err != nil {
 			return err
 		}
-		eigws = []*ec2.EgressOnlyInternetGateway{ig}
+		eigws = []types.EgressOnlyInternetGateway{*ig}
 	} else if err != nil {
 		return err
 	}
@@ -105,7 +106,7 @@ func (s *Service) deleteEgressOnlyInternetGateways() error {
 			EgressOnlyInternetGatewayId: ig.EgressOnlyInternetGatewayId,
 		}
 
-		if _, err = s.EC2Client.DeleteEgressOnlyInternetGatewayWithContext(context.TODO(), deleteReq); err != nil {
+		if _, err = s.EC2Client.DeleteEgressOnlyInternetGateway(context.TODO(), deleteReq); err != nil {
 			record.Warnf(s.scope.InfraCluster(), "FailedDeleteEgressOnlyInternetGateway", "Failed to delete Egress Only Internet Gateway %q previously attached to VPC %q: %v", *ig.EgressOnlyInternetGatewayId, s.scope.VPC().ID, err)
 			return errors.Wrapf(err, "failed to delete egress only internet gateway %q", *ig.EgressOnlyInternetGatewayId)
 		}
@@ -117,10 +118,10 @@ func (s *Service) deleteEgressOnlyInternetGateways() error {
 	return nil
 }
 
-func (s *Service) createEgressOnlyInternetGateway() (*ec2.EgressOnlyInternetGateway, error) {
-	ig, err := s.EC2Client.CreateEgressOnlyInternetGatewayWithContext(context.TODO(), &ec2.CreateEgressOnlyInternetGatewayInput{
-		TagSpecifications: []*ec2.TagSpecification{
-			tags.BuildParamsToTagSpecification(ec2.ResourceTypeEgressOnlyInternetGateway, s.getEgressOnlyGatewayTagParams(services.TemporaryResourceID)),
+func (s *Service) createEgressOnlyInternetGateway() (*types.EgressOnlyInternetGateway, error) {
+	ig, err := s.EC2Client.CreateEgressOnlyInternetGateway(context.TODO(), &ec2.CreateEgressOnlyInternetGatewayInput{
+		TagSpecifications: []types.TagSpecification{
+			tags.BuildParamsToTagSpecification(types.ResourceTypeEgressOnlyInternetGateway, s.getEgressOnlyGatewayTagParams(services.TemporaryResourceID)),
 		},
 		VpcId: aws.String(s.scope.VPC().ID),
 	})
@@ -134,9 +135,9 @@ func (s *Service) createEgressOnlyInternetGateway() (*ec2.EgressOnlyInternetGate
 	return ig.EgressOnlyInternetGateway, nil
 }
 
-func (s *Service) describeEgressOnlyVpcInternetGateways() ([]*ec2.EgressOnlyInternetGateway, error) {
-	out, err := s.EC2Client.DescribeEgressOnlyInternetGatewaysWithContext(context.TODO(), &ec2.DescribeEgressOnlyInternetGatewaysInput{
-		Filters: []*ec2.Filter{
+func (s *Service) describeEgressOnlyVpcInternetGateways() ([]types.EgressOnlyInternetGateway, error) {
+	out, err := s.EC2Client.DescribeEgressOnlyInternetGateways(context.TODO(), &ec2.DescribeEgressOnlyInternetGatewaysInput{
+		Filters: []types.Filter{
 			filter.EC2.VPCAttachment(s.scope.VPC().ID),
 		},
 	})
diff --git a/pkg/cloud/services/network/eips.go b/pkg/cloud/services/network/eips.go
index 0c546af5b..90d4c38da 100644
--- a/pkg/cloud/services/network/eips.go
+++ b/pkg/cloud/services/network/eips.go
@@ -20,8 +20,9 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/pkg/errors"
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
@@ -47,11 +48,11 @@ func (s *Service) getOrAllocateAddresses(num int, role string, pool *infrav1.Ela
 	}
 
 	// allocate addresses when needed.
-	tagSpecifications := tags.BuildParamsToTagSpecification(ec2.ResourceTypeElasticIp, s.getEIPTagParams(role))
+	tagSpecifications := tags.BuildParamsToTagSpecification(types.ResourceTypeElasticIp, s.getEIPTagParams(role))
 	for len(eips) < num {
 		allocInput := &ec2.AllocateAddressInput{
-			Domain: aws.String("vpc"),
-			TagSpecifications: []*ec2.TagSpecification{
+			Domain: types.DomainTypeVpc,
+			TagSpecifications: []types.TagSpecification{
 				tagSpecifications,
 			},
 		}
@@ -76,7 +77,7 @@ func (s *Service) getOrAllocateAddresses(num int, role string, pool *infrav1.Ela
 }
 
 func (s *Service) allocateAddress(alloc *ec2.AllocateAddressInput) (string, error) {
-	out, err := s.EC2Client.AllocateAddressWithContext(context.TODO(), alloc)
+	out, err := s.EC2Client.AllocateAddress(context.TODO(), alloc)
 	if err != nil {
 		return "", err
 	}
@@ -85,19 +86,19 @@ func (s *Service) allocateAddress(alloc *ec2.AllocateAddressInput) (string, erro
 }
 
 func (s *Service) describeAddresses(role string) (*ec2.DescribeAddressesOutput, error) {
-	x := []*ec2.Filter{filter.EC2.Cluster(s.scope.Name())}
+	x := []types.Filter{filter.EC2.Cluster(s.scope.Name())}
 	if role != "" {
 		x = append(x, filter.EC2.ProviderRole(role))
 	}
 
-	return s.EC2Client.DescribeAddressesWithContext(context.TODO(), &ec2.DescribeAddressesInput{
+	return s.EC2Client.DescribeAddresses(context.TODO(), &ec2.DescribeAddressesInput{
 		Filters: x,
 	})
 }
 
-func (s *Service) disassociateAddress(ip *ec2.Address) error {
+func (s *Service) disassociateAddress(ip types.Address) error {
 	err := wait.WaitForWithRetryable(wait.NewBackoff(), func() (bool, error) {
-		_, err := s.EC2Client.DisassociateAddressWithContext(context.TODO(), &ec2.DisassociateAddressInput{
+		_, err := s.EC2Client.DisassociateAddress(context.TODO(), &ec2.DisassociateAddressInput{
 			AssociationId: ip.AssociationId,
 		})
 		if err != nil {
@@ -116,9 +117,9 @@ func (s *Service) disassociateAddress(ip *ec2.Address) error {
 }
 
 // releaseAddress releases an given EIP address back to the pool.
-func (s *Service) releaseAddress(ip *ec2.Address) error {
+func (s *Service) releaseAddress(ip types.Address) error {
 	if ip.AssociationId != nil {
-		if _, err := s.EC2Client.DisassociateAddressWithContext(context.TODO(), &ec2.DisassociateAddressInput{
+		if _, err := s.EC2Client.DisassociateAddress(context.TODO(), &ec2.DisassociateAddressInput{
 			AssociationId: ip.AssociationId,
 		}); err != nil {
 			record.Warnf(s.scope.InfraCluster(), "FailedDisassociateEIP", "Failed to disassociate Elastic IP %q: %v", *ip.AllocationId, err)
@@ -127,7 +128,7 @@ func (s *Service) releaseAddress(ip *ec2.Address) error {
 	}
 
 	if err := wait.WaitForWithRetryable(wait.NewBackoff(), func() (bool, error) {
-		_, err := s.EC2Client.ReleaseAddressWithContext(context.TODO(), &ec2.ReleaseAddressInput{AllocationId: ip.AllocationId})
+		_, err := s.EC2Client.ReleaseAddress(context.TODO(), &ec2.ReleaseAddressInput{AllocationId: ip.AllocationId})
 		if err != nil {
 			if ip.AssociationId != nil {
 				if s.disassociateAddress(ip) != nil {
@@ -148,8 +149,8 @@ func (s *Service) releaseAddress(ip *ec2.Address) error {
 
 // releaseAddressesWithFilter discovery address to be released based in filters, returning no error,
 // when all addresses have been released.
-func (s *Service) releaseAddressesWithFilter(filters []*ec2.Filter) error {
-	out, err := s.EC2Client.DescribeAddressesWithContext(context.TODO(), &ec2.DescribeAddressesInput{
+func (s *Service) releaseAddressesWithFilter(filters []types.Filter) error {
+	out, err := s.EC2Client.DescribeAddresses(context.TODO(), &ec2.DescribeAddressesInput{
 		Filters: filters,
 	})
 	if err != nil {
@@ -169,7 +170,7 @@ func (s *Service) releaseAddressesWithFilter(filters []*ec2.Filter) error {
 // releaseAddresses is default cluster release flow, discoverying and releasing all
 // addresses associated and owned by the cluster tag.
 func (s *Service) releaseAddresses() error {
-	filters := []*ec2.Filter{filter.EC2.Cluster(s.scope.Name())}
+	filters := []types.Filter{filter.EC2.Cluster(s.scope.Name())}
 	filters = append(filters, filter.EC2.ClusterOwned(s.scope.Name()))
 	return s.releaseAddressesWithFilter(filters)
 }
@@ -198,7 +199,7 @@ func (s *Service) GetAddresses(role string) (*ec2.DescribeAddressesOutput, error
 
 // ReleaseAddressByRole releases EIP addresses filtering by tag CAPA provider role.
 func (s *Service) ReleaseAddressByRole(role string) error {
-	return s.releaseAddressesWithFilter([]*ec2.Filter{
+	return s.releaseAddressesWithFilter([]types.Filter{
 		filter.EC2.ClusterOwned(s.scope.Name()),
 		filter.EC2.ProviderRole(role),
 	})
@@ -229,7 +230,7 @@ func (s *Service) setByoPublicIpv4(pool *infrav1.ElasticIPPool, alloc *ec2.Alloc
 }
 
 // publicIpv4PoolHasAtLeastNFreeIPs check if there are N IPs address available in a Public IPv4 Pool.
-func (s *Service) publicIpv4PoolHasAtLeastNFreeIPs(pool *infrav1.ElasticIPPool, want int64) (bool, error) {
+func (s *Service) publicIpv4PoolHasAtLeastNFreeIPs(pool *infrav1.ElasticIPPool, want int32) (bool, error) {
 	if pool == nil {
 		return true, nil
 	}
@@ -237,8 +238,8 @@ func (s *Service) publicIpv4PoolHasAtLeastNFreeIPs(pool *infrav1.ElasticIPPool,
 		return true, nil
 	}
 	publicIpv4Pool := pool.PublicIpv4Pool
-	pools, err := s.EC2Client.DescribePublicIpv4Pools(&ec2.DescribePublicIpv4PoolsInput{
-		PoolIds: []*string{publicIpv4Pool},
+	pools, err := s.EC2Client.DescribePublicIpv4Pools(context.TODO(), &ec2.DescribePublicIpv4PoolsInput{
+		PoolIds: []string{aws.StringValue(publicIpv4Pool)},
 	})
 	if err != nil {
 		return false, fmt.Errorf("failed to describe Public IPv4 Pool %q: %w", *publicIpv4Pool, err)
@@ -247,7 +248,7 @@ func (s *Service) publicIpv4PoolHasAtLeastNFreeIPs(pool *infrav1.ElasticIPPool,
 		return false, fmt.Errorf("unexpected number of configured Public IPv4 Pools. want 1, got %d", len(pools.PublicIpv4Pools))
 	}
 
-	freeIPs := aws.Int64Value(pools.PublicIpv4Pools[0].TotalAvailableAddressCount)
+	freeIPs := aws.Int32Value(pools.PublicIpv4Pools[0].TotalAvailableAddressCount)
 	hasFreeIPs := freeIPs >= want
 
 	// force to fallback to Amazon pool when the custom pool is full.
diff --git a/pkg/cloud/services/network/gateways.go b/pkg/cloud/services/network/gateways.go
index d8581af53..161cc82a7 100644
--- a/pkg/cloud/services/network/gateways.go
+++ b/pkg/cloud/services/network/gateways.go
@@ -20,8 +20,9 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/pkg/errors"
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
@@ -53,7 +54,7 @@ func (s *Service) reconcileInternetGateways() error {
 		if err != nil {
 			return err
 		}
-		igs = []*ec2.InternetGateway{ig}
+		igs = []types.InternetGateway{*ig}
 	} else if err != nil {
 		return err
 	}
@@ -96,7 +97,7 @@ func (s *Service) deleteInternetGateways() error {
 			VpcId:             aws.String(s.scope.VPC().ID),
 		}
 
-		if _, err := s.EC2Client.DetachInternetGatewayWithContext(context.TODO(), detachReq); err != nil {
+		if _, err := s.EC2Client.DetachInternetGateway(context.TODO(), detachReq); err != nil {
 			record.Warnf(s.scope.InfraCluster(), "FailedDetachInternetGateway", "Failed to detach Internet Gateway %q from VPC %q: %v", *ig.InternetGatewayId, s.scope.VPC().ID, err)
 			return errors.Wrapf(err, "failed to detach internet gateway %q", *ig.InternetGatewayId)
 		}
@@ -108,7 +109,7 @@ func (s *Service) deleteInternetGateways() error {
 			InternetGatewayId: ig.InternetGatewayId,
 		}
 
-		if _, err = s.EC2Client.DeleteInternetGatewayWithContext(context.TODO(), deleteReq); err != nil {
+		if _, err = s.EC2Client.DeleteInternetGateway(context.TODO(), deleteReq); err != nil {
 			record.Warnf(s.scope.InfraCluster(), "FailedDeleteInternetGateway", "Failed to delete Internet Gateway %q previously attached to VPC %q: %v", *ig.InternetGatewayId, s.scope.VPC().ID, err)
 			return errors.Wrapf(err, "failed to delete internet gateway %q", *ig.InternetGatewayId)
 		}
@@ -120,10 +121,10 @@ func (s *Service) deleteInternetGateways() error {
 	return nil
 }
 
-func (s *Service) createInternetGateway() (*ec2.InternetGateway, error) {
-	ig, err := s.EC2Client.CreateInternetGatewayWithContext(context.TODO(), &ec2.CreateInternetGatewayInput{
-		TagSpecifications: []*ec2.TagSpecification{
-			tags.BuildParamsToTagSpecification(ec2.ResourceTypeInternetGateway, s.getGatewayTagParams(services.TemporaryResourceID)),
+func (s *Service) createInternetGateway() (*types.InternetGateway, error) {
+	ig, err := s.EC2Client.CreateInternetGateway(context.TODO(), &ec2.CreateInternetGatewayInput{
+		TagSpecifications: []types.TagSpecification{
+			tags.BuildParamsToTagSpecification(types.ResourceTypeInternetGateway, s.getGatewayTagParams(services.TemporaryResourceID)),
 		},
 	})
 	if err != nil {
@@ -134,7 +135,7 @@ func (s *Service) createInternetGateway() (*ec2.InternetGateway, error) {
 	s.scope.Info("Created Internet gateway for VPC", "internet-gateway-id", *ig.InternetGateway.InternetGatewayId, "vpc-id", s.scope.VPC().ID)
 
 	if err := wait.WaitForWithRetryable(wait.NewBackoff(), func() (bool, error) {
-		if _, err := s.EC2Client.AttachInternetGatewayWithContext(context.TODO(), &ec2.AttachInternetGatewayInput{
+		if _, err := s.EC2Client.AttachInternetGateway(context.TODO(), &ec2.AttachInternetGatewayInput{
 			InternetGatewayId: ig.InternetGateway.InternetGatewayId,
 			VpcId:             aws.String(s.scope.VPC().ID),
 		}); err != nil {
@@ -151,9 +152,9 @@ func (s *Service) createInternetGateway() (*ec2.InternetGateway, error) {
 	return ig.InternetGateway, nil
 }
 
-func (s *Service) describeVpcInternetGateways() ([]*ec2.InternetGateway, error) {
-	out, err := s.EC2Client.DescribeInternetGatewaysWithContext(context.TODO(), &ec2.DescribeInternetGatewaysInput{
-		Filters: []*ec2.Filter{
+func (s *Service) describeVpcInternetGateways() ([]types.InternetGateway, error) {
+	out, err := s.EC2Client.DescribeInternetGateways(context.TODO(), &ec2.DescribeInternetGatewaysInput{
+		Filters: []types.Filter{
 			filter.EC2.VPCAttachment(s.scope.VPC().ID),
 		},
 	})
diff --git a/pkg/cloud/services/network/natgateways.go b/pkg/cloud/services/network/natgateways.go
index 276cde000..f3c7b33ec 100644
--- a/pkg/cloud/services/network/natgateways.go
+++ b/pkg/cloud/services/network/natgateways.go
@@ -20,9 +20,11 @@ import (
 	"context"
 	"fmt"
 	"sort"
+	"time"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/pkg/errors"
 	kerrors "k8s.io/apimachinery/pkg/util/errors"
 
@@ -166,7 +168,7 @@ func (s *Service) deleteNatGateways() error {
 		return err
 	}
 
-	var ngIDs []*ec2.NatGateway
+	var ngIDs []types.NatGateway
 	for _, sn := range s.scope.Subnets().FilterPublic() {
 		if sn.GetResourceID() == "" {
 			continue
@@ -181,7 +183,7 @@ func (s *Service) deleteNatGateways() error {
 	errs := []error{}
 
 	for _, ngID := range ngIDs {
-		go func(c chan error, ngID *ec2.NatGateway) {
+		go func(c chan error, ngID types.NatGateway) {
 			err := s.deleteNatGateway(*ngID.NatGatewayId)
 			c <- err
 		}(c, ngID)
@@ -197,26 +199,26 @@ func (s *Service) deleteNatGateways() error {
 	return kerrors.NewAggregate(errs)
 }
 
-func (s *Service) describeNatGatewaysBySubnet() (map[string]*ec2.NatGateway, error) {
+func (s *Service) describeNatGatewaysBySubnet() (map[string]types.NatGateway, error) {
 	describeNatGatewayInput := &ec2.DescribeNatGatewaysInput{
-		Filter: []*ec2.Filter{
+		Filter: []types.Filter{
 			filter.EC2.VPC(s.scope.VPC().ID),
-			filter.EC2.NATGatewayStates(ec2.NatGatewayStatePending, ec2.NatGatewayStateAvailable),
+			filter.EC2.NATGatewayStates(types.NatGatewayStatePending, types.NatGatewayStateAvailable),
 		},
 	}
 
-	gateways := make(map[string]*ec2.NatGateway)
+	gateways := make(map[string]types.NatGateway)
 
-	err := s.EC2Client.DescribeNatGatewaysPagesWithContext(context.TODO(), describeNatGatewayInput,
-		func(page *ec2.DescribeNatGatewaysOutput, lastPage bool) bool {
-			for _, r := range page.NatGateways {
-				gateways[*r.SubnetId] = r
-			}
-			return !lastPage
-		})
-	if err != nil {
-		record.Eventf(s.scope.InfraCluster(), "FailedDescribeNATGateways", "Failed to describe NAT gateways with VPC ID %q: %v", s.scope.VPC().ID, err)
-		return nil, errors.Wrapf(err, "failed to describe NAT gateways with VPC ID %q", s.scope.VPC().ID)
+	paginator := ec2.NewDescribeNatGatewaysPaginator(s.EC2Client, describeNatGatewayInput)
+	for paginator.HasMorePages() {
+		output, err := paginator.NextPage(context.TODO())
+		if err != nil {
+			record.Eventf(s.scope.InfraCluster(), "FailedDescribeNATGateways", "Failed to describe NAT gateways with VPC ID %q: %v", s.scope.VPC().ID, err)
+			return nil, errors.Wrapf(err, "failed to describe NAT gateways with VPC ID %q", s.scope.VPC().ID)
+		}
+		for _, r := range output.NatGateways {
+			gateways[aws.ToString(r.SubnetId)] = r
+		}
 	}
 
 	return gateways, nil
@@ -235,13 +237,13 @@ func (s *Service) getNatGatewayTagParams(id string) infrav1.BuildParams {
 	}
 }
 
-func (s *Service) createNatGateways(subnetIDs []string) (natgateways []*ec2.NatGateway, err error) {
+func (s *Service) createNatGateways(subnetIDs []string) (natgateways []*types.NatGateway, err error) {
 	eips, err := s.getOrAllocateAddresses(len(subnetIDs), infrav1.CommonRoleTagValue, s.scope.VPC().GetElasticIPPool())
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed to create one or more IP addresses for NAT gateways")
 	}
 	type ngwCreation struct {
-		natGateway *ec2.NatGateway
+		natGateway *types.NatGateway
 		error      error
 	}
 	c := make(chan ngwCreation, len(subnetIDs))
@@ -263,15 +265,15 @@ func (s *Service) createNatGateways(subnetIDs []string) (natgateways []*ec2.NatG
 	return natgateways, nil
 }
 
-func (s *Service) createNatGateway(subnetID, ip string) (*ec2.NatGateway, error) {
+func (s *Service) createNatGateway(subnetID, ip string) (*types.NatGateway, error) {
 	var out *ec2.CreateNatGatewayOutput
 	var err error
 
 	if err := wait.WaitForWithRetryable(wait.NewBackoff(), func() (bool, error) {
-		if out, err = s.EC2Client.CreateNatGatewayWithContext(context.TODO(), &ec2.CreateNatGatewayInput{
+		if out, err = s.EC2Client.CreateNatGateway(context.TODO(), &ec2.CreateNatGatewayInput{
 			SubnetId:          aws.String(subnetID),
 			AllocationId:      aws.String(ip),
-			TagSpecifications: []*ec2.TagSpecification{tags.BuildParamsToTagSpecification(ec2.ResourceTypeNatgateway, s.getNatGatewayTagParams(services.TemporaryResourceID))},
+			TagSpecifications: []types.TagSpecification{tags.BuildParamsToTagSpecification(types.ResourceTypeNatgateway, s.getNatGatewayTagParams(services.TemporaryResourceID))},
 		}); err != nil {
 			return false, err
 		}
@@ -282,8 +284,9 @@ func (s *Service) createNatGateway(subnetID, ip string) (*ec2.NatGateway, error)
 	}
 	record.Eventf(s.scope.InfraCluster(), "SuccessfulCreateNATGateway", "Created new NAT Gateway %q", *out.NatGateway.NatGatewayId)
 
-	wReq := &ec2.DescribeNatGatewaysInput{NatGatewayIds: []*string{out.NatGateway.NatGatewayId}}
-	if err := s.EC2Client.WaitUntilNatGatewayAvailableWithContext(context.TODO(), wReq); err != nil {
+	if err := ec2.NewNatGatewayAvailableWaiter(s.EC2Client).Wait(context.TODO(), &ec2.DescribeNatGatewaysInput{
+		NatGatewayIds: []string{aws.ToString(out.NatGateway.NatGatewayId)},
+	}, time.Minute*2); err != nil {
 		return nil, errors.Wrapf(err, "failed to wait for nat gateway %q in subnet %q", *out.NatGateway.NatGatewayId, subnetID)
 	}
 
@@ -292,7 +295,7 @@ func (s *Service) createNatGateway(subnetID, ip string) (*ec2.NatGateway, error)
 }
 
 func (s *Service) deleteNatGateway(id string) error {
-	_, err := s.EC2Client.DeleteNatGatewayWithContext(context.TODO(), &ec2.DeleteNatGatewayInput{
+	_, err := s.EC2Client.DeleteNatGateway(context.TODO(), &ec2.DeleteNatGatewayInput{
 		NatGatewayId: aws.String(id),
 	})
 	if err != nil {
@@ -303,11 +306,11 @@ func (s *Service) deleteNatGateway(id string) error {
 	s.scope.Info("Deleted NAT gateway in VPC", "nat-gateway-id", id, "vpc-id", s.scope.VPC().ID)
 
 	describeInput := &ec2.DescribeNatGatewaysInput{
-		NatGatewayIds: []*string{aws.String(id)},
+		NatGatewayIds: []string{id},
 	}
 
 	if err := wait.WaitForWithRetryable(wait.NewBackoff(), func() (done bool, err error) {
-		out, err := s.EC2Client.DescribeNatGatewaysWithContext(context.TODO(), describeInput)
+		out, err := s.EC2Client.DescribeNatGateways(context.TODO(), describeInput)
 		if err != nil {
 			return false, err
 		}
@@ -317,14 +320,14 @@ func (s *Service) deleteNatGateway(id string) error {
 		}
 
 		ng := out.NatGateways[0]
-		switch state := ng.State; *state {
-		case ec2.NatGatewayStateAvailable, ec2.NatGatewayStateDeleting:
+		switch state := ng.State; state {
+		case types.NatGatewayStateAvailable, types.NatGatewayStateDeleting:
 			return false, nil
-		case ec2.NatGatewayStateDeleted:
+		case types.NatGatewayStateDeleted:
 			return true, nil
-		case ec2.NatGatewayStatePending:
+		case types.NatGatewayStatePending:
 			return false, errors.Errorf("in pending state")
-		case ec2.NatGatewayStateFailed:
+		case types.NatGatewayStateFailed:
 			return false, errors.Errorf("in failed state: %q - %s", *ng.FailureCode, *ng.FailureMessage)
 		}
 
@@ -371,7 +374,7 @@ func (s *Service) getNatGatewayForSubnet(sn *infrav1.SubnetSpec) (string, error)
 
 	// Check if the parent zone public subnet has nat gateway
 	if sn.ParentZoneName != nil {
-		if gws, ok := azGateways[aws.StringValue(sn.ParentZoneName)]; ok && len(gws) > 0 {
+		if gws, ok := azGateways[aws.ToString(sn.ParentZoneName)]; ok && len(gws) > 0 {
 			return gws, nil
 		}
 	}
diff --git a/pkg/cloud/services/network/routetables.go b/pkg/cloud/services/network/routetables.go
index 66694b2dd..21dd039ff 100644
--- a/pkg/cloud/services/network/routetables.go
+++ b/pkg/cloud/services/network/routetables.go
@@ -20,8 +20,9 @@ import (
 	"context"
 	"strings"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/pkg/errors"
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
@@ -67,7 +68,7 @@ func (s *Service) reconcileRouteTables() error {
 		}
 
 		if rt, ok := subnetRouteMap[sn.GetResourceID()]; ok {
-			s.scope.Debug("Subnet is already associated with route table", "subnet-id", sn.GetResourceID(), "route-table-id", *rt.RouteTableId)
+			s.scope.Debug("Subnet is already associated with route table", "subnet-id", sn.GetResourceID(), "route-table-id", aws.ToString(rt.RouteTableId))
 			// TODO(vincepri): check that everything is in order, e.g. routes match the subnet type.
 
 			// For managed environments we need to reconcile the routes of our tables if there is a mistmatch.
@@ -85,15 +86,15 @@ func (s *Service) reconcileRouteTables() error {
 
 			// Make sure tags are up-to-date.
 			if err := wait.WaitForWithRetryable(wait.NewBackoff(), func() (bool, error) {
-				buildParams := s.getRouteTableTagParams(*rt.RouteTableId, sn.IsPublic, sn.AvailabilityZone)
+				buildParams := s.getRouteTableTagParams(aws.ToString(rt.RouteTableId), sn.IsPublic, sn.AvailabilityZone)
 				tagsBuilder := tags.New(&buildParams, tags.WithEC2(s.EC2Client))
 				if err := tagsBuilder.Ensure(converters.TagsToMap(rt.Tags)); err != nil {
 					return false, err
 				}
 				return true, nil
 			}, awserrors.RouteTableNotFound); err != nil {
-				record.Warnf(s.scope.InfraCluster(), "FailedTagRouteTable", "Failed to tag managed RouteTable %q: %v", *rt.RouteTableId, err)
-				return errors.Wrapf(err, "failed to ensure tags on route table %q", *rt.RouteTableId)
+				record.Warnf(s.scope.InfraCluster(), "FailedTagRouteTable", "Failed to tag managed RouteTable %q: %v", aws.ToString(rt.RouteTableId), err)
+				return errors.Wrapf(err, "failed to ensure tags on route table %q", aws.ToString(rt.RouteTableId))
 			}
 
 			// Not recording "SuccessfulTagRouteTable" here as we don't know if this was a no-op or an actual change
@@ -125,13 +126,13 @@ func (s *Service) reconcileRouteTables() error {
 	return nil
 }
 
-func (s *Service) fixMismatchedRouting(specRoute *ec2.CreateRouteInput, currentRoute *ec2.Route, rt *ec2.RouteTable) error {
+func (s *Service) fixMismatchedRouting(specRoute *ec2.CreateRouteInput, currentRoute types.Route, rt types.RouteTable) error {
 	var input *ec2.ReplaceRouteInput
 	if specRoute.DestinationCidrBlock != nil {
 		if (currentRoute.DestinationCidrBlock != nil &&
-			*currentRoute.DestinationCidrBlock == *specRoute.DestinationCidrBlock) &&
-			((currentRoute.GatewayId != nil && *currentRoute.GatewayId != *specRoute.GatewayId) ||
-				(currentRoute.NatGatewayId != nil && *currentRoute.NatGatewayId != *specRoute.NatGatewayId)) {
+			aws.ToString(currentRoute.DestinationCidrBlock) == aws.ToString(specRoute.DestinationCidrBlock)) &&
+			((currentRoute.GatewayId != nil && aws.ToString(currentRoute.GatewayId) != aws.ToString(specRoute.GatewayId)) ||
+				(currentRoute.NatGatewayId != nil && aws.ToString(currentRoute.NatGatewayId) != aws.ToString(specRoute.NatGatewayId))) {
 			input = &ec2.ReplaceRouteInput{
 				RouteTableId:         rt.RouteTableId,
 				DestinationCidrBlock: specRoute.DestinationCidrBlock,
@@ -142,9 +143,9 @@ func (s *Service) fixMismatchedRouting(specRoute *ec2.CreateRouteInput, currentR
 	}
 	if specRoute.DestinationIpv6CidrBlock != nil {
 		if (currentRoute.DestinationIpv6CidrBlock != nil &&
-			*currentRoute.DestinationIpv6CidrBlock == *specRoute.DestinationIpv6CidrBlock) &&
-			((currentRoute.GatewayId != nil && *currentRoute.GatewayId != *specRoute.GatewayId) ||
-				(currentRoute.NatGatewayId != nil && *currentRoute.NatGatewayId != *specRoute.NatGatewayId)) {
+			aws.ToString(currentRoute.DestinationIpv6CidrBlock) == aws.ToString(specRoute.DestinationIpv6CidrBlock)) &&
+			((currentRoute.GatewayId != nil && aws.ToString(currentRoute.GatewayId) != aws.ToString(specRoute.GatewayId)) ||
+				(currentRoute.NatGatewayId != nil && aws.ToString(currentRoute.NatGatewayId) != aws.ToString(specRoute.NatGatewayId))) {
 			input = &ec2.ReplaceRouteInput{
 				RouteTableId:                rt.RouteTableId,
 				DestinationIpv6CidrBlock:    specRoute.DestinationIpv6CidrBlock,
@@ -157,19 +158,19 @@ func (s *Service) fixMismatchedRouting(specRoute *ec2.CreateRouteInput, currentR
 	}
 	if input != nil {
 		if err := wait.WaitForWithRetryable(wait.NewBackoff(), func() (bool, error) {
-			if _, err := s.EC2Client.ReplaceRouteWithContext(context.TODO(), input); err != nil {
+			if _, err := s.EC2Client.ReplaceRoute(context.TODO(), input); err != nil {
 				return false, err
 			}
 			return true, nil
 		}); err != nil {
-			record.Warnf(s.scope.InfraCluster(), "FailedReplaceRoute", "Failed to replace outdated route on managed RouteTable %q: %v", *rt.RouteTableId, err)
-			return errors.Wrapf(err, "failed to replace outdated route on route table %q", *rt.RouteTableId)
+			record.Warnf(s.scope.InfraCluster(), "FailedReplaceRoute", "Failed to replace outdated route on managed RouteTable %q: %v", aws.ToString(rt.RouteTableId), err)
+			return errors.Wrapf(err, "failed to replace outdated route on route table %q", aws.ToString(rt.RouteTableId))
 		}
 	}
 	return nil
 }
 
-func (s *Service) describeVpcRouteTablesBySubnet() (map[string]*ec2.RouteTable, error) {
+func (s *Service) describeVpcRouteTablesBySubnet() (map[string]types.RouteTable, error) {
 	rts, err := s.describeVpcRouteTables()
 	if err != nil {
 		return nil, err
@@ -177,7 +178,7 @@ func (s *Service) describeVpcRouteTablesBySubnet() (map[string]*ec2.RouteTable,
 
 	// Amazon allows a subnet to be associated only with a single routing table
 	// https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html.
-	res := make(map[string]*ec2.RouteTable)
+	res := make(map[string]types.RouteTable)
 	for _, rt := range rts {
 		for _, as := range rt.Associations {
 			if as.Main != nil && *as.Main {
@@ -187,35 +188,35 @@ func (s *Service) describeVpcRouteTablesBySubnet() (map[string]*ec2.RouteTable,
 				continue
 			}
 
-			res[*as.SubnetId] = rt
+			res[aws.ToString(as.SubnetId)] = rt
 		}
 	}
 
 	return res, nil
 }
 
-func (s *Service) deleteRouteTable(rt *ec2.RouteTable) error {
+func (s *Service) deleteRouteTable(rt types.RouteTable) error {
 	for _, as := range rt.Associations {
 		if as.SubnetId == nil {
 			continue
 		}
 
-		if _, err := s.EC2Client.DisassociateRouteTableWithContext(context.TODO(), &ec2.DisassociateRouteTableInput{AssociationId: as.RouteTableAssociationId}); err != nil {
-			record.Warnf(s.scope.InfraCluster(), "FailedDisassociateRouteTable", "Failed to disassociate managed RouteTable %q from Subnet %q: %v", *rt.RouteTableId, *as.SubnetId, err)
-			return errors.Wrapf(err, "failed to disassociate route table %q from subnet %q", *rt.RouteTableId, *as.SubnetId)
+		if _, err := s.EC2Client.DisassociateRouteTable(context.TODO(), &ec2.DisassociateRouteTableInput{AssociationId: as.RouteTableAssociationId}); err != nil {
+			record.Warnf(s.scope.InfraCluster(), "FailedDisassociateRouteTable", "Failed to disassociate managed RouteTable %q from Subnet %q: %v", aws.ToString(rt.RouteTableId), aws.ToString(as.SubnetId), err)
+			return errors.Wrapf(err, "failed to disassociate route table %q from subnet %q", aws.ToString(rt.RouteTableId), aws.ToString(as.SubnetId))
 		}
 
-		record.Eventf(s.scope.InfraCluster(), "SuccessfulDisassociateRouteTable", "Disassociated managed RouteTable %q from subnet %q", *rt.RouteTableId, *as.SubnetId)
-		s.scope.Debug("Deleted association between route table and subnet", "route-table-id", *rt.RouteTableId, "subnet-id", *as.SubnetId)
+		record.Eventf(s.scope.InfraCluster(), "SuccessfulDisassociateRouteTable", "Disassociated managed RouteTable %q from subnet %q", aws.ToString(rt.RouteTableId), aws.ToString(as.SubnetId))
+		s.scope.Debug("Deleted association between route table and subnet", "route-table-id", aws.ToString(rt.RouteTableId), "subnet-id", aws.ToString(as.SubnetId))
 	}
 
-	if _, err := s.EC2Client.DeleteRouteTableWithContext(context.TODO(), &ec2.DeleteRouteTableInput{RouteTableId: rt.RouteTableId}); err != nil {
-		record.Warnf(s.scope.InfraCluster(), "FailedDeleteRouteTable", "Failed to delete managed RouteTable %q: %v", *rt.RouteTableId, err)
-		return errors.Wrapf(err, "failed to delete route table %q", *rt.RouteTableId)
+	if _, err := s.EC2Client.DeleteRouteTable(context.TODO(), &ec2.DeleteRouteTableInput{RouteTableId: rt.RouteTableId}); err != nil {
+		record.Warnf(s.scope.InfraCluster(), "FailedDeleteRouteTable", "Failed to delete managed RouteTable %q: %v", aws.ToString(rt.RouteTableId), err)
+		return errors.Wrapf(err, "failed to delete route table %q", aws.ToString(rt.RouteTableId))
 	}
 
-	record.Eventf(s.scope.InfraCluster(), "SuccessfulDeleteRouteTable", "Deleted managed RouteTable %q", *rt.RouteTableId)
-	s.scope.Info("Deleted route table", "route-table-id", *rt.RouteTableId)
+	record.Eventf(s.scope.InfraCluster(), "SuccessfulDeleteRouteTable", "Deleted managed RouteTable %q", aws.ToString(rt.RouteTableId))
+	s.scope.Info("Deleted route table", "route-table-id", aws.ToString(rt.RouteTableId))
 
 	return nil
 }
@@ -240,8 +241,8 @@ func (s *Service) deleteRouteTables() error {
 	return nil
 }
 
-func (s *Service) describeVpcRouteTables() ([]*ec2.RouteTable, error) {
-	filters := []*ec2.Filter{
+func (s *Service) describeVpcRouteTables() ([]types.RouteTable, error) {
+	filters := []types.Filter{
 		filter.EC2.VPC(s.scope.VPC().ID),
 	}
 
@@ -249,7 +250,7 @@ func (s *Service) describeVpcRouteTables() ([]*ec2.RouteTable, error) {
 		filters = append(filters, filter.EC2.Cluster(s.scope.Name()))
 	}
 
-	out, err := s.EC2Client.DescribeRouteTablesWithContext(context.TODO(), &ec2.DescribeRouteTablesInput{
+	out, err := s.EC2Client.DescribeRouteTables(context.TODO(), &ec2.DescribeRouteTablesInput{
 		Filters: filters,
 	})
 	if err != nil {
@@ -261,35 +262,35 @@ func (s *Service) describeVpcRouteTables() ([]*ec2.RouteTable, error) {
 }
 
 func (s *Service) createRouteTableWithRoutes(routes []*ec2.CreateRouteInput, isPublic bool, zone string) (*infrav1.RouteTable, error) {
-	out, err := s.EC2Client.CreateRouteTableWithContext(context.TODO(), &ec2.CreateRouteTableInput{
+	out, err := s.EC2Client.CreateRouteTable(context.TODO(), &ec2.CreateRouteTableInput{
 		VpcId: aws.String(s.scope.VPC().ID),
-		TagSpecifications: []*ec2.TagSpecification{
-			tags.BuildParamsToTagSpecification(ec2.ResourceTypeRouteTable, s.getRouteTableTagParams(services.TemporaryResourceID, isPublic, zone))},
+		TagSpecifications: []types.TagSpecification{
+			tags.BuildParamsToTagSpecification(types.ResourceTypeRouteTable, s.getRouteTableTagParams(services.TemporaryResourceID, isPublic, zone))},
 	})
 	if err != nil {
 		record.Warnf(s.scope.InfraCluster(), "FailedCreateRouteTable", "Failed to create managed RouteTable: %v", err)
 		return nil, errors.Wrapf(err, "failed to create route table in vpc %q", s.scope.VPC().ID)
 	}
-	record.Eventf(s.scope.InfraCluster(), "SuccessfulCreateRouteTable", "Created managed RouteTable %q", *out.RouteTable.RouteTableId)
+	record.Eventf(s.scope.InfraCluster(), "SuccessfulCreateRouteTable", "Created managed RouteTable %q", aws.ToString(out.RouteTable.RouteTableId))
 	s.scope.Info("Created route table", "route-table-id", *out.RouteTable.RouteTableId)
 
 	for i := range routes {
 		route := routes[i]
 		if err := wait.WaitForWithRetryable(wait.NewBackoff(), func() (bool, error) {
 			route.RouteTableId = out.RouteTable.RouteTableId
-			if _, err := s.EC2Client.CreateRouteWithContext(context.TODO(), route); err != nil {
+			if _, err := s.EC2Client.CreateRoute(context.TODO(), route); err != nil {
 				return false, err
 			}
 			return true, nil
 		}, awserrors.RouteTableNotFound, awserrors.NATGatewayNotFound, awserrors.GatewayNotFound); err != nil {
-			record.Warnf(s.scope.InfraCluster(), "FailedCreateRoute", "Failed to create route %s for RouteTable %q: %v", route.GoString(), *out.RouteTable.RouteTableId, err)
-			errDel := s.deleteRouteTable(out.RouteTable)
+			record.Warnf(s.scope.InfraCluster(), "FailedCreateRoute", "Failed to create route %s for RouteTable %q: %v", route, aws.ToString(out.RouteTable.RouteTableId), err)
+			errDel := s.deleteRouteTable(*out.RouteTable)
 			if errDel != nil {
-				record.Warnf(s.scope.InfraCluster(), "FailedDeleteRouteTable", "Failed to delete managed RouteTable %q: %v", *out.RouteTable.RouteTableId, errDel)
+				record.Warnf(s.scope.InfraCluster(), "FailedDeleteRouteTable", "Failed to delete managed RouteTable %q: %v", aws.ToString(out.RouteTable.RouteTableId), errDel)
 			}
-			return nil, errors.Wrapf(err, "failed to create route in route table %q: %s", *out.RouteTable.RouteTableId, route.GoString())
+			return nil, errors.Wrapf(err, "failed to create route in route table %q: %v", aws.ToString(out.RouteTable.RouteTableId), route)
 		}
-		record.Eventf(s.scope.InfraCluster(), "SuccessfulCreateRoute", "Created route %s for RouteTable %q", route.GoString(), *out.RouteTable.RouteTableId)
+		record.Eventf(s.scope.InfraCluster(), "SuccessfulCreateRoute", "Created route %s for RouteTable %q", route, aws.ToString(out.RouteTable.RouteTableId))
 	}
 
 	return &infrav1.RouteTable{
@@ -298,7 +299,7 @@ func (s *Service) createRouteTableWithRoutes(routes []*ec2.CreateRouteInput, isP
 }
 
 func (s *Service) associateRouteTable(rt *infrav1.RouteTable, subnetID string) error {
-	_, err := s.EC2Client.AssociateRouteTableWithContext(context.TODO(), &ec2.AssociateRouteTableInput{
+	_, err := s.EC2Client.AssociateRouteTable(context.TODO(), &ec2.AssociateRouteTableInput{
 		RouteTableId: aws.String(rt.ID),
 		SubnetId:     aws.String(subnetID),
 	})
diff --git a/pkg/cloud/services/network/secondarycidr.go b/pkg/cloud/services/network/secondarycidr.go
index 45151af95..db03a00d5 100644
--- a/pkg/cloud/services/network/secondarycidr.go
+++ b/pkg/cloud/services/network/secondarycidr.go
@@ -19,7 +19,7 @@ package network
 import (
 	"context"
 
-	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
 	"github.com/pkg/errors"
 
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/record"
@@ -35,8 +35,8 @@ func (s *Service) associateSecondaryCidrs() error {
 		return nil
 	}
 
-	vpcs, err := s.EC2Client.DescribeVpcsWithContext(context.TODO(), &ec2.DescribeVpcsInput{
-		VpcIds: []*string{&s.scope.VPC().ID},
+	vpcs, err := s.EC2Client.DescribeVpcs(context.TODO(), &ec2.DescribeVpcsInput{
+		VpcIds: []string{s.scope.VPC().ID},
 	})
 	if err != nil {
 		return err
@@ -61,7 +61,7 @@ func (s *Service) associateSecondaryCidrs() error {
 			continue
 		}
 
-		out, err := s.EC2Client.AssociateVpcCidrBlockWithContext(context.TODO(), &ec2.AssociateVpcCidrBlockInput{
+		out, err := s.EC2Client.AssociateVpcCidrBlock(context.TODO(), &ec2.AssociateVpcCidrBlockInput{
 			VpcId:     &s.scope.VPC().ID,
 			CidrBlock: &desiredCidrBlock.IPv4CidrBlock,
 		})
@@ -89,8 +89,8 @@ func (s *Service) disassociateSecondaryCidrs() error {
 		return nil
 	}
 
-	vpcs, err := s.EC2Client.DescribeVpcsWithContext(context.TODO(), &ec2.DescribeVpcsInput{
-		VpcIds: []*string{&s.scope.VPC().ID},
+	vpcs, err := s.EC2Client.DescribeVpcs(context.TODO(), &ec2.DescribeVpcsInput{
+		VpcIds: []string{s.scope.VPC().ID},
 	})
 	if err != nil {
 		return err
@@ -104,7 +104,7 @@ func (s *Service) disassociateSecondaryCidrs() error {
 	for _, cidrBlockToDelete := range secondaryCidrBlocks {
 		for _, existing := range existingAssociations {
 			if *existing.CidrBlock == cidrBlockToDelete.IPv4CidrBlock {
-				if _, err := s.EC2Client.DisassociateVpcCidrBlockWithContext(context.TODO(), &ec2.DisassociateVpcCidrBlockInput{
+				if _, err := s.EC2Client.DisassociateVpcCidrBlock(context.TODO(), &ec2.DisassociateVpcCidrBlockInput{
 					AssociationId: existing.AssociationId,
 				}); err != nil {
 					record.Warnf(s.scope.InfraCluster(), "FailedDisassociateSecondaryCidr", "Failed disassociating secondary CIDR %q from VPC %v", cidrBlockToDelete.IPv4CidrBlock, err)
diff --git a/pkg/cloud/services/network/service.go b/pkg/cloud/services/network/service.go
index 8c223c5e6..0279221b5 100644
--- a/pkg/cloud/services/network/service.go
+++ b/pkg/cloud/services/network/service.go
@@ -18,9 +18,8 @@ limitations under the License.
 package network
 
 import (
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
-
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope"
+	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/common"
 )
 
 // Service holds a collection of interfaces.
@@ -28,7 +27,7 @@ import (
 // One alternative is to have a large list of functions from the ec2 client.
 type Service struct {
 	scope     scope.NetworkScope
-	EC2Client ec2iface.EC2API
+	EC2Client common.EC2API
 }
 
 // NewService returns a new service given the ec2 api client.
diff --git a/pkg/cloud/services/network/subnets.go b/pkg/cloud/services/network/subnets.go
index 5ac8918cc..1cf991ec5 100644
--- a/pkg/cloud/services/network/subnets.go
+++ b/pkg/cloud/services/network/subnets.go
@@ -23,9 +23,11 @@ import (
 	"net"
 	"sort"
 	"strings"
+	"time"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/pkg/errors"
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
@@ -207,9 +209,9 @@ func (s *Service) reconcileSubnets() error {
 	return nil
 }
 
-func (s *Service) retrieveZoneInfo(zoneNames []string) ([]*ec2.AvailabilityZone, error) {
-	zones, err := s.EC2Client.DescribeAvailabilityZonesWithContext(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
-		ZoneNames: aws.StringSlice(zoneNames),
+func (s *Service) retrieveZoneInfo(zoneNames []string) ([]types.AvailabilityZone, error) {
+	zones, err := s.EC2Client.DescribeAvailabilityZones(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
+		ZoneNames: zoneNames,
 	})
 	if err != nil {
 		record.Eventf(s.scope.InfraCluster(), "FailedDescribeAvailableZones", "Failed getting available zones: %v", err)
@@ -402,7 +404,7 @@ func (s *Service) describeVpcSubnets() (infrav1.Subnets, error) {
 		// For IPv6 subnets, both, ipv4 and 6 have to be defined so pods can have ipv6 cidr ranges.
 		spec.CidrBlock = aws.StringValue(ec2sn.CidrBlock)
 		for _, set := range ec2sn.Ipv6CidrBlockAssociationSet {
-			if *set.Ipv6CidrBlockState.State == ec2.SubnetCidrBlockStateCodeAssociated {
+			if set.Ipv6CidrBlockState.State == types.SubnetCidrBlockStateCodeAssociated {
 				spec.IPv6CidrBlock = aws.StringValue(set.Ipv6CidrBlock)
 				spec.IsIPv6 = true
 			}
@@ -413,12 +415,12 @@ func (s *Service) describeVpcSubnets() (infrav1.Subnets, error) {
 		}
 
 		// ... or if it has an internet route
-		rt := routeTables[*ec2sn.SubnetId]
-		if rt == nil {
+		rt, ok := routeTables[*ec2sn.SubnetId]
+		if !ok {
 			// If there is no explicit association, subnet defaults to main route table as implicit association
 			rt = routeTables[mainRouteTableInVPCKey]
 		}
-		if rt != nil {
+		if ok {
 			spec.RouteTableID = rt.RouteTableId
 			for _, route := range rt.Routes {
 				if route.GatewayId != nil && strings.HasPrefix(*route.GatewayId, "igw") {
@@ -430,8 +432,8 @@ func (s *Service) describeVpcSubnets() (infrav1.Subnets, error) {
 			}
 		}
 
-		ngw := natGateways[*ec2sn.SubnetId]
-		if ngw != nil {
+		ngw, ok := natGateways[*ec2sn.SubnetId]
+		if ok {
 			spec.NatGatewayID = ngw.NatGatewayId
 		}
 		subnets = append(subnets, spec)
@@ -442,8 +444,8 @@ func (s *Service) describeVpcSubnets() (infrav1.Subnets, error) {
 
 func (s *Service) describeSubnets() (*ec2.DescribeSubnetsOutput, error) {
 	input := &ec2.DescribeSubnetsInput{
-		Filters: []*ec2.Filter{
-			filter.EC2.SubnetStates(ec2.SubnetStatePending, ec2.SubnetStateAvailable),
+		Filters: []types.Filter{
+			filter.EC2.SubnetStates(types.SubnetStatePending, types.SubnetStateAvailable),
 		},
 	}
 
@@ -453,7 +455,7 @@ func (s *Service) describeSubnets() (*ec2.DescribeSubnetsOutput, error) {
 		input.Filters = append(input.Filters, filter.EC2.VPC(s.scope.VPC().ID))
 	}
 
-	out, err := s.EC2Client.DescribeSubnetsWithContext(context.TODO(), input)
+	out, err := s.EC2Client.DescribeSubnets(context.TODO(), input)
 	if err != nil {
 		record.Eventf(s.scope.InfraCluster(), "FailedDescribeSubnet", "Failed to describe subnets in vpc %q: %v", s.scope.VPC().ID, err)
 		return nil, errors.Wrapf(err, "failed to describe subnets in vpc %q", s.scope.VPC().ID)
@@ -498,9 +500,9 @@ func (s *Service) createSubnet(sn *infrav1.SubnetSpec) (*infrav1.SubnetSpec, err
 		VpcId:            aws.String(s.scope.VPC().ID),
 		CidrBlock:        aws.String(sn.CidrBlock),
 		AvailabilityZone: aws.String(sn.AvailabilityZone),
-		TagSpecifications: []*ec2.TagSpecification{
+		TagSpecifications: []types.TagSpecification{
 			tags.BuildParamsToTagSpecification(
-				ec2.ResourceTypeSubnet,
+				types.ResourceTypeSubnet,
 				s.getSubnetTagParams(false, services.TemporaryResourceID, sn.IsPublic, sn.AvailabilityZone, sn.Tags, sn.IsEdge()),
 			),
 		},
@@ -509,7 +511,7 @@ func (s *Service) createSubnet(sn *infrav1.SubnetSpec) (*infrav1.SubnetSpec, err
 		input.Ipv6CidrBlock = aws.String(sn.IPv6CidrBlock)
 		sn.IsIPv6 = true
 	}
-	out, err := s.EC2Client.CreateSubnetWithContext(context.TODO(), input)
+	out, err := s.EC2Client.CreateSubnet(context.TODO(), input)
 	if err != nil {
 		record.Warnf(s.scope.InfraCluster(), "FailedCreateSubnet", "Failed creating new managed Subnet %v", err)
 		return nil, errors.Wrap(err, "failed to create subnet")
@@ -518,8 +520,8 @@ func (s *Service) createSubnet(sn *infrav1.SubnetSpec) (*infrav1.SubnetSpec, err
 	record.Eventf(s.scope.InfraCluster(), "SuccessfulCreateSubnet", "Created new managed Subnet %q", *out.Subnet.SubnetId)
 	s.scope.Info("Created subnet", "id", *out.Subnet.SubnetId, "public", sn.IsPublic, "az", sn.AvailabilityZone, "cidr", sn.CidrBlock, "ipv6", sn.IsIPv6, "ipv6-cidr", sn.IPv6CidrBlock)
 
-	wReq := &ec2.DescribeSubnetsInput{SubnetIds: []*string{out.Subnet.SubnetId}}
-	if err := s.EC2Client.WaitUntilSubnetAvailableWithContext(context.TODO(), wReq); err != nil {
+	wReq := &ec2.DescribeSubnetsInput{SubnetIds: []string{aws.StringValue(out.Subnet.SubnetId)}}
+	if err := ec2.NewSubnetAvailableWaiter(s.EC2Client).Wait(context.TODO(), wReq, time.Minute*5); err != nil {
 		return nil, errors.Wrapf(err, "failed to wait for subnet %q", *out.Subnet.SubnetId)
 	}
 
@@ -529,9 +531,9 @@ func (s *Service) createSubnet(sn *infrav1.SubnetSpec) (*infrav1.SubnetSpec, err
 		// regardless of the subnet being public or not, ipv6 address needs to be assigned
 		// on creation. There is no such thing as private ipv6 address.
 		if err := wait.WaitForWithRetryable(wait.NewBackoff(), func() (bool, error) {
-			if _, err := s.EC2Client.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
+			if _, err := s.EC2Client.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
 				SubnetId: out.Subnet.SubnetId,
-				AssignIpv6AddressOnCreation: &ec2.AttributeBooleanValue{
+				AssignIpv6AddressOnCreation: &types.AttributeBooleanValue{
 					Value: aws.Bool(true),
 				},
 			}); err != nil {
@@ -552,9 +554,9 @@ func (s *Service) createSubnet(sn *infrav1.SubnetSpec) (*infrav1.SubnetSpec, err
 	// [2] https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_InstanceNetworkInterfaceSpecification.html
 	if sn.IsPublic && !sn.IsEdgeWavelength() {
 		if err := wait.WaitForWithRetryable(wait.NewBackoff(), func() (bool, error) {
-			if _, err := s.EC2Client.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
+			if _, err := s.EC2Client.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
 				SubnetId: out.Subnet.SubnetId,
-				MapPublicIpOnLaunch: &ec2.AttributeBooleanValue{
+				MapPublicIpOnLaunch: &types.AttributeBooleanValue{
 					Value: aws.Bool(true),
 				},
 			}); err != nil {
@@ -570,9 +572,9 @@ func (s *Service) createSubnet(sn *infrav1.SubnetSpec) (*infrav1.SubnetSpec, err
 
 	if s.scope.VPC().PrivateDNSHostnameTypeOnLaunch != nil {
 		if err := wait.WaitForWithRetryable(wait.NewBackoff(), func() (bool, error) {
-			if _, err := s.EC2Client.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
+			if _, err := s.EC2Client.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
 				SubnetId:                       out.Subnet.SubnetId,
-				PrivateDnsHostnameTypeOnLaunch: s.scope.VPC().PrivateDNSHostnameTypeOnLaunch,
+				PrivateDnsHostnameTypeOnLaunch: types.HostnameType(aws.StringValue(s.scope.VPC().PrivateDNSHostnameTypeOnLaunch)),
 			}); err != nil {
 				return false, err
 			}
@@ -594,7 +596,7 @@ func (s *Service) createSubnet(sn *infrav1.SubnetSpec) (*infrav1.SubnetSpec, err
 		Tags:             sn.Tags,
 	}
 	for _, set := range out.Subnet.Ipv6CidrBlockAssociationSet {
-		if *set.Ipv6CidrBlockState.State == ec2.SubnetCidrBlockStateCodeAssociated {
+		if set.Ipv6CidrBlockState.State == types.SubnetCidrBlockStateCodeAssociated {
 			subnet.IPv6CidrBlock = aws.StringValue(set.Ipv6CidrBlock)
 			subnet.IsIPv6 = true
 		}
@@ -611,7 +613,7 @@ func (s *Service) createSubnet(sn *infrav1.SubnetSpec) (*infrav1.SubnetSpec, err
 }
 
 func (s *Service) deleteSubnet(id string) error {
-	_, err := s.EC2Client.DeleteSubnetWithContext(context.TODO(), &ec2.DeleteSubnetInput{
+	_, err := s.EC2Client.DeleteSubnet(context.TODO(), &ec2.DeleteSubnetInput{
 		SubnetId: aws.String(id),
 	})
 	if err != nil {
diff --git a/pkg/cloud/services/network/vpc.go b/pkg/cloud/services/network/vpc.go
index 59a9481a6..a62083168 100644
--- a/pkg/cloud/services/network/vpc.go
+++ b/pkg/cloud/services/network/vpc.go
@@ -20,8 +20,9 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/pkg/errors"
 	kerrors "k8s.io/apimachinery/pkg/util/errors"
 	"k8s.io/apimachinery/pkg/util/sets"
@@ -34,6 +35,7 @@ import (
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/wait"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/tags"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/record"
+	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/utils"
 	clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
 	"sigs.k8s.io/cluster-api/util/conditions"
 )
@@ -155,24 +157,27 @@ func (s *Service) reconcileVPC() error {
 	return nil
 }
 
-func (s *Service) describeVPCEndpoints(filters ...*ec2.Filter) ([]*ec2.VpcEndpoint, error) {
+func (s *Service) describeVPCEndpoints(filters ...types.Filter) ([]types.VpcEndpoint, error) {
 	vpc := s.scope.VPC()
 	if vpc == nil || vpc.ID == "" {
 		return nil, errors.New("vpc is nil or vpc id is not set")
 	}
 	input := &ec2.DescribeVpcEndpointsInput{
-		Filters: append(filters, &ec2.Filter{
+		Filters: append(filters, types.Filter{
 			Name:   aws.String("vpc-id"),
-			Values: []*string{&vpc.ID},
+			Values: []string{vpc.ID},
 		}),
 	}
-	endpoints := []*ec2.VpcEndpoint{}
-	if err := s.EC2Client.DescribeVpcEndpointsPages(input, func(dveo *ec2.DescribeVpcEndpointsOutput, lastPage bool) bool {
-		endpoints = append(endpoints, dveo.VpcEndpoints...)
-		return true
-	}); err != nil {
-		return nil, errors.Wrap(err, "failed to describe vpc endpoints")
+	endpoints := []types.VpcEndpoint{}
+	paginator := ec2.NewDescribeVpcEndpointsPaginator(s.EC2Client, input)
+	for paginator.HasMorePages() {
+		page, err := paginator.NextPage(context.TODO())
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to describe vpc endpoints")
+		}
+		endpoints = append(endpoints, page.VpcEndpoints...)
 	}
+
 	return endpoints, nil
 }
 
@@ -207,10 +212,10 @@ func (s *Service) reconcileVPCEndpoints() error {
 
 	// Build the filters based on all the services we need to enable.
 	// A single filter with multiple values functions as an OR.
-	filters := []*ec2.Filter{
+	filters := []types.Filter{
 		{
 			Name:   aws.String("service-name"),
-			Values: aws.StringSlice(services.UnsortedList()),
+			Values: services.UnsortedList(),
 		},
 	}
 
@@ -222,10 +227,10 @@ func (s *Service) reconcileVPCEndpoints() error {
 
 	// Iterate over all services and create missing endpoints.
 	for _, service := range services.UnsortedList() {
-		var existing *ec2.VpcEndpoint
+		var existing *types.VpcEndpoint
 		for _, ep := range endpoints {
 			if aws.StringValue(ep.ServiceName) == service {
-				existing = ep
+				existing = &ep
 				break
 			}
 		}
@@ -233,7 +238,7 @@ func (s *Service) reconcileVPCEndpoints() error {
 		// Handle the case where the endpoint already exists.
 		// If the route tables are different, modify the endpoint.
 		if existing != nil {
-			existingRouteTables := sets.New(aws.StringValueSlice(existing.RouteTableIds)...)
+			existingRouteTables := sets.New(existing.RouteTableIds...)
 			existingRouteTables.Delete("")
 			additions := routeTables.Difference(existingRouteTables)
 			removals := existingRouteTables.Difference(routeTables)
@@ -242,12 +247,12 @@ func (s *Service) reconcileVPCEndpoints() error {
 					VpcEndpointId: existing.VpcEndpointId,
 				}
 				if additions.Len() > 0 {
-					modify.AddRouteTableIds = aws.StringSlice(additions.UnsortedList())
+					modify.AddRouteTableIds = additions.UnsortedList()
 				}
 				if removals.Len() > 0 {
-					modify.RemoveRouteTableIds = aws.StringSlice(removals.UnsortedList())
+					modify.RemoveRouteTableIds = removals.UnsortedList()
 				}
-				if _, err := s.EC2Client.ModifyVpcEndpoint(modify); err != nil {
+				if _, err := s.EC2Client.ModifyVpcEndpoint(context.TODO(), modify); err != nil {
 					return errors.Wrapf(err, "failed to modify vpc endpoint for service %q", service)
 				}
 			}
@@ -255,12 +260,12 @@ func (s *Service) reconcileVPCEndpoints() error {
 		}
 
 		// Create the endpoint.
-		if _, err := s.EC2Client.CreateVpcEndpoint(&ec2.CreateVpcEndpointInput{
+		if _, err := s.EC2Client.CreateVpcEndpoint(context.TODO(), &ec2.CreateVpcEndpointInput{
 			VpcId:         aws.String(s.scope.VPC().ID),
 			ServiceName:   aws.String(service),
-			RouteTableIds: aws.StringSlice(routeTables.UnsortedList()),
-			TagSpecifications: []*ec2.TagSpecification{
-				tags.BuildParamsToTagSpecification(ec2.ResourceTypeVpcEndpoint, s.getVPCEndpointTagParams()),
+			RouteTableIds: routeTables.UnsortedList(),
+			TagSpecifications: []types.TagSpecification{
+				tags.BuildParamsToTagSpecification(types.ResourceTypeVpcEndpoint, s.getVPCEndpointTagParams()),
 			},
 		}); err != nil {
 			return errors.Wrapf(err, "failed to create vpc endpoint for service %q", service)
@@ -283,12 +288,12 @@ func (s *Service) deleteVPCEndpoints() error {
 	}
 
 	// Gather all endpoint IDs.
-	ids := []*string{}
+	ids := []string{}
 	for _, ep := range endpoints {
 		if ep.VpcEndpointId == nil || *ep.VpcEndpointId == "" {
 			continue
 		}
-		ids = append(ids, ep.VpcEndpointId)
+		ids = append(ids, *ep.VpcEndpointId)
 	}
 
 	if len(ids) == 0 {
@@ -296,7 +301,7 @@ func (s *Service) deleteVPCEndpoints() error {
 	}
 
 	// Iterate over all services and delete endpoints.
-	if _, err := s.EC2Client.DeleteVpcEndpoints(&ec2.DeleteVpcEndpointsInput{
+	if _, err := s.EC2Client.DeleteVpcEndpoints(context.TODO(), &ec2.DeleteVpcEndpointsInput{
 		VpcEndpointIds: ids,
 	}); err != nil {
 		return errors.Wrapf(err, "failed to delete vpc endpoints %+v", ids)
@@ -313,9 +318,9 @@ func (s *Service) ensureManagedVPCAttributes(vpc *infrav1.VPCSpec) error {
 	// Cannot get or set both attributes at the same time.
 	descAttrInput := &ec2.DescribeVpcAttributeInput{
 		VpcId:     aws.String(vpc.ID),
-		Attribute: aws.String("enableDnsHostnames"),
+		Attribute: types.VpcAttributeNameEnableDnsHostnames,
 	}
-	vpcAttr, err := s.EC2Client.DescribeVpcAttributeWithContext(context.TODO(), descAttrInput)
+	vpcAttr, err := s.EC2Client.DescribeVpcAttribute(context.TODO(), descAttrInput)
 	if err != nil {
 		// If the returned error is a 'NotFound' error it should trigger retry
 		if code, ok := awserrors.Code(errors.Cause(err)); ok && code == awserrors.VPCNotFound {
@@ -325,9 +330,9 @@ func (s *Service) ensureManagedVPCAttributes(vpc *infrav1.VPCSpec) error {
 	} else if !aws.BoolValue(vpcAttr.EnableDnsHostnames.Value) {
 		attrInput := &ec2.ModifyVpcAttributeInput{
 			VpcId:              aws.String(vpc.ID),
-			EnableDnsHostnames: &ec2.AttributeBooleanValue{Value: aws.Bool(true)},
+			EnableDnsHostnames: &types.AttributeBooleanValue{Value: aws.Bool(true)},
 		}
-		if _, err := s.EC2Client.ModifyVpcAttributeWithContext(context.TODO(), attrInput); err != nil {
+		if _, err := s.EC2Client.ModifyVpcAttribute(context.TODO(), attrInput); err != nil {
 			errs = append(errs, errors.Wrap(err, "failed to set enableDnsHostnames vpc attribute"))
 		} else {
 			updated = true
@@ -336,9 +341,9 @@ func (s *Service) ensureManagedVPCAttributes(vpc *infrav1.VPCSpec) error {
 
 	descAttrInput = &ec2.DescribeVpcAttributeInput{
 		VpcId:     aws.String(vpc.ID),
-		Attribute: aws.String("enableDnsSupport"),
+		Attribute: types.VpcAttributeNameEnableDnsSupport,
 	}
-	vpcAttr, err = s.EC2Client.DescribeVpcAttributeWithContext(context.TODO(), descAttrInput)
+	vpcAttr, err = s.EC2Client.DescribeVpcAttribute(context.TODO(), descAttrInput)
 	if err != nil {
 		// If the returned error is a 'NotFound' error it should trigger retry
 		if code, ok := awserrors.Code(errors.Cause(err)); ok && code == awserrors.VPCNotFound {
@@ -348,9 +353,9 @@ func (s *Service) ensureManagedVPCAttributes(vpc *infrav1.VPCSpec) error {
 	} else if !aws.BoolValue(vpcAttr.EnableDnsSupport.Value) {
 		attrInput := &ec2.ModifyVpcAttributeInput{
 			VpcId:            aws.String(vpc.ID),
-			EnableDnsSupport: &ec2.AttributeBooleanValue{Value: aws.Bool(true)},
+			EnableDnsSupport: &types.AttributeBooleanValue{Value: aws.Bool(true)},
 		}
-		if _, err := s.EC2Client.ModifyVpcAttributeWithContext(context.TODO(), attrInput); err != nil {
+		if _, err := s.EC2Client.ModifyVpcAttribute(context.TODO(), attrInput); err != nil {
 			errs = append(errs, errors.Wrap(err, "failed to set enableDnsSupport vpc attribute"))
 		} else {
 			updated = true
@@ -380,7 +385,7 @@ func (s *Service) getIPAMPoolID() (*string, error) {
 		input.Filters = append(input.Filters, filter.EC2.Name(s.scope.VPC().IPAMPool.Name))
 	}
 
-	output, err := s.EC2Client.DescribeIpamPools(input)
+	output, err := s.EC2Client.DescribeIpamPools(context.TODO(), input)
 	if err != nil {
 		record.Warnf(s.scope.InfraCluster(), "FailedCreateVPC", "Failed to describe IPAM Pools: %v", err)
 		return nil, errors.Wrap(err, "failed to describe IPAM Pools")
@@ -400,8 +405,8 @@ func (s *Service) getIPAMPoolID() (*string, error) {
 
 func (s *Service) createVPC() (*infrav1.VPCSpec, error) {
 	input := &ec2.CreateVpcInput{
-		TagSpecifications: []*ec2.TagSpecification{
-			tags.BuildParamsToTagSpecification(ec2.ResourceTypeVpc, s.getVPCTagParams(services.TemporaryResourceID)),
+		TagSpecifications: []types.TagSpecification{
+			tags.BuildParamsToTagSpecification(types.ResourceTypeVpc, s.getVPCTagParams(services.TemporaryResourceID)),
 		},
 	}
 
@@ -423,7 +428,7 @@ func (s *Service) createVPC() (*infrav1.VPCSpec, error) {
 			}
 
 			input.Ipv6IpamPoolId = ipamPoolID
-			input.Ipv6NetmaskLength = aws.Int64(s.scope.VPC().IPv6.IPAMPool.NetmaskLength)
+			input.Ipv6NetmaskLength = utils.ToInt32Pointer(&s.scope.VPC().IPv6.IPAMPool.NetmaskLength)
 		default:
 			input.AmazonProvidedIpv6CidrBlock = aws.Bool(s.scope.VPC().IsIPv6Enabled())
 		}
@@ -441,7 +446,7 @@ func (s *Service) createVPC() (*infrav1.VPCSpec, error) {
 		}
 
 		input.Ipv4IpamPoolId = ipamPoolID
-		input.Ipv4NetmaskLength = aws.Int64(s.scope.VPC().IPAMPool.NetmaskLength)
+		input.Ipv4NetmaskLength = utils.ToInt32Pointer(&s.scope.VPC().IPAMPool.NetmaskLength)
 	} else {
 		if s.scope.VPC().CidrBlock == "" {
 			s.scope.VPC().CidrBlock = defaultVPCCidr
@@ -450,7 +455,7 @@ func (s *Service) createVPC() (*infrav1.VPCSpec, error) {
 		input.CidrBlock = &s.scope.VPC().CidrBlock
 	}
 
-	out, err := s.EC2Client.CreateVpcWithContext(context.TODO(), input)
+	out, err := s.EC2Client.CreateVpc(context.TODO(), input)
 	if err != nil {
 		record.Warnf(s.scope.InfraCluster(), "FailedCreateVPC", "Failed to create new managed VPC: %v", err)
 		return nil, errors.Wrap(err, "failed to create vpc")
@@ -481,8 +486,8 @@ func (s *Service) createVPC() (*infrav1.VPCSpec, error) {
 	}
 
 	// We have to describe the VPC again because the `create` output will **NOT** contain the associated IPv6 address.
-	vpc, err := s.EC2Client.DescribeVpcsWithContext(context.TODO(), &ec2.DescribeVpcsInput{
-		VpcIds: aws.StringSlice([]string{aws.StringValue(out.Vpc.VpcId)}),
+	vpc, err := s.EC2Client.DescribeVpcs(context.TODO(), &ec2.DescribeVpcsInput{
+		VpcIds: []string{aws.StringValue(out.Vpc.VpcId)},
 	})
 	if err != nil {
 		record.Warnf(s.scope.InfraCluster(), "DescribeVpcs", "Failed to describe the new ipv6 vpc: %v", err)
@@ -493,7 +498,7 @@ func (s *Service) createVPC() (*infrav1.VPCSpec, error) {
 		return nil, errors.New("failed to find new ipv6 vpc; returned list was empty")
 	}
 	for _, set := range vpc.Vpcs[0].Ipv6CidrBlockAssociationSet {
-		if *set.Ipv6CidrBlockState.State == ec2.SubnetCidrBlockStateCodeAssociated {
+		if set.Ipv6CidrBlockState.State == types.VpcCidrBlockStateCodeAssociated {
 			return &infrav1.VPCSpec{
 				IPv6: &infrav1.IPv6{
 					CidrBlock: aws.StringValue(set.Ipv6CidrBlock),
@@ -521,7 +526,7 @@ func (s *Service) deleteVPC() error {
 		VpcId: aws.String(vpc.ID),
 	}
 
-	if _, err := s.EC2Client.DeleteVpcWithContext(context.TODO(), input); err != nil {
+	if _, err := s.EC2Client.DeleteVpc(context.TODO(), input); err != nil {
 		// Ignore if it's already deleted
 		if code, ok := awserrors.Code(err); ok && code == awserrors.VPCNotFound {
 			s.scope.Trace("Skipping VPC deletion, VPC not found")
@@ -549,14 +554,14 @@ func (s *Service) describeVPCByID() (*infrav1.VPCSpec, error) {
 	}
 
 	input := &ec2.DescribeVpcsInput{
-		Filters: []*ec2.Filter{
-			filter.EC2.VPCStates(ec2.VpcStatePending, ec2.VpcStateAvailable),
+		Filters: []types.Filter{
+			filter.EC2.VPCStates(types.VpcStatePending, types.VpcStateAvailable),
 		},
 	}
 
-	input.VpcIds = []*string{aws.String(s.scope.VPC().ID)}
+	input.VpcIds = []string{s.scope.VPC().ID}
 
-	out, err := s.EC2Client.DescribeVpcsWithContext(context.TODO(), input)
+	out, err := s.EC2Client.DescribeVpcs(context.TODO(), input)
 	if err != nil {
 		if awserrors.IsNotFound(err) {
 			return nil, err
@@ -568,11 +573,11 @@ func (s *Service) describeVPCByID() (*infrav1.VPCSpec, error) {
 	if len(out.Vpcs) == 0 {
 		return nil, awserrors.NewNotFound(fmt.Sprintf("could not find vpc %q", s.scope.VPC().ID))
 	} else if len(out.Vpcs) > 1 {
-		return nil, awserrors.NewConflict(fmt.Sprintf("found %v VPCs with matching tags for %v. Only one VPC per cluster name is supported. Ensure duplicate VPCs are deleted for this AWS account and there are no conflicting instances of Cluster API Provider AWS. filtered VPCs: %v", len(out.Vpcs), s.scope.Name(), out.GoString()))
+		return nil, awserrors.NewConflict(fmt.Sprintf("found %v VPCs with matching tags for %v. Only one VPC per cluster name is supported. Ensure duplicate VPCs are deleted for this AWS account and there are no conflicting instances of Cluster API Provider AWS. filtered VPCs: %v", len(out.Vpcs), s.scope.Name(), out))
 	}
 
-	switch *out.Vpcs[0].State {
-	case ec2.VpcStateAvailable, ec2.VpcStatePending:
+	switch out.Vpcs[0].State {
+	case types.VpcStateAvailable, types.VpcStatePending:
 	default:
 		return nil, awserrors.NewNotFound("could not find available or pending vpc")
 	}
@@ -583,7 +588,7 @@ func (s *Service) describeVPCByID() (*infrav1.VPCSpec, error) {
 		Tags:      converters.TagsToMap(out.Vpcs[0].Tags),
 	}
 	for _, set := range out.Vpcs[0].Ipv6CidrBlockAssociationSet {
-		if *set.Ipv6CidrBlockState.State == ec2.SubnetCidrBlockStateCodeAssociated {
+		if set.Ipv6CidrBlockState.State == types.VpcCidrBlockStateCodeAssociated {
 			vpc.IPv6 = &infrav1.IPv6{
 				CidrBlock: aws.StringValue(set.Ipv6CidrBlock),
 				PoolID:    aws.StringValue(set.Ipv6Pool),
@@ -600,15 +605,15 @@ func (s *Service) describeVPCByName() (*infrav1.VPCSpec, error) {
 	vpcName := *s.getVPCTagParams(services.TemporaryResourceID).Name
 
 	input := &ec2.DescribeVpcsInput{
-		Filters: []*ec2.Filter{
+		Filters: []types.Filter{
 			{
 				Name:   aws.String("tag:Name"),
-				Values: aws.StringSlice([]string{vpcName}),
+				Values: []string{vpcName},
 			},
 		},
 	}
 
-	out, err := s.EC2Client.DescribeVpcsWithContext(context.TODO(), input)
+	out, err := s.EC2Client.DescribeVpcs(context.TODO(), input)
 	if (err != nil && awserrors.IsNotFound(err)) || (out != nil && len(out.Vpcs) == 0) {
 		return nil, awserrors.NewNotFound(fmt.Sprintf("could not find VPC by name %q", vpcName))
 	}
@@ -616,11 +621,11 @@ func (s *Service) describeVPCByName() (*infrav1.VPCSpec, error) {
 		return nil, errors.Wrapf(err, "failed to query ec2 for VPCs by name %q", vpcName)
 	}
 	if len(out.Vpcs) > 1 {
-		return nil, awserrors.NewConflict(fmt.Sprintf("found %v VPCs with name %q. Only one VPC per cluster name is supported. Ensure duplicate VPCs are deleted for this AWS account and there are no conflicting instances of Cluster API Provider AWS. Filtered VPCs: %v", len(out.Vpcs), vpcName, out.GoString()))
+		return nil, awserrors.NewConflict(fmt.Sprintf("found %v VPCs with name %q. Only one VPC per cluster name is supported. Ensure duplicate VPCs are deleted for this AWS account and there are no conflicting instances of Cluster API Provider AWS. Filtered VPCs: %v", len(out.Vpcs), vpcName, out))
 	}
 
-	switch *out.Vpcs[0].State {
-	case ec2.VpcStateAvailable, ec2.VpcStatePending:
+	switch out.Vpcs[0].State {
+	case types.VpcStateAvailable, types.VpcStatePending:
 	default:
 		return nil, awserrors.NewNotFound(fmt.Sprintf("could not find available or pending VPC by name %q", vpcName))
 	}
@@ -631,7 +636,7 @@ func (s *Service) describeVPCByName() (*infrav1.VPCSpec, error) {
 		Tags:      converters.TagsToMap(out.Vpcs[0].Tags),
 	}
 	for _, set := range out.Vpcs[0].Ipv6CidrBlockAssociationSet {
-		if *set.Ipv6CidrBlockState.State == ec2.SubnetCidrBlockStateCodeAssociated {
+		if set.Ipv6CidrBlockState.State == types.VpcCidrBlockStateCodeAssociated {
 			vpc.IPv6 = &infrav1.IPv6{
 				CidrBlock: aws.StringValue(set.Ipv6CidrBlock),
 				PoolID:    aws.StringValue(set.Ipv6Pool),
diff --git a/pkg/cloud/services/securitygroup/securitygroups.go b/pkg/cloud/services/securitygroup/securitygroups.go
index 9f14688c5..9de501f7c 100644
--- a/pkg/cloud/services/securitygroup/securitygroups.go
+++ b/pkg/cloud/services/securitygroup/securitygroups.go
@@ -21,8 +21,9 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/pkg/errors"
 	kerrors "k8s.io/apimachinery/pkg/util/errors"
 	"k8s.io/apimachinery/pkg/util/sets"
@@ -36,6 +37,7 @@ import (
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/wait"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/tags"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/record"
+	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/utils"
 	clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
 	"sigs.k8s.io/cluster-api/util/conditions"
 )
@@ -71,7 +73,7 @@ func (s *Service) ReconcileSecurityGroups() error {
 
 	// Security group overrides are mapped by Role rather than their security group name
 	// They are copied into the main 'sgs' list by their group name later
-	var securityGroupOverrides map[infrav1.SecurityGroupRole]*ec2.SecurityGroup
+	var securityGroupOverrides map[infrav1.SecurityGroupRole]types.SecurityGroup
 	securityGroupOverrides, err = s.describeSecurityGroupOverridesByID()
 	if err != nil {
 		return err
@@ -109,7 +111,7 @@ func (s *Service) ReconcileSecurityGroups() error {
 		existing, ok := sgs[*sg.GroupName]
 
 		if !ok {
-			if err := s.createSecurityGroup(role, sg); err != nil {
+			if err := s.createSecurityGroup(role, &sg); err != nil {
 				return err
 			}
 
@@ -249,7 +251,7 @@ func (s *Service) securityGroupIsAnOverride(securityGroupID string) bool {
 	return false
 }
 
-func (s *Service) describeSecurityGroupOverridesByID() (map[infrav1.SecurityGroupRole]*ec2.SecurityGroup, error) {
+func (s *Service) describeSecurityGroupOverridesByID() (map[infrav1.SecurityGroupRole]types.SecurityGroup, error) {
 	securityGroupIDs := map[infrav1.SecurityGroupRole]*string{}
 	input := &ec2.DescribeSecurityGroupsInput{}
 
@@ -265,17 +267,17 @@ func (s *Service) describeSecurityGroupOverridesByID() (map[infrav1.SecurityGrou
 			securityGroupID, ok := s.scope.SecurityGroupOverrides()[role]
 			if ok {
 				securityGroupIDs[role] = aws.String(securityGroupID)
-				input.GroupIds = append(input.GroupIds, aws.String(securityGroupID))
+				input.GroupIds = append(input.GroupIds, securityGroupID)
 			}
 		}
 	}
 
-	out, err := s.EC2Client.DescribeSecurityGroupsWithContext(context.TODO(), input)
+	out, err := s.EC2Client.DescribeSecurityGroups(context.TODO(), input)
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed to describe security groups in vpc %q", s.scope.VPC().ID)
 	}
 
-	res := make(map[infrav1.SecurityGroupRole]*ec2.SecurityGroup, len(out.SecurityGroups))
+	res := make(map[infrav1.SecurityGroupRole]types.SecurityGroup, len(out.SecurityGroups))
 	for _, role := range s.roles {
 		for _, ec2sg := range out.SecurityGroups {
 			if securityGroupIDs[role] == nil {
@@ -293,7 +295,7 @@ func (s *Service) describeSecurityGroupOverridesByID() (map[infrav1.SecurityGrou
 	return res, nil
 }
 
-func (s *Service) ec2SecurityGroupToSecurityGroup(ec2SecurityGroup *ec2.SecurityGroup) infrav1.SecurityGroup {
+func (s *Service) ec2SecurityGroupToSecurityGroup(ec2SecurityGroup types.SecurityGroup) infrav1.SecurityGroup {
 	sg := makeInfraSecurityGroup(ec2SecurityGroup)
 
 	for _, ec2rule := range ec2SecurityGroup.IpPermissions {
@@ -354,7 +356,7 @@ func (s *Service) deleteSecurityGroup(sg *infrav1.SecurityGroup, typ string) err
 		GroupId: aws.String(sg.ID),
 	}
 
-	if _, err := s.EC2Client.DeleteSecurityGroupWithContext(context.TODO(), input); awserrors.IsIgnorableSecurityGroupError(err) != nil { //nolint:gocritic
+	if _, err := s.EC2Client.DeleteSecurityGroup(context.TODO(), input); awserrors.IsIgnorableSecurityGroupError(err) != nil { //nolint:gocritic
 		record.Warnf(s.scope.InfraCluster(), "FailedDeleteSecurityGroup", "Failed to delete %s SecurityGroup %q with name %q: %v", typ, sg.ID, sg.Name, err)
 		return errors.Wrapf(err, "failed to delete security group %q with name %q", sg.ID, sg.Name)
 	}
@@ -367,7 +369,7 @@ func (s *Service) deleteSecurityGroup(sg *infrav1.SecurityGroup, typ string) err
 
 func (s *Service) describeClusterOwnedSecurityGroups() ([]infrav1.SecurityGroup, error) {
 	input := &ec2.DescribeSecurityGroupsInput{
-		Filters: []*ec2.Filter{
+		Filters: []types.Filter{
 			filter.EC2.VPC(s.scope.VPC().ID),
 			filter.EC2.ClusterOwned(s.scope.Name()),
 		},
@@ -375,29 +377,30 @@ func (s *Service) describeClusterOwnedSecurityGroups() ([]infrav1.SecurityGroup,
 
 	groups := []infrav1.SecurityGroup{}
 
-	err := s.EC2Client.DescribeSecurityGroupsPagesWithContext(context.TODO(), input, func(out *ec2.DescribeSecurityGroupsOutput, last bool) bool {
+	paginator := ec2.NewDescribeSecurityGroupsPaginator(s.EC2Client, input)
+	for paginator.HasMorePages() {
+		out, err := paginator.NextPage(context.TODO())
+		if err != nil {
+			return nil, errors.Wrapf(err, "failed to describe cluster-owned security groups in vpc %q", s.scope.VPC().ID)
+		}
+
 		for _, group := range out.SecurityGroups {
-			if group != nil {
-				groups = append(groups, makeInfraSecurityGroup(group))
-			}
+			groups = append(groups, makeInfraSecurityGroup(group))
 		}
-		return true
-	})
-	if err != nil {
-		return nil, errors.Wrapf(err, "failed to describe cluster-owned security groups in vpc %q", s.scope.VPC().ID)
 	}
+
 	return groups, nil
 }
 
 func (s *Service) describeSecurityGroupsByName() (map[string]infrav1.SecurityGroup, error) {
 	input := &ec2.DescribeSecurityGroupsInput{
-		Filters: []*ec2.Filter{
+		Filters: []types.Filter{
 			filter.EC2.VPC(s.scope.VPC().ID),
 			filter.EC2.Cluster(s.scope.Name()),
 		},
 	}
 
-	out, err := s.EC2Client.DescribeSecurityGroupsWithContext(context.TODO(), input)
+	out, err := s.EC2Client.DescribeSecurityGroups(context.TODO(), input)
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed to describe security groups in vpc %q", s.scope.VPC().ID)
 	}
@@ -419,8 +422,8 @@ func (s *Service) revokeIngressAndEgressRulesFromVPCDefaultSecurityGroup() error
 		return nil
 	}
 
-	securityGroups, err := s.EC2Client.DescribeSecurityGroupsWithContext(context.TODO(), &ec2.DescribeSecurityGroupsInput{
-		Filters: []*ec2.Filter{
+	securityGroups, err := s.EC2Client.DescribeSecurityGroups(context.TODO(), &ec2.DescribeSecurityGroupsInput{
+		Filters: []types.Filter{
 			filter.EC2.VPC(s.scope.VPC().ID),
 			filter.EC2.SecurityGroupName("default"),
 		},
@@ -460,7 +463,7 @@ func (s *Service) revokeIngressAndEgressRulesFromVPCDefaultSecurityGroup() error
 	return nil
 }
 
-func makeInfraSecurityGroup(ec2sg *ec2.SecurityGroup) infrav1.SecurityGroup {
+func makeInfraSecurityGroup(ec2sg types.SecurityGroup) infrav1.SecurityGroup {
 	return infrav1.SecurityGroup{
 		ID:   *ec2sg.GroupId,
 		Name: *ec2sg.GroupName,
@@ -468,23 +471,23 @@ func makeInfraSecurityGroup(ec2sg *ec2.SecurityGroup) infrav1.SecurityGroup {
 	}
 }
 
-func (s *Service) createSecurityGroup(role infrav1.SecurityGroupRole, input *ec2.SecurityGroup) error {
-	sgTags := s.getSecurityGroupTagParams(aws.StringValue(input.GroupName), services.TemporaryResourceID, role)
-	out, err := s.EC2Client.CreateSecurityGroupWithContext(context.TODO(), &ec2.CreateSecurityGroupInput{
+func (s *Service) createSecurityGroup(role infrav1.SecurityGroupRole, input *types.SecurityGroup) error {
+	sgTags := s.getSecurityGroupTagParams(aws.ToString(input.GroupName), services.TemporaryResourceID, role)
+	out, err := s.EC2Client.CreateSecurityGroup(context.TODO(), &ec2.CreateSecurityGroupInput{
 		VpcId:       input.VpcId,
 		GroupName:   input.GroupName,
 		Description: aws.String(fmt.Sprintf("Kubernetes cluster %s: %s", s.scope.Name(), role)),
-		TagSpecifications: []*ec2.TagSpecification{
-			tags.BuildParamsToTagSpecification(ec2.ResourceTypeSecurityGroup, sgTags),
+		TagSpecifications: []types.TagSpecification{
+			tags.BuildParamsToTagSpecification(types.ResourceTypeSecurityGroup, sgTags),
 		},
 	})
 	if err != nil {
 		record.Warnf(s.scope.InfraCluster(), "FailedCreateSecurityGroup", "Failed to create managed SecurityGroup for Role %q: %v", role, err)
-		return errors.Wrapf(err, "failed to create security group %q in vpc %q", role, aws.StringValue(input.VpcId))
+		return errors.Wrapf(err, "failed to create security group %q in vpc %q", role, aws.ToString(input.VpcId))
 	}
 
-	record.Eventf(s.scope.InfraCluster(), "SuccessfulCreateSecurityGroup", "Created managed SecurityGroup %q for Role %q", aws.StringValue(out.GroupId), role)
-	s.scope.Info("Created security group for role", "security-group", aws.StringValue(out.GroupId), "role", role)
+	record.Eventf(s.scope.InfraCluster(), "SuccessfulCreateSecurityGroup", "Created managed SecurityGroup %q for Role %q", aws.ToString(out.GroupId), role)
+	s.scope.Info("Created security group for role", "security-group", aws.ToString(out.GroupId), "role", role)
 
 	// Set the group id.
 	input.GroupId = out.GroupId
@@ -496,9 +499,9 @@ func (s *Service) authorizeSecurityGroupIngressRules(id string, rules infrav1.In
 	input := &ec2.AuthorizeSecurityGroupIngressInput{GroupId: aws.String(id)}
 	for i := range rules {
 		rule := rules[i]
-		input.IpPermissions = append(input.IpPermissions, ingressRuleToSDKType(s.scope, &rule))
+		input.IpPermissions = append(input.IpPermissions, *ingressRuleToSDKType(s.scope, &rule))
 	}
-	if _, err := s.EC2Client.AuthorizeSecurityGroupIngressWithContext(context.TODO(), input); err != nil {
+	if _, err := s.EC2Client.AuthorizeSecurityGroupIngress(context.TODO(), input); err != nil {
 		record.Warnf(s.scope.InfraCluster(), "FailedAuthorizeSecurityGroupIngressRules", "Failed to authorize security group ingress rules %v for SecurityGroup %q: %v", rules, id, err)
 		return errors.Wrapf(err, "failed to authorize security group %q ingress rules: %v", id, rules)
 	}
@@ -511,10 +514,10 @@ func (s *Service) revokeSecurityGroupIngressRules(id string, rules infrav1.Ingre
 	input := &ec2.RevokeSecurityGroupIngressInput{GroupId: aws.String(id)}
 	for i := range rules {
 		rule := rules[i]
-		input.IpPermissions = append(input.IpPermissions, ingressRuleToSDKType(s.scope, &rule))
+		input.IpPermissions = append(input.IpPermissions, *ingressRuleToSDKType(s.scope, &rule))
 	}
 
-	if _, err := s.EC2Client.RevokeSecurityGroupIngressWithContext(context.TODO(), input); err != nil && !awserrors.IsPermissionNotFoundError(errors.Cause(err)) {
+	if _, err := s.EC2Client.RevokeSecurityGroupIngress(context.TODO(), input); err != nil && !awserrors.IsPermissionNotFoundError(errors.Cause(err)) {
 		record.Warnf(s.scope.InfraCluster(), "FailedRevokeSecurityGroupIngressRules", "Failed to revoke security group ingress rules %v for SecurityGroup %q: %v", rules, id, err)
 		return errors.Wrapf(err, "failed to revoke security group %q ingress rules: %v", id, rules)
 	}
@@ -527,10 +530,10 @@ func (s *Service) revokeSecurityGroupEgressRules(id string, rules infrav1.Ingres
 	input := &ec2.RevokeSecurityGroupEgressInput{GroupId: aws.String(id)}
 	for i := range rules {
 		rule := rules[i]
-		input.IpPermissions = append(input.IpPermissions, ingressRuleToSDKType(s.scope, &rule))
+		input.IpPermissions = append(input.IpPermissions, *ingressRuleToSDKType(s.scope, &rule))
 	}
 
-	if _, err := s.EC2Client.RevokeSecurityGroupEgressWithContext(context.TODO(), input); err != nil && !awserrors.IsPermissionNotFoundError(errors.Cause(err)) {
+	if _, err := s.EC2Client.RevokeSecurityGroupEgress(context.TODO(), input); err != nil && !awserrors.IsPermissionNotFoundError(errors.Cause(err)) {
 		record.Warnf(s.scope.InfraCluster(), "FailedRevokeSecurityGroupEgressRules", "Failed to revoke security group egress rules %v for SecurityGroup %q: %v", rules, id, err)
 		return errors.Wrapf(err, "failed to revoke security group %q egress rules: %v", id, rules)
 	}
@@ -540,9 +543,9 @@ func (s *Service) revokeSecurityGroupEgressRules(id string, rules infrav1.Ingres
 }
 
 func (s *Service) revokeAllSecurityGroupIngressRules(id string) error {
-	describeInput := &ec2.DescribeSecurityGroupsInput{GroupIds: []*string{aws.String(id)}}
+	describeInput := &ec2.DescribeSecurityGroupsInput{GroupIds: []string{id}}
 
-	securityGroups, err := s.EC2Client.DescribeSecurityGroupsWithContext(context.TODO(), describeInput)
+	securityGroups, err := s.EC2Client.DescribeSecurityGroups(context.TODO(), describeInput)
 	if err != nil {
 		return err
 	}
@@ -553,7 +556,7 @@ func (s *Service) revokeAllSecurityGroupIngressRules(id string) error {
 				GroupId:       aws.String(id),
 				IpPermissions: sg.IpPermissions,
 			}
-			if _, err := s.EC2Client.RevokeSecurityGroupIngressWithContext(context.TODO(), revokeInput); err != nil {
+			if _, err := s.EC2Client.RevokeSecurityGroupIngress(context.TODO(), revokeInput); err != nil {
 				record.Warnf(s.scope.InfraCluster(), "FailedRevokeSecurityGroupIngressRules", "Failed to revoke all security group ingress rules for SecurityGroup %q: %v", *sg.GroupId, err)
 				return err
 			}
@@ -765,10 +768,10 @@ func (s *Service) getSecurityGroupName(clusterName string, role infrav1.Security
 	return fmt.Sprintf("%s-%v", groupPrefix, role)
 }
 
-func (s *Service) getDefaultSecurityGroup(role infrav1.SecurityGroupRole) *ec2.SecurityGroup {
+func (s *Service) getDefaultSecurityGroup(role infrav1.SecurityGroupRole) types.SecurityGroup {
 	name := s.getSecurityGroupName(s.scope.Name(), role)
 
-	return &ec2.SecurityGroup{
+	return types.SecurityGroup{
 		GroupName: aws.String(name),
 		VpcId:     aws.String(s.scope.VPC().ID),
 		Tags:      converters.MapToTags(infrav1.Build(s.getSecurityGroupTagParams(name, "", role))),
@@ -806,7 +809,7 @@ func (s *Service) isEKSOwned(sg infrav1.SecurityGroup) bool {
 	return ok
 }
 
-func ingressRuleToSDKType(scope scope.SGScope, i *infrav1.IngressRule) (res *ec2.IpPermission) {
+func ingressRuleToSDKType(scope scope.SGScope, i *infrav1.IngressRule) (res *types.IpPermission) {
 	// AWS seems to ignore the From/To port when set on protocols where it doesn't apply, but
 	// we avoid serializing it out for clarity's sake.
 	// See: https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_IpPermission.html
@@ -815,15 +818,15 @@ func ingressRuleToSDKType(scope scope.SGScope, i *infrav1.IngressRule) (res *ec2
 		infrav1.SecurityGroupProtocolUDP,
 		infrav1.SecurityGroupProtocolICMP,
 		infrav1.SecurityGroupProtocolICMPv6:
-		res = &ec2.IpPermission{
+		res = &types.IpPermission{
 			IpProtocol: aws.String(string(i.Protocol)),
-			FromPort:   aws.Int64(i.FromPort),
-			ToPort:     aws.Int64(i.ToPort),
+			FromPort:   utils.ToInt32Pointer(&i.FromPort),
+			ToPort:     utils.ToInt32Pointer(&i.ToPort),
 		}
 	case infrav1.SecurityGroupProtocolIPinIP,
 		infrav1.SecurityGroupProtocolESP,
 		infrav1.SecurityGroupProtocolAll:
-		res = &ec2.IpPermission{
+		res = &types.IpPermission{
 			IpProtocol: aws.String(string(i.Protocol)),
 		}
 	default:
@@ -832,7 +835,7 @@ func ingressRuleToSDKType(scope scope.SGScope, i *infrav1.IngressRule) (res *ec2
 	}
 
 	for _, cidr := range i.CidrBlocks {
-		ipRange := &ec2.IpRange{
+		ipRange := types.IpRange{
 			CidrIp: aws.String(cidr),
 		}
 
@@ -844,7 +847,7 @@ func ingressRuleToSDKType(scope scope.SGScope, i *infrav1.IngressRule) (res *ec2
 	}
 
 	for _, cidr := range i.IPv6CidrBlocks {
-		ipV6Range := &ec2.Ipv6Range{
+		ipV6Range := types.Ipv6Range{
 			CidrIpv6: aws.String(cidr),
 		}
 
@@ -856,7 +859,7 @@ func ingressRuleToSDKType(scope scope.SGScope, i *infrav1.IngressRule) (res *ec2
 	}
 
 	for _, groupID := range i.SourceSecurityGroupIDs {
-		userIDGroupPair := &ec2.UserIdGroupPair{
+		userIDGroupPair := types.UserIdGroupPair{
 			GroupId: aws.String(groupID),
 		}
 
@@ -870,7 +873,7 @@ func ingressRuleToSDKType(scope scope.SGScope, i *infrav1.IngressRule) (res *ec2
 	return res
 }
 
-func ingressRulesFromSDKType(v *ec2.IpPermission) (res infrav1.IngressRules) {
+func ingressRulesFromSDKType(v types.IpPermission) (res infrav1.IngressRules) {
 	for _, ec2range := range v.IpRanges {
 		rule := ingressRuleFromSDKProtocol(v)
 		if ec2range.Description != nil && *ec2range.Description != "" {
@@ -908,7 +911,7 @@ func ingressRulesFromSDKType(v *ec2.IpPermission) (res infrav1.IngressRules) {
 	return res
 }
 
-func ingressRuleFromSDKProtocol(v *ec2.IpPermission) infrav1.IngressRule {
+func ingressRuleFromSDKProtocol(v types.IpPermission) infrav1.IngressRule {
 	// Ports are only well-defined for TCP and UDP protocols, but EC2 overloads the port range
 	// in the case of ICMP(v6) traffic to indicate which codes are allowed. For all other protocols,
 	// including the custom "-1" All Traffic protocol, FromPort and ToPort are omitted from the response.
@@ -920,8 +923,8 @@ func ingressRuleFromSDKProtocol(v *ec2.IpPermission) infrav1.IngressRule {
 		IPProtocolICMPv6:
 		return infrav1.IngressRule{
 			Protocol: infrav1.SecurityGroupProtocol(*v.IpProtocol),
-			FromPort: *v.FromPort,
-			ToPort:   *v.ToPort,
+			FromPort: utils.ToInt64Value(v.FromPort),
+			ToPort:   utils.ToInt64Value(v.ToPort),
 		}
 	default:
 		return infrav1.IngressRule{
diff --git a/pkg/cloud/services/securitygroup/service.go b/pkg/cloud/services/securitygroup/service.go
index 63231ea26..860a55776 100644
--- a/pkg/cloud/services/securitygroup/service.go
+++ b/pkg/cloud/services/securitygroup/service.go
@@ -18,10 +18,9 @@ limitations under the License.
 package securitygroup
 
 import (
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
-
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope"
+	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/common"
 )
 
 // Service holds a collection of interfaces.
@@ -30,7 +29,7 @@ import (
 type Service struct {
 	scope     scope.SGScope
 	roles     []infrav1.SecurityGroupRole
-	EC2Client ec2iface.EC2API
+	EC2Client common.EC2API
 }
 
 // NewService returns a new service given the api clients with a defined
diff --git a/pkg/cloud/tags/tags.go b/pkg/cloud/tags/tags.go
index 1f9fbd538..0b8b362d4 100644
--- a/pkg/cloud/tags/tags.go
+++ b/pkg/cloud/tags/tags.go
@@ -24,12 +24,13 @@ import (
 	"strings"
 
 	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go-v2/service/eks"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
 	"github.com/pkg/errors"
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
+	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/common"
 )
 
 const (
@@ -100,11 +101,11 @@ func (b *Builder) Ensure(current infrav1.Tags) error {
 }
 
 // WithEC2 is used to denote that the tags builder will be using EC2.
-func WithEC2(ec2client ec2iface.EC2API) BuilderOption {
+func WithEC2(ec2client common.EC2API) BuilderOption {
 	return func(b *Builder) {
 		b.applyFunc = func(params *infrav1.BuildParams) error {
 			tags := infrav1.Build(*params)
-			awsTags := make([]*ec2.Tag, 0, len(tags))
+			awsTags := make([]ec2types.Tag, 0, len(tags))
 
 			// For testing, we need sorted keys
 			sortedKeys := make([]string, 0, len(tags))
@@ -117,7 +118,7 @@ func WithEC2(ec2client ec2iface.EC2API) BuilderOption {
 			sort.Strings(sortedKeys)
 
 			for _, key := range sortedKeys {
-				tag := &ec2.Tag{
+				tag := ec2types.Tag{
 					Key:   aws.String(key),
 					Value: aws.String(tags[key]),
 				}
@@ -125,11 +126,11 @@ func WithEC2(ec2client ec2iface.EC2API) BuilderOption {
 			}
 
 			createTagsInput := &ec2.CreateTagsInput{
-				Resources: aws.StringSlice([]string{params.ResourceID}),
+				Resources: []string{params.ResourceID},
 				Tags:      awsTags,
 			}
 
-			_, err := ec2client.CreateTagsWithContext(context.TODO(), createTagsInput)
+			_, err := ec2client.CreateTags(context.TODO(), createTagsInput)
 			return errors.Wrapf(err, "failed to tag resource %q in cluster %q", params.ResourceID, params.ClusterName)
 		}
 	}
@@ -176,10 +177,10 @@ func computeDiff(current infrav1.Tags, buildParams infrav1.BuildParams) infrav1.
 }
 
 // BuildParamsToTagSpecification builds a TagSpecification for the specified resource type.
-func BuildParamsToTagSpecification(ec2ResourceType string, params infrav1.BuildParams) *ec2.TagSpecification {
+func BuildParamsToTagSpecification(ec2ResourceType ec2types.ResourceType, params infrav1.BuildParams) ec2types.TagSpecification {
 	tags := infrav1.Build(params)
 
-	tagSpec := &ec2.TagSpecification{ResourceType: aws.String(ec2ResourceType)}
+	tagSpec := ec2types.TagSpecification{ResourceType: ec2ResourceType}
 
 	// For testing, we need sorted keys
 	sortedKeys := make([]string, 0, len(tags))
@@ -190,7 +191,7 @@ func BuildParamsToTagSpecification(ec2ResourceType string, params infrav1.BuildP
 	sort.Strings(sortedKeys)
 
 	for _, key := range sortedKeys {
-		tagSpec.Tags = append(tagSpec.Tags, &ec2.Tag{
+		tagSpec.Tags = append(tagSpec.Tags, ec2types.Tag{
 			Key:   aws.String(key),
 			Value: aws.String(tags[key]),
 		})
diff --git a/pkg/utils/utils.go b/pkg/utils/utils.go
index 748c95f23..c056042fb 100644
--- a/pkg/utils/utils.go
+++ b/pkg/utils/utils.go
@@ -36,6 +36,14 @@ func ToInt64Pointer(to *int32) *int64 {
 	return ptr.To(int64(*to))
 }
 
+// ToInt64Value converts an int32 pointer to an int64 value.
+func ToInt64Value(to *int32) int64 {
+	if to == nil {
+		panic("Cannot convert nil pointer to int64")
+	}
+	return int64(*to)
+}
+
 // ToInt32Pointer converts an int64 pointer to an int32 pointer.
 func ToInt32Pointer(to *int64) *int32 {
 	if to == nil {



Test patch:
diff --git a/api/v1beta2/network_types_test.go b/api/v1beta2/network_types_test.go
index 25409f7c3..17f4f7e48 100644
--- a/api/v1beta2/network_types_test.go
+++ b/api/v1beta2/network_types_test.go
@@ -19,7 +19,7 @@ package v1beta2
 import (
 	"testing"
 
-	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/google/go-cmp/cmp"
 	. "github.com/onsi/gomega"
 	"k8s.io/utils/ptr"
@@ -338,7 +338,7 @@ func TestSubnetSpec_SetZoneInfo(t *testing.T) {
 	tests := []struct {
 		name    string
 		spec    *SubnetSpec
-		zones   []*ec2.AvailabilityZone
+		zones   []types.AvailabilityZone
 		want    *SubnetSpec
 		wantErr string
 	}{
@@ -350,7 +350,7 @@ func TestSubnetSpec_SetZoneInfo(t *testing.T) {
 				s.ParentZoneName = nil
 				return s
 			}(),
-			zones: []*ec2.AvailabilityZone{
+			zones: []types.AvailabilityZone{
 				{
 					ZoneName: ptr.To[string]("us-east-1a"),
 					ZoneType: ptr.To[string]("availability-zone"),
@@ -366,7 +366,7 @@ func TestSubnetSpec_SetZoneInfo(t *testing.T) {
 				s.ParentZoneName = nil
 				return s
 			}(),
-			zones: []*ec2.AvailabilityZone{
+			zones: []types.AvailabilityZone{
 				{
 					ZoneName: ptr.To[string]("us-east-1b"),
 					ZoneType: ptr.To[string]("availability-zone"),
@@ -386,7 +386,7 @@ func TestSubnetSpec_SetZoneInfo(t *testing.T) {
 				s.ParentZoneName = nil
 				return s
 			}(),
-			zones:   []*ec2.AvailabilityZone{},
+			zones:   []types.AvailabilityZone{},
 			wantErr: `unable to update zone information for subnet 'subnet-id-us-east-1a-private' and zone 'us-east-1a'`,
 		},
 		{
@@ -396,7 +396,7 @@ func TestSubnetSpec_SetZoneInfo(t *testing.T) {
 				s.AvailabilityZone = ""
 				return s
 			}(),
-			zones: []*ec2.AvailabilityZone{
+			zones: []types.AvailabilityZone{
 				{
 					ZoneName: ptr.To[string]("us-east-1a"),
 					ZoneType: ptr.To[string]("availability-zone"),
@@ -412,7 +412,7 @@ func TestSubnetSpec_SetZoneInfo(t *testing.T) {
 				s.ParentZoneName = nil
 				return s
 			}(),
-			zones: []*ec2.AvailabilityZone{
+			zones: []types.AvailabilityZone{
 				{
 					ZoneName: ptr.To[string]("us-east-1b"),
 					ZoneType: ptr.To[string]("availability-zone"),
@@ -436,7 +436,7 @@ func TestSubnetSpec_SetZoneInfo(t *testing.T) {
 				s.ParentZoneName = nil
 				return s
 			}(),
-			zones: []*ec2.AvailabilityZone{
+			zones: []types.AvailabilityZone{
 				{
 					ZoneName: ptr.To[string]("us-east-1b"),
 					ZoneType: ptr.To[string]("availability-zone"),
diff --git a/controllers/awscluster_controller_test.go b/controllers/awscluster_controller_test.go
index d245b7230..64dbd30c4 100644
--- a/controllers/awscluster_controller_test.go
+++ b/controllers/awscluster_controller_test.go
@@ -22,9 +22,10 @@ import (
 	"time"
 
 	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/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/service/ec2"
 	"github.com/golang/mock/gomock"
 	. "github.com/onsi/gomega"
 	"github.com/pkg/errors"
@@ -664,7 +665,7 @@ func TestAWSClusterReconcilerIntegrationTests(t *testing.T) {
 }
 
 func mockedDeleteSGCalls(m *mocks.MockEC2APIMockRecorder) {
-	m.DescribeSecurityGroupsPagesWithContext(context.TODO(), gomock.Any(), gomock.Any()).Return(nil)
+	m.DescribeSecurityGroups(context.TODO(), gomock.Any(), gomock.Any()).Return(&ec2.DescribeSecurityGroupsOutput{}, nil)
 }
 
 func mockedDescribeAvailabilityZones(m *mocks.MockEC2APIMockRecorder, zones []string) {
@@ -674,8 +675,8 @@ func mockedDescribeAvailabilityZones(m *mocks.MockEC2APIMockRecorder, zones []st
 	if len(zones) > 0 {
 		input := &ec2.DescribeAvailabilityZonesInput{}
 		for _, zone := range zones {
-			input.ZoneNames = append(input.ZoneNames, aws.String(zone))
-			output.AvailabilityZones = append(output.AvailabilityZones, &ec2.AvailabilityZone{
+			input.ZoneNames = append(input.ZoneNames, zone)
+			output.AvailabilityZones = append(output.AvailabilityZones, ec2types.AvailabilityZone{
 				ZoneName: aws.String(zone),
 				ZoneType: aws.String("availability-zone"),
 			})
@@ -683,7 +684,7 @@ func mockedDescribeAvailabilityZones(m *mocks.MockEC2APIMockRecorder, zones []st
 
 		matcher = gomock.Eq(input)
 	}
-	m.DescribeAvailabilityZonesWithContext(context.TODO(), matcher).AnyTimes().
+	m.DescribeAvailabilityZones(context.TODO(), matcher).AnyTimes().
 		Return(output, nil)
 }
 
@@ -706,47 +707,47 @@ func createControllerIdentity(g *WithT) *infrav1.AWSClusterControllerIdentity {
 }
 
 func mockedDescribeInstanceCall(m *mocks.MockEC2APIMockRecorder) {
-	m.DescribeInstancesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstancesInput{
-		Filters: []*ec2.Filter{
+	m.DescribeInstances(context.TODO(), gomock.Eq(&ec2.DescribeInstancesInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("tag:sigs.k8s.io/cluster-api-provider-aws/role"),
-				Values: aws.StringSlice([]string{"bastion"}),
+				Values: []string{"bastion"},
 			},
 			{
 				Name:   aws.String("tag-key"),
-				Values: aws.StringSlice([]string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"}),
+				Values: []string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"},
 			},
 			{
 				Name:   aws.String("instance-state-name"),
-				Values: aws.StringSlice([]string{"pending", "running", "stopping", "stopped"}),
+				Values: []string{"pending", "running", "stopping", "stopped"},
 			},
 		},
 	})).Return(&ec2.DescribeInstancesOutput{
-		Reservations: []*ec2.Reservation{
+		Reservations: []ec2types.Reservation{
 			{
-				Instances: []*ec2.Instance{
+				Instances: []ec2types.Instance{
 					{
 						InstanceId:   aws.String("id-1"),
-						InstanceType: aws.String("m5.large"),
+						InstanceType: ec2types.InstanceTypeM5Large,
 						SubnetId:     aws.String("subnet-1"),
 						ImageId:      aws.String("ami-1"),
-						IamInstanceProfile: &ec2.IamInstanceProfile{
+						IamInstanceProfile: &ec2types.IamInstanceProfile{
 							Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 						},
-						State: &ec2.InstanceState{
-							Code: aws.Int64(16),
-							Name: aws.String(ec2.StateAvailable),
+						State: &ec2types.InstanceState{
+							Code: aws.Int32(16),
+							Name: ec2types.InstanceStateNameRunning,
 						},
 						RootDeviceName: aws.String("device-1"),
-						BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+						BlockDeviceMappings: []ec2types.InstanceBlockDeviceMapping{
 							{
 								DeviceName: aws.String("device-1"),
-								Ebs: &ec2.EbsInstanceBlockDevice{
+								Ebs: &ec2types.EbsInstanceBlockDevice{
 									VolumeId: aws.String("volume-1"),
 								},
 							},
 						},
-						Placement: &ec2.Placement{
+						Placement: &ec2types.Placement{
 							AvailabilityZone: aws.String("us-east-1a"),
 						},
 					},
@@ -757,42 +758,74 @@ func mockedDescribeInstanceCall(m *mocks.MockEC2APIMockRecorder) {
 }
 
 func mockedDeleteInstanceAndAwaitTerminationCalls(m *mocks.MockEC2APIMockRecorder) {
-	m.TerminateInstancesWithContext(context.TODO(),
+	m.TerminateInstances(context.TODO(),
 		gomock.Eq(&ec2.TerminateInstancesInput{
-			InstanceIds: aws.StringSlice([]string{"id-1"}),
+			InstanceIds: []string{"id-1"},
 		}),
-	).Return(nil, nil)
-	m.WaitUntilInstanceTerminatedWithContext(context.TODO(),
-		gomock.Eq(&ec2.DescribeInstancesInput{
-			InstanceIds: aws.StringSlice([]string{"id-1"}),
-		}),
-	).Return(nil)
+	).Return(&ec2.TerminateInstancesOutput{
+		TerminatingInstances: []ec2types.InstanceStateChange{
+			{
+				InstanceId: aws.String("id-1"),
+				CurrentState: &ec2types.InstanceState{
+					Name: ec2types.InstanceStateNameShuttingDown,
+				},
+				PreviousState: &ec2types.InstanceState{
+					Name: ec2types.InstanceStateNameRunning,
+				},
+			},
+		},
+	}, nil)
+
+	m.DescribeInstances(gomock.Any(), gomock.Eq(&ec2.DescribeInstancesInput{
+		InstanceIds: []string{"id-1"},
+	}), gomock.Any()).Return(&ec2.DescribeInstancesOutput{
+		Reservations: []ec2types.Reservation{
+			{
+				Instances: []ec2types.Instance{
+					{
+						InstanceId: aws.String("id-1"),
+						State: &ec2types.InstanceState{
+							Name: ec2types.InstanceStateNameTerminated,
+						},
+					},
+				},
+			},
+		},
+	}, nil)
 }
 
 func mockedDeleteInstanceCalls(m *mocks.MockEC2APIMockRecorder) {
-	m.TerminateInstancesWithContext(context.TODO(),
+	m.TerminateInstances(context.TODO(),
 		gomock.Eq(&ec2.TerminateInstancesInput{
-			InstanceIds: aws.StringSlice([]string{"id-1"}),
+			InstanceIds: []string{"id-1"},
 		}),
 	).Return(nil, nil)
 }
 
 func mockedVPCCallsForExistingVPCAndSubnets(m *mocks.MockEC2APIMockRecorder) {
-	m.DescribeNatGatewaysPagesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
-		Filter: []*ec2.Filter{
+	m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+		Filter: []ec2types.Filter{
 			{
 				Name:   aws.String("vpc-id"),
-				Values: []*string{aws.String("vpc-exists")},
+				Values: []string{"vpc-exists"},
 			},
 			{
 				Name:   aws.String("state"),
-				Values: aws.StringSlice([]string{ec2.VpcStatePending, ec2.VpcStateAvailable}),
+				Values: []string{string(ec2types.VpcStatePending), string(ec2types.VpcStateAvailable)},
+			},
+		},
+	}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{
+		NatGateways: []ec2types.NatGateway{
+			{
+				NatGatewayId: aws.String("nat-01"),
+				SubnetId:     aws.String("subnet-2"),
+				State:        ec2types.NatGatewayStateAvailable,
 			},
 		},
-	}), gomock.Any()).Return(nil)
-	m.CreateTagsWithContext(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
-		Resources: aws.StringSlice([]string{"subnet-1"}),
-		Tags: []*ec2.Tag{
+	}, nil)
+	m.CreateTags(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
+		Resources: []string{"subnet-1"},
+		Tags: []ec2types.Tag{
 			{
 				Key:   aws.String("kubernetes.io/cluster/test-cluster"),
 				Value: aws.String("shared"),
@@ -803,9 +836,9 @@ func mockedVPCCallsForExistingVPCAndSubnets(m *mocks.MockEC2APIMockRecorder) {
 			},
 		},
 	})).Return(&ec2.CreateTagsOutput{}, nil)
-	m.CreateTagsWithContext(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
-		Resources: aws.StringSlice([]string{"subnet-2"}),
-		Tags: []*ec2.Tag{
+	m.CreateTags(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
+		Resources: []string{"subnet-2"},
+		Tags: []ec2types.Tag{
 			{
 				Key:   aws.String("kubernetes.io/cluster/test-cluster"),
 				Value: aws.String("shared"),
@@ -816,19 +849,19 @@ func mockedVPCCallsForExistingVPCAndSubnets(m *mocks.MockEC2APIMockRecorder) {
 			},
 		},
 	})).Return(&ec2.CreateTagsOutput{}, nil)
-	m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-		Filters: []*ec2.Filter{
+	m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("state"),
-				Values: aws.StringSlice([]string{ec2.VpcStatePending, ec2.VpcStateAvailable}),
+				Values: []string{string(ec2types.VpcStatePending), string(ec2types.VpcStateAvailable)},
 			},
 			{
 				Name:   aws.String("vpc-id"),
-				Values: aws.StringSlice([]string{"vpc-exists"}),
+				Values: []string{"vpc-exists"},
 			},
 		},
 	})).Return(&ec2.DescribeSubnetsOutput{
-		Subnets: []*ec2.Subnet{
+		Subnets: []ec2types.Subnet{
 			{
 				VpcId:               aws.String("vpc-exists"),
 				SubnetId:            aws.String("subnet-1"),
@@ -842,7 +875,7 @@ func mockedVPCCallsForExistingVPCAndSubnets(m *mocks.MockEC2APIMockRecorder) {
 				AvailabilityZone:    aws.String("us-east-1c"),
 				CidrBlock:           aws.String("10.0.11.0/24"),
 				MapPublicIpOnLaunch: aws.Bool(false),
-				Tags: []*ec2.Tag{
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"),
 						Value: aws.String("owned"),
@@ -863,17 +896,17 @@ func mockedVPCCallsForExistingVPCAndSubnets(m *mocks.MockEC2APIMockRecorder) {
 			},
 		},
 	}, nil)
-	m.DescribeRouteTablesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeRouteTablesInput{
-		Filters: []*ec2.Filter{
+	m.DescribeRouteTables(context.TODO(), gomock.Eq(&ec2.DescribeRouteTablesInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("vpc-id"),
-				Values: aws.StringSlice([]string{"vpc-exists"}),
+				Values: []string{"vpc-exists"},
 			},
 		},
 	})).Return(&ec2.DescribeRouteTablesOutput{
-		RouteTables: []*ec2.RouteTable{
+		RouteTables: []ec2types.RouteTable{
 			{
-				Routes: []*ec2.Route{
+				Routes: []ec2types.Route{
 					{
 						GatewayId: aws.String("igw-12345"),
 					},
@@ -881,36 +914,38 @@ func mockedVPCCallsForExistingVPCAndSubnets(m *mocks.MockEC2APIMockRecorder) {
 			},
 		},
 	}, nil)
-	m.DescribeNatGatewaysPagesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
-		Filter: []*ec2.Filter{
+	m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+		Filter: []ec2types.Filter{
 			{
 				Name:   aws.String("vpc-id"),
-				Values: []*string{aws.String("vpc-exists")},
+				Values: []string{"vpc-exists"},
 			},
 			{
 				Name:   aws.String("state"),
-				Values: aws.StringSlice([]string{ec2.VpcStatePending, ec2.VpcStateAvailable}),
+				Values: []string{string(ec2types.VpcStatePending), string(ec2types.VpcStateAvailable)},
 			},
 		},
-	}), gomock.Any()).Return(nil)
-	m.DescribeVpcsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeVpcsInput{
-		VpcIds: []*string{
-			aws.String("vpc-exists"),
+	}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{
+		NatGateways: []ec2types.NatGateway{},
+	}, nil)
+	m.DescribeVpcs(context.TODO(), gomock.Eq(&ec2.DescribeVpcsInput{
+		VpcIds: []string{
+			"vpc-exists",
 		},
-		Filters: []*ec2.Filter{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("state"),
-				Values: aws.StringSlice([]string{ec2.VpcStatePending, ec2.VpcStateAvailable}),
+				Values: []string{string(ec2types.VpcStatePending), string(ec2types.VpcStateAvailable)},
 			},
 		},
 	})).
 		Return(&ec2.DescribeVpcsOutput{
-			Vpcs: []*ec2.Vpc{
+			Vpcs: []ec2types.Vpc{
 				{
-					State:     aws.String("available"),
+					State:     ec2types.VpcStateAvailable,
 					VpcId:     aws.String("vpc-exists"),
 					CidrBlock: aws.String("10.0.0.0/8"),
-					Tags: []*ec2.Tag{
+					Tags: []ec2types.Tag{
 						{
 							Key:   aws.String("sigs.k8s.io/cluster-api-provider-aws/role"),
 							Value: aws.String("common"),
@@ -928,20 +963,20 @@ func mockedVPCCallsForExistingVPCAndSubnets(m *mocks.MockEC2APIMockRecorder) {
 // mockedCallsForMissingEverything mocks most of the AWSCluster reconciliation calls to the AWS API,
 // except for what other functions provide (see `mockedCreateSGCalls` and `mockedDescribeInstanceCall`).
 func mockedCallsForMissingEverything(m *mocks.MockEC2APIMockRecorder, e *mocks.MockELBAPIMockRecorder, privateSubnetName string, publicSubnetName string) {
-	describeVPCByNameCall := m.DescribeVpcsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeVpcsInput{
-		Filters: []*ec2.Filter{
+	describeVPCByNameCall := m.DescribeVpcs(context.TODO(), gomock.Eq(&ec2.DescribeVpcsInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("tag:Name"),
-				Values: aws.StringSlice([]string{"test-cluster-vpc"}),
+				Values: []string{"test-cluster-vpc"},
 			},
 		},
-	})).Return(&ec2.DescribeVpcsOutput{Vpcs: []*ec2.Vpc{}}, nil)
-	m.CreateVpcWithContext(context.TODO(), gomock.Eq(&ec2.CreateVpcInput{
+	})).Return(&ec2.DescribeVpcsOutput{Vpcs: []ec2types.Vpc{}}, nil)
+	m.CreateVpc(context.TODO(), gomock.Eq(&ec2.CreateVpcInput{
 		CidrBlock: aws.String("10.0.0.0/8"),
-		TagSpecifications: []*ec2.TagSpecification{
+		TagSpecifications: []ec2types.TagSpecification{
 			{
-				ResourceType: aws.String("vpc"),
-				Tags: []*ec2.Tag{
+				ResourceType: ec2types.ResourceTypeVpc,
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String("test-cluster-vpc"),
@@ -958,11 +993,11 @@ func mockedCallsForMissingEverything(m *mocks.MockEC2APIMockRecorder, e *mocks.M
 			},
 		},
 	})).After(describeVPCByNameCall).Return(&ec2.CreateVpcOutput{
-		Vpc: &ec2.Vpc{
-			State:     aws.String("available"),
+		Vpc: &ec2types.Vpc{
+			State:     ec2types.VpcStateAvailable,
 			VpcId:     aws.String("vpc-new"),
 			CidrBlock: aws.String("10.0.0.0/8"),
-			Tags: []*ec2.Tag{
+			Tags: []ec2types.Tag{
 				{
 					Key:   aws.String("Name"),
 					Value: aws.String("test-cluster-vpc"),
@@ -979,43 +1014,43 @@ func mockedCallsForMissingEverything(m *mocks.MockEC2APIMockRecorder, e *mocks.M
 		},
 	}, nil)
 
-	m.DescribeVpcAttributeWithContext(context.TODO(), gomock.Eq(&ec2.DescribeVpcAttributeInput{
+	m.DescribeVpcAttribute(context.TODO(), gomock.Eq(&ec2.DescribeVpcAttributeInput{
 		VpcId:     aws.String("vpc-new"),
-		Attribute: aws.String("enableDnsHostnames"),
+		Attribute: ec2types.VpcAttributeNameEnableDnsHostnames,
 	})).Return(&ec2.DescribeVpcAttributeOutput{
-		EnableDnsHostnames: &ec2.AttributeBooleanValue{Value: aws.Bool(true)},
+		EnableDnsHostnames: &ec2types.AttributeBooleanValue{Value: aws.Bool(true)},
 	}, nil)
 
-	m.DescribeVpcAttributeWithContext(context.TODO(), gomock.Eq(&ec2.DescribeVpcAttributeInput{
+	m.DescribeVpcAttribute(context.TODO(), gomock.Eq(&ec2.DescribeVpcAttributeInput{
 		VpcId:     aws.String("vpc-new"),
-		Attribute: aws.String("enableDnsSupport"),
+		Attribute: ec2types.VpcAttributeNameEnableDnsSupport,
 	})).Return(&ec2.DescribeVpcAttributeOutput{
-		EnableDnsSupport: &ec2.AttributeBooleanValue{Value: aws.Bool(true)},
+		EnableDnsSupport: &ec2types.AttributeBooleanValue{Value: aws.Bool(true)},
 	}, nil)
 
-	m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-		Filters: []*ec2.Filter{
+	m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("state"),
-				Values: aws.StringSlice([]string{ec2.VpcStatePending, ec2.VpcStateAvailable}),
+				Values: []string{string(ec2types.VpcStatePending), string(ec2types.VpcStateAvailable)},
 			},
 			{
 				Name:   aws.String("vpc-id"),
-				Values: aws.StringSlice([]string{"vpc-new"}),
+				Values: []string{"vpc-new"},
 			},
 		},
-	})).Return(&ec2.DescribeSubnetsOutput{
-		Subnets: []*ec2.Subnet{},
+	}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+		Subnets: []ec2types.Subnet{},
 	}, nil)
 
-	m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+	subnet1 := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 		VpcId:            aws.String("vpc-new"),
 		CidrBlock:        aws.String("10.0.10.0/24"),
 		AvailabilityZone: aws.String("us-east-1a"),
-		TagSpecifications: []*ec2.TagSpecification{
+		TagSpecifications: []ec2types.TagSpecification{
 			{
-				ResourceType: aws.String("subnet"),
-				Tags: []*ec2.Tag{
+				ResourceType: ec2types.ResourceTypeSubnet,
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String(privateSubnetName),
@@ -1040,13 +1075,13 @@ func mockedCallsForMissingEverything(m *mocks.MockEC2APIMockRecorder, e *mocks.M
 			},
 		},
 	})).Return(&ec2.CreateSubnetOutput{
-		Subnet: &ec2.Subnet{
+		Subnet: &ec2types.Subnet{
 			VpcId:               aws.String("vpc-new"),
 			SubnetId:            aws.String("subnet-1"),
 			CidrBlock:           aws.String("10.0.10.0/24"),
 			AvailabilityZone:    aws.String("us-east-1a"),
 			MapPublicIpOnLaunch: aws.Bool(false),
-			Tags: []*ec2.Tag{
+			Tags: []ec2types.Tag{
 				{
 					Key:   aws.String("Name"),
 					Value: aws.String(privateSubnetName),
@@ -1071,18 +1106,28 @@ func mockedCallsForMissingEverything(m *mocks.MockEC2APIMockRecorder, e *mocks.M
 		},
 	}, nil)
 
-	m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-		SubnetIds: aws.StringSlice([]string{"subnet-1"}),
-	})).Return(nil)
+	m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+		SubnetIds: []string{"subnet-1"},
+	}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+		Subnets: []ec2types.Subnet{
+			{
+				VpcId:            aws.String("vpc-new"),
+				SubnetId:         aws.String("subnet-1"),
+				CidrBlock:        aws.String("10.0.10.0/24"),
+				AvailabilityZone: aws.String("us-east-1a"),
+				State:            ec2types.SubnetStateAvailable,
+			},
+		},
+	}, nil).After(subnet1)
 
-	m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+	subnet2 := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 		VpcId:            aws.String("vpc-new"),
 		CidrBlock:        aws.String("10.0.11.0/24"),
 		AvailabilityZone: aws.String("us-east-1a"),
-		TagSpecifications: []*ec2.TagSpecification{
+		TagSpecifications: []ec2types.TagSpecification{
 			{
-				ResourceType: aws.String("subnet"),
-				Tags: []*ec2.Tag{
+				ResourceType: ec2types.ResourceTypeSubnet,
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String(publicSubnetName),
@@ -1107,13 +1152,13 @@ func mockedCallsForMissingEverything(m *mocks.MockEC2APIMockRecorder, e *mocks.M
 			},
 		},
 	})).Return(&ec2.CreateSubnetOutput{
-		Subnet: &ec2.Subnet{
+		Subnet: &ec2types.Subnet{
 			VpcId:               aws.String("vpc-new"),
 			SubnetId:            aws.String("subnet-2"),
 			CidrBlock:           aws.String("10.0.11.0/24"),
 			AvailabilityZone:    aws.String("us-east-1a"),
 			MapPublicIpOnLaunch: aws.Bool(false),
-			Tags: []*ec2.Tag{
+			Tags: []ec2types.Tag{
 				{
 					Key:   aws.String("Name"),
 					Value: aws.String(publicSubnetName),
@@ -1138,32 +1183,43 @@ func mockedCallsForMissingEverything(m *mocks.MockEC2APIMockRecorder, e *mocks.M
 		},
 	}, nil)
 
-	m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-		SubnetIds: aws.StringSlice([]string{"subnet-2"}),
-	})).Return(nil)
+	m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+		SubnetIds: []string{"subnet-2"},
+	}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+		Subnets: []ec2types.Subnet{
+			{
+				VpcId:               aws.String("vpc-new"),
+				SubnetId:            aws.String("subnet-2"),
+				CidrBlock:           aws.String("10.0.11.0/24"),
+				AvailabilityZone:    aws.String("us-east-1a"),
+				MapPublicIpOnLaunch: aws.Bool(false),
+				State:               ec2types.SubnetStateAvailable,
+			},
+		},
+	}, nil).After(subnet2)
 
-	m.ModifySubnetAttributeWithContext(context.TODO(), gomock.Eq(&ec2.ModifySubnetAttributeInput{
+	m.ModifySubnetAttribute(context.TODO(), gomock.Eq(&ec2.ModifySubnetAttributeInput{
 		SubnetId: aws.String("subnet-2"),
-		MapPublicIpOnLaunch: &ec2.AttributeBooleanValue{
+		MapPublicIpOnLaunch: &ec2types.AttributeBooleanValue{
 			Value: aws.Bool(true),
 		},
 	})).Return(&ec2.ModifySubnetAttributeOutput{}, nil)
 
-	m.DescribeRouteTablesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeRouteTablesInput{
-		Filters: []*ec2.Filter{
+	m.DescribeRouteTables(context.TODO(), gomock.Eq(&ec2.DescribeRouteTablesInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("vpc-id"),
-				Values: aws.StringSlice([]string{"vpc-new"}),
+				Values: []string{"vpc-new"},
 			},
 			{
 				Name:   aws.String("tag-key"),
-				Values: aws.StringSlice([]string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"}),
+				Values: []string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"},
 			},
 		},
 	})).Return(&ec2.DescribeRouteTablesOutput{
-		RouteTables: []*ec2.RouteTable{
+		RouteTables: []ec2types.RouteTable{
 			{
-				Routes: []*ec2.Route{
+				Routes: []ec2types.Route{
 					{
 						GatewayId: aws.String("igw-12345"),
 					},
@@ -1172,22 +1228,22 @@ func mockedCallsForMissingEverything(m *mocks.MockEC2APIMockRecorder, e *mocks.M
 		},
 	}, nil).MinTimes(1).MaxTimes(2)
 
-	m.DescribeInternetGatewaysWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInternetGatewaysInput{
-		Filters: []*ec2.Filter{
+	m.DescribeInternetGateways(context.TODO(), gomock.Eq(&ec2.DescribeInternetGatewaysInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("attachment.vpc-id"),
-				Values: aws.StringSlice([]string{"vpc-new"}),
+				Values: []string{"vpc-new"},
 			},
 		},
 	})).Return(&ec2.DescribeInternetGatewaysOutput{
-		InternetGateways: []*ec2.InternetGateway{},
+		InternetGateways: []ec2types.InternetGateway{},
 	}, nil)
 
-	m.CreateInternetGatewayWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateInternetGatewayInput{})).
+	m.CreateInternetGateway(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateInternetGatewayInput{})).
 		Return(&ec2.CreateInternetGatewayOutput{
-			InternetGateway: &ec2.InternetGateway{
+			InternetGateway: &ec2types.InternetGateway{
 				InternetGatewayId: aws.String("igw-1"),
-				Tags: []*ec2.Tag{
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String(infrav1.ClusterTagKey("test-cluster")),
 						Value: aws.String("owned"),
@@ -1204,46 +1260,46 @@ func mockedCallsForMissingEverything(m *mocks.MockEC2APIMockRecorder, e *mocks.M
 			},
 		}, nil)
 
-	m.AttachInternetGatewayWithContext(context.TODO(), gomock.Eq(&ec2.AttachInternetGatewayInput{
+	m.AttachInternetGateway(context.TODO(), gomock.Eq(&ec2.AttachInternetGatewayInput{
 		InternetGatewayId: aws.String("igw-1"),
 		VpcId:             aws.String("vpc-new"),
 	})).
 		Return(&ec2.AttachInternetGatewayOutput{}, nil)
 
-	m.DescribeNatGatewaysPagesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
-		Filter: []*ec2.Filter{
+	m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+		Filter: []ec2types.Filter{
 			{
 				Name:   aws.String("vpc-id"),
-				Values: []*string{aws.String("vpc-new")},
+				Values: []string{"vpc-new"},
 			},
 			{
 				Name:   aws.String("state"),
-				Values: aws.StringSlice([]string{ec2.VpcStatePending, ec2.VpcStateAvailable}),
+				Values: []string{string(ec2types.VpcStatePending), string(ec2types.VpcStateAvailable)},
 			},
 		},
-	}), gomock.Any()).Return(nil).MinTimes(1).MaxTimes(2)
+	}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil).MinTimes(1).MaxTimes(2)
 
-	m.DescribeAddressesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeAddressesInput{
-		Filters: []*ec2.Filter{
+	m.DescribeAddresses(context.TODO(), gomock.Eq(&ec2.DescribeAddressesInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("tag-key"),
-				Values: aws.StringSlice([]string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"}),
+				Values: []string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"},
 			},
 			{
 				Name:   aws.String("tag:sigs.k8s.io/cluster-api-provider-aws/role"),
-				Values: aws.StringSlice([]string{"common"}),
+				Values: []string{"common"},
 			},
 		},
 	})).Return(&ec2.DescribeAddressesOutput{
-		Addresses: []*ec2.Address{},
+		Addresses: []ec2types.Address{},
 	}, nil)
 
-	m.AllocateAddressWithContext(context.TODO(), gomock.Eq(&ec2.AllocateAddressInput{
-		Domain: aws.String("vpc"),
-		TagSpecifications: []*ec2.TagSpecification{
+	m.AllocateAddress(context.TODO(), gomock.Eq(&ec2.AllocateAddressInput{
+		Domain: ec2types.DomainTypeVpc,
+		TagSpecifications: []ec2types.TagSpecification{
 			{
-				ResourceType: aws.String("elastic-ip"),
-				Tags: []*ec2.Tag{
+				ResourceType: ec2types.ResourceTypeElasticIp,
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String("test-cluster-eip-common"),
@@ -1263,13 +1319,13 @@ func mockedCallsForMissingEverything(m *mocks.MockEC2APIMockRecorder, e *mocks.M
 		AllocationId: aws.String("1234"),
 	}, nil)
 
-	m.CreateNatGatewayWithContext(context.TODO(), gomock.Eq(&ec2.CreateNatGatewayInput{
+	m.CreateNatGateway(context.TODO(), gomock.Eq(&ec2.CreateNatGatewayInput{
 		AllocationId: aws.String("1234"),
 		SubnetId:     aws.String("subnet-2"),
-		TagSpecifications: []*ec2.TagSpecification{
+		TagSpecifications: []ec2types.TagSpecification{
 			{
-				ResourceType: aws.String("natgateway"),
-				Tags: []*ec2.Tag{
+				ResourceType: ec2types.ResourceTypeNatgateway,
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String("test-cluster-nat"),
@@ -1286,21 +1342,29 @@ func mockedCallsForMissingEverything(m *mocks.MockEC2APIMockRecorder, e *mocks.M
 			},
 		},
 	})).Return(&ec2.CreateNatGatewayOutput{
-		NatGateway: &ec2.NatGateway{
+		NatGateway: &ec2types.NatGateway{
 			NatGatewayId: aws.String("nat-01"),
 			SubnetId:     aws.String("subnet-2"),
 		},
 	}, nil)
 
-	m.WaitUntilNatGatewayAvailableWithContext(context.TODO(), &ec2.DescribeNatGatewaysInput{
-		NatGatewayIds: []*string{aws.String("nat-01")},
-	}).Return(nil)
+	m.DescribeNatGateways(gomock.Any(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+		NatGatewayIds: []string{"nat-01"},
+	}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{
+		NatGateways: []ec2types.NatGateway{
+			{
+				NatGatewayId: aws.String("nat-01"),
+				SubnetId:     aws.String("subnet-2"),
+				State:        ec2types.NatGatewayStateAvailable,
+			},
+		},
+	}, nil)
 
-	m.CreateRouteTableWithContext(context.TODO(), gomock.Eq(&ec2.CreateRouteTableInput{
-		TagSpecifications: []*ec2.TagSpecification{
+	m.CreateRouteTable(context.TODO(), gomock.Eq(&ec2.CreateRouteTableInput{
+		TagSpecifications: []ec2types.TagSpecification{
 			{
-				ResourceType: aws.String("route-table"),
-				Tags: []*ec2.Tag{
+				ResourceType: ec2types.ResourceTypeRouteTable,
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String("test-cluster-rt-private-us-east-1a"),
@@ -1322,27 +1386,27 @@ func mockedCallsForMissingEverything(m *mocks.MockEC2APIMockRecorder, e *mocks.M
 		},
 		VpcId: aws.String("vpc-new"),
 	})).Return(&ec2.CreateRouteTableOutput{
-		RouteTable: &ec2.RouteTable{
+		RouteTable: &ec2types.RouteTable{
 			RouteTableId: aws.String("rtb-1"),
 		},
 	}, nil)
 
-	m.CreateRouteWithContext(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
+	m.CreateRoute(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
 		DestinationCidrBlock: aws.String("0.0.0.0/0"),
 		NatGatewayId:         aws.String("nat-01"),
 		RouteTableId:         aws.String("rtb-1"),
 	})).Return(&ec2.CreateRouteOutput{}, nil)
 
-	m.AssociateRouteTableWithContext(context.TODO(), gomock.Eq(&ec2.AssociateRouteTableInput{
+	m.AssociateRouteTable(context.TODO(), gomock.Eq(&ec2.AssociateRouteTableInput{
 		RouteTableId: aws.String("rtb-1"),
 		SubnetId:     aws.String("subnet-1"),
 	})).Return(&ec2.AssociateRouteTableOutput{}, nil)
 
-	m.CreateRouteTableWithContext(context.TODO(), gomock.Eq(&ec2.CreateRouteTableInput{
-		TagSpecifications: []*ec2.TagSpecification{
+	m.CreateRouteTable(context.TODO(), gomock.Eq(&ec2.CreateRouteTableInput{
+		TagSpecifications: []ec2types.TagSpecification{
 			{
-				ResourceType: aws.String("route-table"),
-				Tags: []*ec2.Tag{
+				ResourceType: ec2types.ResourceTypeRouteTable,
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String("test-cluster-rt-public-us-east-1a"),
@@ -1364,18 +1428,18 @@ func mockedCallsForMissingEverything(m *mocks.MockEC2APIMockRecorder, e *mocks.M
 		},
 		VpcId: aws.String("vpc-new"),
 	})).Return(&ec2.CreateRouteTableOutput{
-		RouteTable: &ec2.RouteTable{
+		RouteTable: &ec2types.RouteTable{
 			RouteTableId: aws.String("rtb-2"),
 		},
 	}, nil)
 
-	m.CreateRouteWithContext(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
+	m.CreateRoute(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
 		DestinationCidrBlock: aws.String("0.0.0.0/0"),
 		GatewayId:            aws.String("igw-1"),
 		RouteTableId:         aws.String("rtb-2"),
 	})).Return(&ec2.CreateRouteOutput{}, nil)
 
-	m.AssociateRouteTableWithContext(context.TODO(), gomock.Eq(&ec2.AssociateRouteTableInput{
+	m.AssociateRouteTable(context.TODO(), gomock.Eq(&ec2.AssociateRouteTableInput{
 		RouteTableId: aws.String("rtb-2"),
 		SubnetId:     aws.String("subnet-2"),
 	})).Return(&ec2.AssociateRouteTableOutput{}, nil)
@@ -1430,102 +1494,104 @@ func mockedCallsForMissingEverything(m *mocks.MockEC2APIMockRecorder, e *mocks.M
 }
 
 func mockedCreateMaximumVPCCalls(m *mocks.MockEC2APIMockRecorder) {
-	describeVPCByNameCall := m.DescribeVpcsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
-		Vpcs: []*ec2.Vpc{},
+	describeVPCByNameCall := m.DescribeVpcs(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
+		Vpcs: []ec2types.Vpc{},
 	}, nil)
-	m.CreateVpcWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateVpcInput{})).After(describeVPCByNameCall).Return(nil, errors.New("The maximum number of VPCs has been reached"))
+	m.CreateVpc(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateVpcInput{})).After(describeVPCByNameCall).Return(nil, errors.New("The maximum number of VPCs has been reached"))
 }
 
 func mockedDeleteVPCCallsForNonExistentVPC(m *mocks.MockEC2APIMockRecorder) {
-	m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-		Filters: []*ec2.Filter{
+	m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("state"),
-				Values: aws.StringSlice([]string{ec2.VpcStatePending, ec2.VpcStateAvailable}),
+				Values: []string{string(ec2types.VpcStatePending), string(ec2types.VpcStateAvailable)},
 			},
 			{
 				Name:   aws.String("tag-key"),
-				Values: aws.StringSlice([]string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"}),
+				Values: []string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"},
 			},
 		},
 	})).Return(&ec2.DescribeSubnetsOutput{
-		Subnets: []*ec2.Subnet{},
+		Subnets: []ec2types.Subnet{},
 	}, nil).AnyTimes()
-	m.DescribeRouteTablesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeRouteTablesInput{
-		Filters: []*ec2.Filter{
+	m.DescribeRouteTables(context.TODO(), gomock.Eq(&ec2.DescribeRouteTablesInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("vpc-id"),
-				Values: aws.StringSlice([]string{""}),
+				Values: []string{""},
 			},
 			{
 				Name:   aws.String("tag-key"),
-				Values: aws.StringSlice([]string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"}),
+				Values: []string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"},
 			},
 		},
 	})).Return(&ec2.DescribeRouteTablesOutput{
-		RouteTables: []*ec2.RouteTable{},
+		RouteTables: []ec2types.RouteTable{},
 	}, nil).AnyTimes()
-	m.DescribeInternetGatewaysWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInternetGatewaysInput{
-		Filters: []*ec2.Filter{
+	m.DescribeInternetGateways(context.TODO(), gomock.Eq(&ec2.DescribeInternetGatewaysInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("attachment.vpc-id"),
-				Values: aws.StringSlice([]string{""}),
+				Values: []string{""},
 			},
 		},
 	})).Return(&ec2.DescribeInternetGatewaysOutput{
-		InternetGateways: []*ec2.InternetGateway{},
+		InternetGateways: []ec2types.InternetGateway{},
 	}, nil)
-	m.DescribeNatGatewaysPagesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
-		Filter: []*ec2.Filter{
+	m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+		Filter: []ec2types.Filter{
 			{
 				Name:   aws.String("vpc-id"),
-				Values: []*string{aws.String("")},
+				Values: []string{""},
 			},
 		},
-	}), gomock.Any()).Return(nil).AnyTimes()
-	m.DescribeAddressesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeAddressesInput{
-		Filters: []*ec2.Filter{
+	}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{
+		NatGateways: []ec2types.NatGateway{},
+	}, nil).AnyTimes()
+	m.DescribeAddresses(context.TODO(), gomock.Eq(&ec2.DescribeAddressesInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("tag-key"),
-				Values: aws.StringSlice([]string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"}),
+				Values: []string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"},
 			},
 			{
 				Name:   aws.String("tag:sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"),
-				Values: aws.StringSlice([]string{"owned"}),
+				Values: []string{"owned"},
 			},
 		},
 	})).Return(nil, nil)
-	m.DeleteVpcWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DeleteVpcInput{
+	m.DeleteVpc(context.TODO(), gomock.AssignableToTypeOf(&ec2.DeleteVpcInput{
 		VpcId: aws.String("vpc-exists"),
 	})).Return(nil, nil)
 }
 
 func mockedDeleteVPCCalls(m *mocks.MockEC2APIMockRecorder) {
-	m.DescribeVpcEndpointsPages(gomock.Eq(&ec2.DescribeVpcEndpointsInput{
-		Filters: []*ec2.Filter{
+	m.DescribeVpcEndpoints(context.TODO(), gomock.Eq(&ec2.DescribeVpcEndpointsInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("tag:sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"),
-				Values: []*string{aws.String("owned")},
+				Values: []string{"owned"},
 			},
 			{
 				Name:   aws.String("vpc-id"),
-				Values: []*string{aws.String("vpc-exists")},
+				Values: []string{"vpc-exists"},
 			},
 		},
-	}), gomock.Any()).Return(nil).AnyTimes()
-	m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-		Filters: []*ec2.Filter{
+	}), gomock.Any()).Return(&ec2.DescribeVpcEndpointsOutput{}, nil).AnyTimes()
+	m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("state"),
-				Values: aws.StringSlice([]string{ec2.VpcStatePending, ec2.VpcStateAvailable}),
+				Values: []string{string(ec2types.VpcStatePending), string(ec2types.VpcStateAvailable)},
 			},
 			{
 				Name:   aws.String("vpc-id"),
-				Values: aws.StringSlice([]string{"vpc-exists"}),
+				Values: []string{"vpc-exists"},
 			},
 		},
 	})).Return(&ec2.DescribeSubnetsOutput{
-		Subnets: []*ec2.Subnet{
+		Subnets: []ec2types.Subnet{
 			{
 				VpcId:               aws.String("vpc-exists"),
 				SubnetId:            aws.String("subnet-1"),
@@ -1535,21 +1601,21 @@ func mockedDeleteVPCCalls(m *mocks.MockEC2APIMockRecorder) {
 			},
 		},
 	}, nil).AnyTimes()
-	m.DescribeRouteTablesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeRouteTablesInput{
-		Filters: []*ec2.Filter{
+	m.DescribeRouteTables(context.TODO(), gomock.Eq(&ec2.DescribeRouteTablesInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("vpc-id"),
-				Values: aws.StringSlice([]string{"vpc-exists"}),
+				Values: []string{"vpc-exists"},
 			},
 			{
 				Name:   aws.String("tag-key"),
-				Values: aws.StringSlice([]string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"}),
+				Values: []string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"},
 			},
 		},
 	})).Return(&ec2.DescribeRouteTablesOutput{
-		RouteTables: []*ec2.RouteTable{
+		RouteTables: []ec2types.RouteTable{
 			{
-				Routes: []*ec2.Route{
+				Routes: []ec2types.Route{
 					{
 						GatewayId: aws.String("igw-12345"),
 					},
@@ -1558,56 +1624,56 @@ func mockedDeleteVPCCalls(m *mocks.MockEC2APIMockRecorder) {
 			},
 		},
 	}, nil).AnyTimes()
-	m.DeleteRouteTableWithContext(context.TODO(), gomock.Eq(&ec2.DeleteRouteTableInput{
+	m.DeleteRouteTable(context.TODO(), gomock.Eq(&ec2.DeleteRouteTableInput{
 		RouteTableId: aws.String("rt-12345"),
 	}))
-	m.DescribeInternetGatewaysWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInternetGatewaysInput{
-		Filters: []*ec2.Filter{
+	m.DescribeInternetGateways(context.TODO(), gomock.Eq(&ec2.DescribeInternetGatewaysInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("attachment.vpc-id"),
-				Values: aws.StringSlice([]string{"vpc-exists"}),
+				Values: []string{"vpc-exists"},
 			},
 		},
 	})).Return(&ec2.DescribeInternetGatewaysOutput{
-		InternetGateways: []*ec2.InternetGateway{
+		InternetGateways: []ec2types.InternetGateway{
 			{
 				Attachments:       nil,
 				InternetGatewayId: aws.String("ig-12345"),
 			},
 		},
 	}, nil)
-	m.DetachInternetGatewayWithContext(context.TODO(), gomock.Eq(&ec2.DetachInternetGatewayInput{
+	m.DetachInternetGateway(context.TODO(), gomock.Eq(&ec2.DetachInternetGatewayInput{
 		VpcId:             aws.String("vpc-exists"),
 		InternetGatewayId: aws.String("ig-12345"),
 	}))
-	m.DeleteInternetGatewayWithContext(context.TODO(), gomock.Eq(&ec2.DeleteInternetGatewayInput{
+	m.DeleteInternetGateway(context.TODO(), gomock.Eq(&ec2.DeleteInternetGatewayInput{
 		InternetGatewayId: aws.String("ig-12345"),
 	}))
-	m.DescribeNatGatewaysPagesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
-		Filter: []*ec2.Filter{
+	m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+		Filter: []ec2types.Filter{
 			{
 				Name:   aws.String("vpc-id"),
-				Values: []*string{aws.String("vpc-exists")},
+				Values: []string{"vpc-exists"},
 			},
 			{
 				Name:   aws.String("state"),
-				Values: aws.StringSlice([]string{ec2.VpcStatePending, ec2.VpcStateAvailable}),
+				Values: []string{string(ec2types.VpcStatePending), string(ec2types.VpcStateAvailable)},
 			},
 		},
-	}), gomock.Any()).Return(nil).AnyTimes()
-	m.DescribeAddressesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeAddressesInput{
-		Filters: []*ec2.Filter{
+	}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil).AnyTimes()
+	m.DescribeAddresses(context.TODO(), gomock.Eq(&ec2.DescribeAddressesInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("tag-key"),
-				Values: aws.StringSlice([]string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"}),
+				Values: []string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"},
 			},
 			{
 				Name:   aws.String("tag:sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"),
-				Values: aws.StringSlice([]string{"owned"}),
+				Values: []string{"owned"},
 			},
 		},
 	})).Return(&ec2.DescribeAddressesOutput{
-		Addresses: []*ec2.Address{
+		Addresses: []ec2types.Address{
 			{
 				AssociationId: aws.String("1234"),
 				AllocationId:  aws.String("1234"),
@@ -1615,30 +1681,30 @@ func mockedDeleteVPCCalls(m *mocks.MockEC2APIMockRecorder) {
 			},
 		},
 	}, nil)
-	m.DisassociateAddressWithContext(context.TODO(), &ec2.DisassociateAddressInput{
+	m.DisassociateAddress(context.TODO(), &ec2.DisassociateAddressInput{
 		AssociationId: aws.String("1234"),
 	})
-	m.ReleaseAddressWithContext(context.TODO(), &ec2.ReleaseAddressInput{
+	m.ReleaseAddress(context.TODO(), &ec2.ReleaseAddressInput{
 		AllocationId: aws.String("1234"),
 	})
-	m.DescribeVpcsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeVpcsInput{
-		VpcIds: []*string{
-			aws.String("vpc-exists"),
+	m.DescribeVpcs(context.TODO(), gomock.Eq(&ec2.DescribeVpcsInput{
+		VpcIds: []string{
+			"vpc-exists",
 		},
-		Filters: []*ec2.Filter{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("state"),
-				Values: aws.StringSlice([]string{ec2.VpcStatePending, ec2.VpcStateAvailable}),
+				Values: []string{string(ec2types.VpcStatePending), string(ec2types.VpcStateAvailable)},
 			},
 		},
 	})).
 		Return(&ec2.DescribeVpcsOutput{
-			Vpcs: []*ec2.Vpc{
+			Vpcs: []ec2types.Vpc{
 				{
-					State:     aws.String("available"),
+					State:     ec2types.VpcStateAvailable,
 					VpcId:     aws.String("vpc-exists"),
 					CidrBlock: aws.String("10.0.0.0/8"),
-					Tags: []*ec2.Tag{
+					Tags: []ec2types.Tag{
 						{
 							Key:   aws.String("sigs.k8s.io/cluster-api-provider-aws/role"),
 							Value: aws.String("common"),
@@ -1655,43 +1721,43 @@ func mockedDeleteVPCCalls(m *mocks.MockEC2APIMockRecorder) {
 				},
 			},
 		}, nil)
-	m.DeleteSubnetWithContext(context.TODO(), gomock.Eq(&ec2.DeleteSubnetInput{
+	m.DeleteSubnet(context.TODO(), gomock.Eq(&ec2.DeleteSubnetInput{
 		SubnetId: aws.String("subnet-1"),
 	}))
-	m.DeleteVpcWithContext(context.TODO(), gomock.Eq(&ec2.DeleteVpcInput{
+	m.DeleteVpc(context.TODO(), gomock.Eq(&ec2.DeleteVpcInput{
 		VpcId: aws.String("vpc-exists"),
 	}))
 }
 
 func mockedCreateSGCalls(recordLBV2 bool, vpcID string, m *mocks.MockEC2APIMockRecorder) {
-	m.DescribeSecurityGroupsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSecurityGroupsInput{
-		Filters: []*ec2.Filter{
+	m.DescribeSecurityGroups(context.TODO(), gomock.Eq(&ec2.DescribeSecurityGroupsInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("vpc-id"),
-				Values: aws.StringSlice([]string{vpcID}),
+				Values: []string{vpcID},
 			},
 			{
 				Name:   aws.String("tag-key"),
-				Values: aws.StringSlice([]string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"}),
+				Values: []string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"},
 			},
 		},
 	})).Return(
 		&ec2.DescribeSecurityGroupsOutput{
-			SecurityGroups: []*ec2.SecurityGroup{
+			SecurityGroups: []ec2types.SecurityGroup{
 				{
 					GroupId:   aws.String("1"),
 					GroupName: aws.String("test-sg"),
 				},
 			},
 		}, nil)
-	m.CreateSecurityGroupWithContext(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
+	m.CreateSecurityGroup(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
 		VpcId:       aws.String(vpcID),
 		GroupName:   aws.String("test-cluster-bastion"),
 		Description: aws.String("Kubernetes cluster test-cluster: bastion"),
-		TagSpecifications: []*ec2.TagSpecification{
+		TagSpecifications: []ec2types.TagSpecification{
 			{
-				ResourceType: aws.String("security-group"),
-				Tags: []*ec2.Tag{
+				ResourceType: ec2types.ResourceTypeSecurityGroup,
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String("test-cluster-bastion"),
@@ -1709,14 +1775,14 @@ func mockedCreateSGCalls(recordLBV2 bool, vpcID string, m *mocks.MockEC2APIMockR
 		},
 	})).
 		Return(&ec2.CreateSecurityGroupOutput{GroupId: aws.String("sg-bastion")}, nil)
-	m.CreateSecurityGroupWithContext(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
+	m.CreateSecurityGroup(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
 		VpcId:       aws.String(vpcID),
 		GroupName:   aws.String("test-cluster-apiserver-lb"),
 		Description: aws.String("Kubernetes cluster test-cluster: apiserver-lb"),
-		TagSpecifications: []*ec2.TagSpecification{
+		TagSpecifications: []ec2types.TagSpecification{
 			{
-				ResourceType: aws.String("security-group"),
-				Tags: []*ec2.Tag{
+				ResourceType: ec2types.ResourceTypeSecurityGroup,
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String("test-cluster-apiserver-lb"),
@@ -1734,14 +1800,14 @@ func mockedCreateSGCalls(recordLBV2 bool, vpcID string, m *mocks.MockEC2APIMockR
 		},
 	})).
 		Return(&ec2.CreateSecurityGroupOutput{GroupId: aws.String("sg-apiserver-lb")}, nil)
-	m.CreateSecurityGroupWithContext(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
+	m.CreateSecurityGroup(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
 		VpcId:       aws.String(vpcID),
 		GroupName:   aws.String("test-cluster-lb"),
 		Description: aws.String("Kubernetes cluster test-cluster: lb"),
-		TagSpecifications: []*ec2.TagSpecification{
+		TagSpecifications: []ec2types.TagSpecification{
 			{
-				ResourceType: aws.String("security-group"),
-				Tags: []*ec2.Tag{
+				ResourceType: ec2types.ResourceTypeSecurityGroup,
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String("test-cluster-lb"),
@@ -1763,14 +1829,14 @@ func mockedCreateSGCalls(recordLBV2 bool, vpcID string, m *mocks.MockEC2APIMockR
 		},
 	})).
 		Return(&ec2.CreateSecurityGroupOutput{GroupId: aws.String("sg-lb")}, nil)
-	securityGroupControl := m.CreateSecurityGroupWithContext(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
+	securityGroupControl := m.CreateSecurityGroup(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
 		VpcId:       aws.String(vpcID),
 		GroupName:   aws.String("test-cluster-controlplane"),
 		Description: aws.String("Kubernetes cluster test-cluster: controlplane"),
-		TagSpecifications: []*ec2.TagSpecification{
+		TagSpecifications: []ec2types.TagSpecification{
 			{
-				ResourceType: aws.String("security-group"),
-				Tags: []*ec2.Tag{
+				ResourceType: ec2types.ResourceTypeSecurityGroup,
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String("test-cluster-controlplane"),
@@ -1788,14 +1854,14 @@ func mockedCreateSGCalls(recordLBV2 bool, vpcID string, m *mocks.MockEC2APIMockR
 		},
 	})).
 		Return(&ec2.CreateSecurityGroupOutput{GroupId: aws.String("sg-controlplane")}, nil)
-	securityGroupNode := m.CreateSecurityGroupWithContext(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
+	securityGroupNode := m.CreateSecurityGroup(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
 		VpcId:       aws.String(vpcID),
 		GroupName:   aws.String("test-cluster-node"),
 		Description: aws.String("Kubernetes cluster test-cluster: node"),
-		TagSpecifications: []*ec2.TagSpecification{
+		TagSpecifications: []ec2types.TagSpecification{
 			{
-				ResourceType: aws.String("security-group"),
-				Tags: []*ec2.Tag{
+				ResourceType: ec2types.ResourceTypeSecurityGroup,
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String("test-cluster-node"),
@@ -1813,18 +1879,18 @@ func mockedCreateSGCalls(recordLBV2 bool, vpcID string, m *mocks.MockEC2APIMockR
 		},
 	})).
 		Return(&ec2.CreateSecurityGroupOutput{GroupId: aws.String("sg-node")}, nil)
-	m.AuthorizeSecurityGroupIngressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
+	m.AuthorizeSecurityGroupIngress(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
 		GroupId: aws.String("sg-controlplane"),
 	})).
 		Return(&ec2.AuthorizeSecurityGroupIngressOutput{}, nil).
 		After(securityGroupControl).Times(2)
-	m.AuthorizeSecurityGroupIngressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
+	m.AuthorizeSecurityGroupIngress(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
 		GroupId: aws.String("sg-node"),
 	})).
 		Return(&ec2.AuthorizeSecurityGroupIngressOutput{}, nil).
 		After(securityGroupNode).Times(2)
 	if recordLBV2 {
-		m.AuthorizeSecurityGroupIngressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
+		m.AuthorizeSecurityGroupIngress(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
 			GroupId: aws.String("sg-lb"),
 		})).
 			Return(&ec2.AuthorizeSecurityGroupIngressOutput{}, nil).
diff --git a/controllers/awsmachine_controller_test.go b/controllers/awsmachine_controller_test.go
index d9e2cecc2..56aceb61d 100644
--- a/controllers/awsmachine_controller_test.go
+++ b/controllers/awsmachine_controller_test.go
@@ -22,9 +22,10 @@ import (
 	"testing"
 	"time"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	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/golang/mock/gomock"
 	. "github.com/onsi/gomega"
 	"github.com/pkg/errors"
@@ -157,7 +158,7 @@ func TestAWSMachineReconcilerIntegrationTests(t *testing.T) {
 			return elbSvc
 		}
 
-		ec2Mock.EXPECT().AssociateAddressWithContext(context.TODO(), gomock.Any()).MaxTimes(1)
+		ec2Mock.EXPECT().AssociateAddress(context.TODO(), gomock.Any()).MaxTimes(1)
 
 		reconciler.secretsManagerServiceFactory = func(clusterScope cloud.ClusterScoper) services.SecretInterface {
 			return secretMock
@@ -341,7 +342,7 @@ func TestAWSMachineReconcilerIntegrationTests(t *testing.T) {
 			return secretMock
 		}
 
-		ec2Mock.EXPECT().AssociateAddressWithContext(context.TODO(), gomock.Any()).MaxTimes(1)
+		ec2Mock.EXPECT().AssociateAddress(context.TODO(), gomock.Any()).MaxTimes(1)
 
 		_, err = reconciler.reconcileNormal(ctx, ms, cs, cs, cs, cs)
 		g.Expect(err).Should(HaveOccurred())
@@ -358,9 +359,9 @@ func TestAWSMachineReconcilerIntegrationTests(t *testing.T) {
 		expect := func(m *mocks.MockEC2APIMockRecorder, ev2 *mocks.MockELBV2APIMockRecorder, e *mocks.MockELBAPIMockRecorder) {
 			mockedDescribeInstanceCalls(m)
 			mockedDeleteLBCalls(false, ev2, e)
-			m.TerminateInstancesWithContext(context.TODO(),
+			m.TerminateInstances(context.TODO(),
 				gomock.Eq(&ec2.TerminateInstancesInput{
-					InstanceIds: aws.StringSlice([]string{"id-1"}),
+					InstanceIds: []string{"id-1"},
 				}),
 			).
 				Return(nil, errors.New("Failed to delete instance"))
@@ -551,101 +552,101 @@ func mockedCreateSecretCall(s *mock_services.MockSecretInterfaceMockRecorder) {
 }
 
 func mockedCreateInstanceCalls(m *mocks.MockEC2APIMockRecorder) {
-	m.DescribeInstancesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstancesInput{
-		Filters: []*ec2.Filter{
+	m.DescribeInstances(context.TODO(), gomock.Eq(&ec2.DescribeInstancesInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("tag:sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"),
-				Values: aws.StringSlice([]string{"owned"}),
+				Values: []string{"owned"},
 			},
 			{
 				Name:   aws.String("tag:Name"),
-				Values: aws.StringSlice([]string{"test"}),
+				Values: []string{"test"},
 			},
 			{
 				Name:   aws.String("instance-state-name"),
-				Values: aws.StringSlice([]string{"pending", "running"}),
+				Values: []string{"pending", "running"},
 			},
 		},
 	})).Return(&ec2.DescribeInstancesOutput{}, nil)
-	m.DescribeInstanceTypesWithContext(context.TODO(), gomock.Any()).
+	m.DescribeInstanceTypes(context.TODO(), gomock.Any()).
 		Return(&ec2.DescribeInstanceTypesOutput{
-			InstanceTypes: []*ec2.InstanceTypeInfo{
+			InstanceTypes: []ec2types.InstanceTypeInfo{
 				{
-					ProcessorInfo: &ec2.ProcessorInfo{
-						SupportedArchitectures: []*string{
-							aws.String("x86_64"),
+					ProcessorInfo: &ec2types.ProcessorInfo{
+						SupportedArchitectures: []ec2types.ArchitectureType{
+							ec2types.ArchitectureTypeX8664,
 						},
 					},
 				},
 			},
 		}, nil)
-	m.DescribeImagesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeImagesInput{
-		Filters: []*ec2.Filter{
+	m.DescribeImages(context.TODO(), gomock.Eq(&ec2.DescribeImagesInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("owner-id"),
-				Values: aws.StringSlice([]string{"819546954734"}),
+				Values: []string{"819546954734"},
 			},
 			{
 				Name:   aws.String("name"),
-				Values: aws.StringSlice([]string{"capa-ami-ubuntu-24.04-?test-*"}),
+				Values: []string{"capa-ami-ubuntu-24.04-?test-*"},
 			},
 			{
 				Name:   aws.String("architecture"),
-				Values: aws.StringSlice([]string{"x86_64"}),
+				Values: []string{"x86_64"},
 			},
 			{
 				Name:   aws.String("state"),
-				Values: aws.StringSlice([]string{"available"}),
+				Values: []string{"available"},
 			},
 			{
 				Name:   aws.String("virtualization-type"),
-				Values: aws.StringSlice([]string{"hvm"}),
+				Values: []string{"hvm"},
 			},
 		},
-	})).Return(&ec2.DescribeImagesOutput{Images: []*ec2.Image{
+	})).Return(&ec2.DescribeImagesOutput{Images: []ec2types.Image{
 		{
 			ImageId:      aws.String("latest"),
 			CreationDate: aws.String("2019-02-08T17:02:31.000Z"),
 		},
 	}}, nil)
-	m.RunInstancesWithContext(context.TODO(), gomock.Any()).Return(&ec2.Reservation{
-		Instances: []*ec2.Instance{
+	m.RunInstances(context.TODO(), gomock.Any()).Return(&ec2.RunInstancesOutput{
+		Instances: []ec2types.Instance{
 			{
-				State: &ec2.InstanceState{
-					Name: aws.String(ec2.InstanceStateNameRunning),
+				State: &ec2types.InstanceState{
+					Name: ec2types.InstanceStateNameRunning,
 				},
-				IamInstanceProfile: &ec2.IamInstanceProfile{
+				IamInstanceProfile: &ec2types.IamInstanceProfile{
 					Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 				},
 				InstanceId:     aws.String("two"),
-				InstanceType:   aws.String("m5.large"),
+				InstanceType:   ec2types.InstanceTypeM5Large,
 				SubnetId:       aws.String("subnet-1"),
 				ImageId:        aws.String("ami-1"),
 				RootDeviceName: aws.String("device-1"),
-				BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+				BlockDeviceMappings: []ec2types.InstanceBlockDeviceMapping{
 					{
 						DeviceName: aws.String("device-1"),
-						Ebs: &ec2.EbsInstanceBlockDevice{
+						Ebs: &ec2types.EbsInstanceBlockDevice{
 							VolumeId: aws.String("volume-1"),
 						},
 					},
 				},
-				Placement: &ec2.Placement{
+				Placement: &ec2types.Placement{
 					AvailabilityZone: aws.String("us-east-1a"),
 				},
 			},
 		},
 	}, nil)
-	m.DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeNetworkInterfacesInput{Filters: []*ec2.Filter{
+	m.DescribeNetworkInterfaces(context.TODO(), gomock.Eq(&ec2.DescribeNetworkInterfacesInput{Filters: []ec2types.Filter{
 		{
 			Name:   aws.String("attachment.instance-id"),
-			Values: aws.StringSlice([]string{"two"}),
+			Values: []string{"two"},
 		},
 	}})).Return(&ec2.DescribeNetworkInterfacesOutput{
-		NetworkInterfaces: []*ec2.NetworkInterface{
+		NetworkInterfaces: []ec2types.NetworkInterface{
 			{
 				NetworkInterfaceId: aws.String("eni-1"),
-				Groups: []*ec2.GroupIdentifier{
+				Groups: []ec2types.GroupIdentifier{
 					{
 						GroupId: aws.String("3"),
 					},
@@ -653,21 +654,21 @@ func mockedCreateInstanceCalls(m *mocks.MockEC2APIMockRecorder) {
 			},
 		},
 	}, nil).MaxTimes(3)
-	m.DescribeNetworkInterfaceAttributeWithContext(context.TODO(), gomock.Eq(&ec2.DescribeNetworkInterfaceAttributeInput{
+	m.DescribeNetworkInterfaceAttribute(context.TODO(), gomock.Eq(&ec2.DescribeNetworkInterfaceAttributeInput{
 		NetworkInterfaceId: aws.String("eni-1"),
-		Attribute:          aws.String("groupSet"),
-	})).Return(&ec2.DescribeNetworkInterfaceAttributeOutput{Groups: []*ec2.GroupIdentifier{{GroupId: aws.String("3")}}}, nil).MaxTimes(1)
-	m.ModifyNetworkInterfaceAttributeWithContext(context.TODO(), gomock.Any()).AnyTimes()
-	m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{Filters: []*ec2.Filter{
+		Attribute:          ec2types.NetworkInterfaceAttributeGroupSet,
+	})).Return(&ec2.DescribeNetworkInterfaceAttributeOutput{Groups: []ec2types.GroupIdentifier{{GroupId: aws.String("3")}}}, nil).MaxTimes(1)
+	m.ModifyNetworkInterfaceAttribute(context.TODO(), gomock.Any()).AnyTimes()
+	m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{Filters: []ec2types.Filter{
 		{
 			Name:   aws.String("state"),
-			Values: aws.StringSlice([]string{"pending", "available"}),
+			Values: []string{"pending", "available"},
 		},
 		{
 			Name:   aws.String("subnet-id"),
-			Values: aws.StringSlice([]string{"subnet-1"}),
+			Values: []string{"subnet-1"},
 		},
-	}})).Return(&ec2.DescribeSubnetsOutput{Subnets: []*ec2.Subnet{
+	}})).Return(&ec2.DescribeSubnetsOutput{Subnets: []ec2types.Subnet{
 		{
 			SubnetId: aws.String("subnet-1"),
 		},
@@ -675,9 +676,9 @@ func mockedCreateInstanceCalls(m *mocks.MockEC2APIMockRecorder) {
 }
 
 func mockedDescribeInstanceCalls(m *mocks.MockEC2APIMockRecorder) {
-	m.DescribeInstancesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstancesInput{
-		InstanceIds: aws.StringSlice([]string{"myMachine"}),
+	m.DescribeInstances(context.TODO(), gomock.Eq(&ec2.DescribeInstancesInput{
+		InstanceIds: []string{"myMachine"},
 	})).Return(&ec2.DescribeInstancesOutput{
-		Reservations: []*ec2.Reservation{{Instances: []*ec2.Instance{{Placement: &ec2.Placement{AvailabilityZone: aws.String("us-east-1a")}, InstanceId: aws.String("id-1"), State: &ec2.InstanceState{Name: aws.String("id-1"), Code: aws.Int64(16)}}}}},
+		Reservations: []ec2types.Reservation{{Instances: []ec2types.Instance{{Placement: &ec2types.Placement{AvailabilityZone: aws.String("us-east-1a")}, InstanceId: aws.String("id-1"), State: &ec2types.InstanceState{Name: "id-1", Code: aws.Int32(16)}}}}},
 	}, nil)
 }
diff --git a/controllers/awsmachine_controller_unit_test.go b/controllers/awsmachine_controller_unit_test.go
index 099eaebf0..a39a393b1 100644
--- a/controllers/awsmachine_controller_unit_test.go
+++ b/controllers/awsmachine_controller_unit_test.go
@@ -24,8 +24,9 @@ import (
 	"testing"
 	"time"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/golang/mock/gomock"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
@@ -2713,28 +2714,28 @@ func TestAWSMachineReconcilerReconcileDefaultsToLoadBalancerTypeClassic(t *testi
 		return secretMock
 	}
 
-	ec2Mock.EXPECT().DescribeInstancesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstancesInput{
-		InstanceIds: aws.StringSlice([]string{"two"}),
+	ec2Mock.EXPECT().DescribeInstances(context.TODO(), gomock.Eq(&ec2.DescribeInstancesInput{
+		InstanceIds: []string{"two"},
 	})).Return(&ec2.DescribeInstancesOutput{
-		Reservations: []*ec2.Reservation{
+		Reservations: []ec2types.Reservation{
 			{
-				Instances: []*ec2.Instance{
+				Instances: []ec2types.Instance{
 					{
 						InstanceId:   aws.String("two"),
-						InstanceType: aws.String("m5.large"),
+						InstanceType: ec2types.InstanceTypeM5Large,
 						SubnetId:     aws.String("subnet-1"),
 						ImageId:      aws.String("ami-1"),
-						State: &ec2.InstanceState{
-							Name: aws.String(ec2.InstanceStateNameRunning),
+						State: &ec2types.InstanceState{
+							Name: ec2types.InstanceStateNameRunning,
 						},
-						Placement: &ec2.Placement{
+						Placement: &ec2types.Placement{
 							AvailabilityZone: aws.String("thezone"),
 						},
-						MetadataOptions: &ec2.InstanceMetadataOptionsResponse{
-							HttpEndpoint:            aws.String(string(infrav1.InstanceMetadataEndpointStateEnabled)),
-							HttpPutResponseHopLimit: aws.Int64(1),
-							HttpTokens:              aws.String(string(infrav1.HTTPTokensStateOptional)),
-							InstanceMetadataTags:    aws.String(string(infrav1.InstanceMetadataEndpointStateDisabled)),
+						MetadataOptions: &ec2types.InstanceMetadataOptionsResponse{
+							HttpEndpoint:            ec2types.InstanceMetadataEndpointState(string(infrav1.InstanceMetadataEndpointStateEnabled)),
+							HttpPutResponseHopLimit: aws.Int32(1),
+							HttpTokens:              ec2types.HttpTokensState(string(infrav1.HTTPTokensStateOptional)),
+							InstanceMetadataTags:    ec2types.InstanceMetadataTagsState(string(infrav1.InstanceMetadataEndpointStateDisabled)),
 						},
 					},
 				},
@@ -2745,16 +2746,16 @@ func TestAWSMachineReconcilerReconcileDefaultsToLoadBalancerTypeClassic(t *testi
 	// Must attach to a classic LB, not another type. Only these mock calls are therefore expected.
 	mockedCreateLBCalls(t, elbMock.EXPECT(), false)
 
-	ec2Mock.EXPECT().DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeNetworkInterfacesInput{Filters: []*ec2.Filter{
+	ec2Mock.EXPECT().DescribeNetworkInterfaces(context.TODO(), gomock.Eq(&ec2.DescribeNetworkInterfacesInput{Filters: []ec2types.Filter{
 		{
 			Name:   aws.String("attachment.instance-id"),
-			Values: aws.StringSlice([]string{"two"}),
+			Values: []string{"two"},
 		},
 	}})).Return(&ec2.DescribeNetworkInterfacesOutput{
-		NetworkInterfaces: []*ec2.NetworkInterface{
+		NetworkInterfaces: []ec2types.NetworkInterface{
 			{
 				NetworkInterfaceId: aws.String("eni-1"),
-				Groups: []*ec2.GroupIdentifier{
+				Groups: []ec2types.GroupIdentifier{
 					{
 						GroupId: aws.String("3"),
 					},
@@ -2762,12 +2763,12 @@ func TestAWSMachineReconcilerReconcileDefaultsToLoadBalancerTypeClassic(t *testi
 			},
 		},
 	}, nil).MaxTimes(3)
-	ec2Mock.EXPECT().DescribeNetworkInterfaceAttributeWithContext(context.TODO(), gomock.Eq(&ec2.DescribeNetworkInterfaceAttributeInput{
+	ec2Mock.EXPECT().DescribeNetworkInterfaceAttribute(context.TODO(), gomock.Eq(&ec2.DescribeNetworkInterfaceAttributeInput{
 		NetworkInterfaceId: aws.String("eni-1"),
-		Attribute:          aws.String("groupSet"),
-	})).Return(&ec2.DescribeNetworkInterfaceAttributeOutput{Groups: []*ec2.GroupIdentifier{{GroupId: aws.String("3")}}}, nil).MaxTimes(1)
-	ec2Mock.EXPECT().ModifyNetworkInterfaceAttributeWithContext(context.TODO(), gomock.Any()).AnyTimes()
-	ec2Mock.EXPECT().AssociateAddressWithContext(context.TODO(), gomock.Any()).MaxTimes(1)
+		Attribute:          ec2types.NetworkInterfaceAttributeGroupSet,
+	})).Return(&ec2.DescribeNetworkInterfaceAttributeOutput{Groups: []ec2types.GroupIdentifier{{GroupId: aws.String("3")}}}, nil).MaxTimes(1)
+	ec2Mock.EXPECT().ModifyNetworkInterfaceAttribute(context.TODO(), gomock.Any()).AnyTimes()
+	ec2Mock.EXPECT().AssociateAddress(context.TODO(), gomock.Any()).MaxTimes(1)
 
 	_, err = reconciler.Reconcile(ctx, ctrl.Request{
 		NamespacedName: client.ObjectKey{
diff --git a/controlplane/eks/controllers/awsmanagedcontrolplane_controller_test.go b/controlplane/eks/controllers/awsmanagedcontrolplane_controller_test.go
index aaa679e3f..2247b92ea 100644
--- a/controlplane/eks/controllers/awsmanagedcontrolplane_controller_test.go
+++ b/controlplane/eks/controllers/awsmanagedcontrolplane_controller_test.go
@@ -26,12 +26,13 @@ import (
 	"time"
 
 	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go-v2/service/eks"
 	ekstypes "github.com/aws/aws-sdk-go-v2/service/eks/types"
 	"github.com/aws/aws-sdk-go-v2/service/iam"
 	iamtypes "github.com/aws/aws-sdk-go-v2/service/iam/types"
 	stsrequest "github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/aws/aws-sdk-go/service/sts"
 	"github.com/aws/smithy-go"
 	"github.com/golang/mock/gomock"
@@ -248,23 +249,23 @@ func createControllerIdentity(g *WithT) *infrav1.AWSClusterControllerIdentity {
 // mockedCallsForMissingEverything mocks most of the AWSManagedControlPlane reconciliation calls to the AWS API,
 // except for what other functions provide (see `mockedCreateSGCalls` and `mockedDescribeInstanceCall`).
 func mockedCallsForMissingEverything(ec2Rec *mocks.MockEC2APIMockRecorder, subnets infrav1.Subnets) {
-	describeVPCByNameCall := ec2Rec.DescribeVpcsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeVpcsInput{
-		Filters: []*ec2.Filter{
+	describeVPCByNameCall := ec2Rec.DescribeVpcs(context.TODO(), gomock.Eq(&ec2.DescribeVpcsInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("tag:Name"),
-				Values: aws.StringSlice([]string{"test-cluster-vpc"}),
+				Values: []string{"test-cluster-vpc"},
 			},
 		},
 	})).Return(&ec2.DescribeVpcsOutput{
-		Vpcs: []*ec2.Vpc{},
+		Vpcs: []ec2types.Vpc{},
 	}, nil)
 
-	ec2Rec.CreateVpcWithContext(context.TODO(), gomock.Eq(&ec2.CreateVpcInput{
+	ec2Rec.CreateVpc(context.TODO(), gomock.Eq(&ec2.CreateVpcInput{
 		CidrBlock: aws.String("10.0.0.0/8"),
-		TagSpecifications: []*ec2.TagSpecification{
+		TagSpecifications: []ec2types.TagSpecification{
 			{
-				ResourceType: aws.String("vpc"),
-				Tags: []*ec2.Tag{
+				ResourceType: ec2types.ResourceTypeVpc,
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String("test-cluster-vpc"),
@@ -281,11 +282,11 @@ func mockedCallsForMissingEverything(ec2Rec *mocks.MockEC2APIMockRecorder, subne
 			},
 		},
 	})).After(describeVPCByNameCall).Return(&ec2.CreateVpcOutput{
-		Vpc: &ec2.Vpc{
-			State:     aws.String("available"),
+		Vpc: &ec2types.Vpc{
+			State:     ec2types.VpcStateAvailable,
 			VpcId:     aws.String("vpc-new"),
 			CidrBlock: aws.String("10.0.0.0/8"),
-			Tags: []*ec2.Tag{
+			Tags: []ec2types.Tag{
 				{
 					Key:   aws.String("Name"),
 					Value: aws.String("test-cluster-vpc"),
@@ -302,43 +303,43 @@ func mockedCallsForMissingEverything(ec2Rec *mocks.MockEC2APIMockRecorder, subne
 		},
 	}, nil)
 
-	ec2Rec.DescribeVpcAttributeWithContext(context.TODO(), gomock.Eq(&ec2.DescribeVpcAttributeInput{
+	ec2Rec.DescribeVpcAttribute(context.TODO(), gomock.Eq(&ec2.DescribeVpcAttributeInput{
 		VpcId:     aws.String("vpc-new"),
-		Attribute: aws.String("enableDnsHostnames"),
+		Attribute: ec2types.VpcAttributeNameEnableDnsHostnames,
 	})).Return(&ec2.DescribeVpcAttributeOutput{
-		EnableDnsHostnames: &ec2.AttributeBooleanValue{Value: aws.Bool(true)},
+		EnableDnsHostnames: &ec2types.AttributeBooleanValue{Value: aws.Bool(true)},
 	}, nil)
 
-	ec2Rec.DescribeVpcAttributeWithContext(context.TODO(), gomock.Eq(&ec2.DescribeVpcAttributeInput{
+	ec2Rec.DescribeVpcAttribute(context.TODO(), gomock.Eq(&ec2.DescribeVpcAttributeInput{
 		VpcId:     aws.String("vpc-new"),
-		Attribute: aws.String("enableDnsSupport"),
+		Attribute: ec2types.VpcAttributeNameEnableDnsSupport,
 	})).Return(&ec2.DescribeVpcAttributeOutput{
-		EnableDnsSupport: &ec2.AttributeBooleanValue{Value: aws.Bool(true)},
+		EnableDnsSupport: &ec2types.AttributeBooleanValue{Value: aws.Bool(true)},
 	}, nil)
 
-	ec2Rec.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-		Filters: []*ec2.Filter{
+	ec2Rec.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("state"),
-				Values: aws.StringSlice([]string{ec2.VpcStatePending, ec2.VpcStateAvailable}),
+				Values: []string{string(ec2types.VpcStatePending), string(ec2types.VpcStateAvailable)},
 			},
 			{
 				Name:   aws.String("vpc-id"),
-				Values: aws.StringSlice([]string{"vpc-new"}),
+				Values: []string{"vpc-new"},
 			},
 		},
 	})).Return(&ec2.DescribeSubnetsOutput{
-		Subnets: []*ec2.Subnet{},
+		Subnets: []ec2types.Subnet{},
 	}, nil)
 
-	zones := []*ec2.AvailabilityZone{}
+	zones := []ec2types.AvailabilityZone{}
 	for _, subnet := range subnets {
-		zones = append(zones, &ec2.AvailabilityZone{
+		zones = append(zones, ec2types.AvailabilityZone{
 			ZoneName: aws.String(subnet.AvailabilityZone),
 			ZoneType: aws.String("availability-zone"),
 		})
 	}
-	ec2Rec.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+	ec2Rec.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 		Return(&ec2.DescribeAvailabilityZonesOutput{
 			AvailabilityZones: zones,
 		}, nil).MaxTimes(2)
@@ -354,25 +355,25 @@ func mockedCallsForMissingEverything(ec2Rec *mocks.MockEC2APIMockRecorder, subne
 			kubernetesRoleTagKey = "kubernetes.io/role/internal-elb"
 			capaRoleTagValue = "private"
 		}
-		ec2Rec.DescribeAvailabilityZonesWithContext(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
-			ZoneNames: aws.StringSlice([]string{subnet.AvailabilityZone}),
+		ec2Rec.DescribeAvailabilityZones(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
+			ZoneNames: []string{subnet.AvailabilityZone},
 		}).
 			Return(&ec2.DescribeAvailabilityZonesOutput{
-				AvailabilityZones: []*ec2.AvailabilityZone{
+				AvailabilityZones: []ec2types.AvailabilityZone{
 					{
 						ZoneName: aws.String(subnet.AvailabilityZone),
 						ZoneType: aws.String("availability-zone"),
 					},
 				},
 			}, nil).MaxTimes(1)
-		ec2Rec.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+		ec2Rec.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 			VpcId:            aws.String("vpc-new"),
 			CidrBlock:        aws.String(subnet.CidrBlock),
 			AvailabilityZone: aws.String(subnet.AvailabilityZone),
-			TagSpecifications: []*ec2.TagSpecification{
+			TagSpecifications: []ec2types.TagSpecification{
 				{
-					ResourceType: aws.String("subnet"),
-					Tags: []*ec2.Tag{
+					ResourceType: ec2types.ResourceTypeSubnet,
+					Tags: []ec2types.Tag{
 						{
 							Key: aws.String("Name"),
 							// Assume that `ID` doesn't start with `subnet-` so that it becomes managed and `ID` denotes the desired name
@@ -398,13 +399,13 @@ func mockedCallsForMissingEverything(ec2Rec *mocks.MockEC2APIMockRecorder, subne
 				},
 			},
 		})).Return(&ec2.CreateSubnetOutput{
-			Subnet: &ec2.Subnet{
+			Subnet: &ec2types.Subnet{
 				VpcId:               aws.String("vpc-new"),
 				SubnetId:            aws.String(subnetID),
 				CidrBlock:           aws.String(subnet.CidrBlock),
 				AvailabilityZone:    aws.String(subnet.AvailabilityZone),
 				MapPublicIpOnLaunch: aws.Bool(false),
-				Tags: []*ec2.Tag{
+				Tags: []ec2types.Tag{
 					{
 						Key: aws.String("Name"),
 						// Assume that `ID` doesn't start with `subnet-` so that it becomes managed and `ID` denotes the desired name
@@ -430,34 +431,45 @@ func mockedCallsForMissingEverything(ec2Rec *mocks.MockEC2APIMockRecorder, subne
 			},
 		}, nil)
 
-		ec2Rec.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-			SubnetIds: aws.StringSlice([]string{subnetID}),
-		})).Return(nil)
+		ec2Rec.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+			SubnetIds: []string{subnetID},
+		}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+			Subnets: []ec2types.Subnet{
+				{
+					VpcId:               aws.String("vpc-new"),
+					SubnetId:            aws.String(subnetID),
+					CidrBlock:           aws.String(subnet.CidrBlock),
+					AvailabilityZone:    aws.String(subnet.AvailabilityZone),
+					MapPublicIpOnLaunch: aws.Bool(false),
+					State:               ec2types.SubnetStateAvailable,
+				},
+			},
+		}, nil)
 
 		if subnet.IsPublic {
-			ec2Rec.ModifySubnetAttributeWithContext(context.TODO(), gomock.Eq(&ec2.ModifySubnetAttributeInput{
+			ec2Rec.ModifySubnetAttribute(context.TODO(), gomock.Eq(&ec2.ModifySubnetAttributeInput{
 				SubnetId: aws.String(subnetID),
-				MapPublicIpOnLaunch: &ec2.AttributeBooleanValue{
+				MapPublicIpOnLaunch: &ec2types.AttributeBooleanValue{
 					Value: aws.Bool(true),
 				},
 			})).Return(&ec2.ModifySubnetAttributeOutput{}, nil)
 		}
 	}
 
-	ec2Rec.DescribeRouteTablesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeRouteTablesInput{
-		Filters: []*ec2.Filter{
+	ec2Rec.DescribeRouteTables(context.TODO(), gomock.Eq(&ec2.DescribeRouteTablesInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("vpc-id"),
-				Values: aws.StringSlice([]string{"vpc-new"}),
+				Values: []string{"vpc-new"},
 			},
 			{
 				Name:   aws.String("tag-key"),
-				Values: aws.StringSlice([]string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"}),
+				Values: []string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"},
 			},
 		}})).Return(&ec2.DescribeRouteTablesOutput{
-		RouteTables: []*ec2.RouteTable{
+		RouteTables: []ec2types.RouteTable{
 			{
-				Routes: []*ec2.Route{
+				Routes: []ec2types.Route{
 					{
 						GatewayId: aws.String("igw-12345"),
 					},
@@ -466,22 +478,22 @@ func mockedCallsForMissingEverything(ec2Rec *mocks.MockEC2APIMockRecorder, subne
 		},
 	}, nil).MinTimes(1).MaxTimes(2)
 
-	ec2Rec.DescribeInternetGatewaysWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInternetGatewaysInput{
-		Filters: []*ec2.Filter{
+	ec2Rec.DescribeInternetGateways(context.TODO(), gomock.Eq(&ec2.DescribeInternetGatewaysInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("attachment.vpc-id"),
-				Values: aws.StringSlice([]string{"vpc-new"}),
+				Values: []string{"vpc-new"},
 			},
 		},
 	})).Return(&ec2.DescribeInternetGatewaysOutput{
-		InternetGateways: []*ec2.InternetGateway{},
+		InternetGateways: []ec2types.InternetGateway{},
 	}, nil)
 
-	ec2Rec.CreateInternetGatewayWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateInternetGatewayInput{})).
+	ec2Rec.CreateInternetGateway(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateInternetGatewayInput{})).
 		Return(&ec2.CreateInternetGatewayOutput{
-			InternetGateway: &ec2.InternetGateway{
+			InternetGateway: &ec2types.InternetGateway{
 				InternetGatewayId: aws.String("igw-1"),
-				Tags: []*ec2.Tag{
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String(infrav1.ClusterTagKey("test-cluster")),
 						Value: aws.String("owned"),
@@ -498,37 +510,37 @@ func mockedCallsForMissingEverything(ec2Rec *mocks.MockEC2APIMockRecorder, subne
 			},
 		}, nil)
 
-	ec2Rec.AttachInternetGatewayWithContext(context.TODO(), gomock.Eq(&ec2.AttachInternetGatewayInput{
+	ec2Rec.AttachInternetGateway(context.TODO(), gomock.Eq(&ec2.AttachInternetGatewayInput{
 		InternetGatewayId: aws.String("igw-1"),
 		VpcId:             aws.String("vpc-new"),
 	})).
 		Return(&ec2.AttachInternetGatewayOutput{}, nil)
 
-	ec2Rec.DescribeNatGatewaysPagesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
-		Filter: []*ec2.Filter{
+	ec2Rec.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+		Filter: []ec2types.Filter{
 			{
 				Name:   aws.String("vpc-id"),
-				Values: []*string{aws.String("vpc-new")},
+				Values: []string{"vpc-new"},
 			},
 			{
 				Name:   aws.String("state"),
-				Values: aws.StringSlice([]string{ec2.VpcStatePending, ec2.VpcStateAvailable}),
+				Values: []string{string(ec2types.VpcStatePending), string(ec2types.VpcStateAvailable)},
 			},
-		}}), gomock.Any()).Return(nil).MinTimes(1).MaxTimes(2)
+		}}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil).MinTimes(1).MaxTimes(2)
 
-	ec2Rec.DescribeAddressesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeAddressesInput{
-		Filters: []*ec2.Filter{
+	ec2Rec.DescribeAddresses(context.TODO(), gomock.Eq(&ec2.DescribeAddressesInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("tag-key"),
-				Values: aws.StringSlice([]string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"}),
+				Values: []string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"},
 			},
 			{
 				Name:   aws.String("tag:sigs.k8s.io/cluster-api-provider-aws/role"),
-				Values: aws.StringSlice([]string{"common"}),
+				Values: []string{"common"},
 			},
 		},
 	})).Return(&ec2.DescribeAddressesOutput{
-		Addresses: []*ec2.Address{},
+		Addresses: []ec2types.Address{},
 	}, nil)
 
 	for subnetIndex, subnet := range subnets {
@@ -539,12 +551,12 @@ func mockedCallsForMissingEverything(ec2Rec *mocks.MockEC2APIMockRecorder, subne
 			eipAllocationID := strconv.Itoa(1234 + subnetIndex)
 			natGatewayID := fmt.Sprintf("nat-%d", subnetIndex+1)
 
-			ec2Rec.AllocateAddressWithContext(context.TODO(), gomock.Eq(&ec2.AllocateAddressInput{
-				Domain: aws.String("vpc"),
-				TagSpecifications: []*ec2.TagSpecification{
+			ec2Rec.AllocateAddress(context.TODO(), gomock.Eq(&ec2.AllocateAddressInput{
+				Domain: ec2types.DomainTypeVpc,
+				TagSpecifications: []ec2types.TagSpecification{
 					{
-						ResourceType: aws.String("elastic-ip"),
-						Tags: []*ec2.Tag{
+						ResourceType: ec2types.ResourceTypeElasticIp,
+						Tags: []ec2types.Tag{
 							{
 								Key:   aws.String("Name"),
 								Value: aws.String("test-cluster-eip-common"),
@@ -564,13 +576,13 @@ func mockedCallsForMissingEverything(ec2Rec *mocks.MockEC2APIMockRecorder, subne
 				AllocationId: aws.String(eipAllocationID),
 			}, nil)
 
-			ec2Rec.CreateNatGatewayWithContext(context.TODO(), gomock.Eq(&ec2.CreateNatGatewayInput{
+			ec2Rec.CreateNatGateway(context.TODO(), gomock.Eq(&ec2.CreateNatGatewayInput{
 				AllocationId: aws.String(eipAllocationID),
 				SubnetId:     aws.String(subnetID),
-				TagSpecifications: []*ec2.TagSpecification{
+				TagSpecifications: []ec2types.TagSpecification{
 					{
-						ResourceType: aws.String("natgateway"),
-						Tags: []*ec2.Tag{
+						ResourceType: ec2types.ResourceTypeNatgateway,
+						Tags: []ec2types.Tag{
 							{
 								Key:   aws.String("Name"),
 								Value: aws.String("test-cluster-nat"),
@@ -587,15 +599,23 @@ func mockedCallsForMissingEverything(ec2Rec *mocks.MockEC2APIMockRecorder, subne
 					},
 				},
 			})).Return(&ec2.CreateNatGatewayOutput{
-				NatGateway: &ec2.NatGateway{
+				NatGateway: &ec2types.NatGateway{
 					NatGatewayId: aws.String(natGatewayID),
 					SubnetId:     aws.String(subnetID),
 				},
 			}, nil)
 
-			ec2Rec.WaitUntilNatGatewayAvailableWithContext(context.TODO(), &ec2.DescribeNatGatewaysInput{
-				NatGatewayIds: []*string{aws.String(natGatewayID)},
-			}).Return(nil)
+			ec2Rec.DescribeNatGateways(gomock.Any(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+				NatGatewayIds: []string{natGatewayID},
+			}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{
+				NatGateways: []ec2types.NatGateway{
+					{
+						NatGatewayId: aws.String(natGatewayID),
+						SubnetId:     aws.String(subnetID),
+						State:        ec2types.NatGatewayStateAvailable,
+					},
+				},
+			}, nil)
 		}
 
 		routeTableID := fmt.Sprintf("rtb-%d", subnetIndex+1)
@@ -605,11 +625,11 @@ func mockedCallsForMissingEverything(ec2Rec *mocks.MockEC2APIMockRecorder, subne
 		} else {
 			routeTablePublicPrivate = "private"
 		}
-		ec2Rec.CreateRouteTableWithContext(context.TODO(), gomock.Eq(&ec2.CreateRouteTableInput{
-			TagSpecifications: []*ec2.TagSpecification{
+		ec2Rec.CreateRouteTable(context.TODO(), gomock.Eq(&ec2.CreateRouteTableInput{
+			TagSpecifications: []ec2types.TagSpecification{
 				{
-					ResourceType: aws.String("route-table"),
-					Tags: []*ec2.Tag{
+					ResourceType: ec2types.ResourceTypeRouteTable,
+					Tags: []ec2types.Tag{
 						{
 							Key:   aws.String("Name"),
 							Value: aws.String(fmt.Sprintf("test-cluster-rt-%s-%s", routeTablePublicPrivate, subnet.AvailabilityZone)),
@@ -631,13 +651,13 @@ func mockedCallsForMissingEverything(ec2Rec *mocks.MockEC2APIMockRecorder, subne
 			},
 			VpcId: aws.String("vpc-new"),
 		})).Return(&ec2.CreateRouteTableOutput{
-			RouteTable: &ec2.RouteTable{
+			RouteTable: &ec2types.RouteTable{
 				RouteTableId: aws.String(routeTableID),
 			},
 		}, nil)
 
 		if subnet.IsPublic {
-			ec2Rec.CreateRouteWithContext(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
+			ec2Rec.CreateRoute(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
 				DestinationCidrBlock: aws.String("0.0.0.0/0"),
 				GatewayId:            aws.String("igw-1"),
 				RouteTableId:         aws.String(routeTableID),
@@ -654,14 +674,14 @@ func mockedCallsForMissingEverything(ec2Rec *mocks.MockEC2APIMockRecorder, subne
 			if natGatewayID == "" {
 				panic("Could not find NAT gateway from public subnet of same AZ")
 			}
-			ec2Rec.CreateRouteWithContext(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
+			ec2Rec.CreateRoute(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
 				DestinationCidrBlock: aws.String("0.0.0.0/0"),
 				NatGatewayId:         aws.String(natGatewayID),
 				RouteTableId:         aws.String(routeTableID),
 			})).Return(&ec2.CreateRouteOutput{}, nil)
 		}
 
-		ec2Rec.AssociateRouteTableWithContext(context.TODO(), gomock.Eq(&ec2.AssociateRouteTableInput{
+		ec2Rec.AssociateRouteTable(context.TODO(), gomock.Eq(&ec2.AssociateRouteTableInput{
 			RouteTableId: aws.String(routeTableID),
 			SubnetId:     aws.String(subnetID),
 		})).Return(&ec2.AssociateRouteTableOutput{}, nil)
@@ -669,34 +689,34 @@ func mockedCallsForMissingEverything(ec2Rec *mocks.MockEC2APIMockRecorder, subne
 }
 
 func mockedCreateSGCalls(ec2Rec *mocks.MockEC2APIMockRecorder) {
-	ec2Rec.DescribeSecurityGroupsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSecurityGroupsInput{
-		Filters: []*ec2.Filter{
+	ec2Rec.DescribeSecurityGroups(context.TODO(), gomock.Eq(&ec2.DescribeSecurityGroupsInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("vpc-id"),
-				Values: aws.StringSlice([]string{"vpc-new"}),
+				Values: []string{"vpc-new"},
 			},
 			{
 				Name:   aws.String("tag-key"),
-				Values: aws.StringSlice([]string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"}),
+				Values: []string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"},
 			},
 		},
 	})).Return(
 		&ec2.DescribeSecurityGroupsOutput{
-			SecurityGroups: []*ec2.SecurityGroup{
+			SecurityGroups: []ec2types.SecurityGroup{
 				{
 					GroupId:   aws.String("1"),
 					GroupName: aws.String("test-sg"),
 				},
 			},
 		}, nil)
-	securityGroupAdditionalCall := ec2Rec.CreateSecurityGroupWithContext(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
+	securityGroupAdditionalCall := ec2Rec.CreateSecurityGroup(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
 		VpcId:       aws.String("vpc-new"),
 		GroupName:   aws.String("test-cluster-node-eks-additional"),
 		Description: aws.String("Kubernetes cluster test-cluster: node-eks-additional"),
-		TagSpecifications: []*ec2.TagSpecification{
+		TagSpecifications: []ec2types.TagSpecification{
 			{
-				ResourceType: aws.String("security-group"),
-				Tags: []*ec2.Tag{
+				ResourceType: ec2types.ResourceTypeSecurityGroup,
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String("test-cluster-node-eks-additional"),
@@ -714,14 +734,14 @@ func mockedCreateSGCalls(ec2Rec *mocks.MockEC2APIMockRecorder) {
 		},
 	})).
 		Return(&ec2.CreateSecurityGroupOutput{GroupId: aws.String("sg-node-eks-additional")}, nil)
-	ec2Rec.CreateSecurityGroupWithContext(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
+	ec2Rec.CreateSecurityGroup(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
 		VpcId:       aws.String("vpc-new"),
 		GroupName:   aws.String("test-cluster-bastion"),
 		Description: aws.String("Kubernetes cluster test-cluster: bastion"),
-		TagSpecifications: []*ec2.TagSpecification{
+		TagSpecifications: []ec2types.TagSpecification{
 			{
-				ResourceType: aws.String("security-group"),
-				Tags: []*ec2.Tag{
+				ResourceType: ec2types.ResourceTypeSecurityGroup,
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String("test-cluster-bastion"),
@@ -739,7 +759,7 @@ func mockedCreateSGCalls(ec2Rec *mocks.MockEC2APIMockRecorder) {
 		},
 	})).
 		Return(&ec2.CreateSecurityGroupOutput{GroupId: aws.String("sg-bastion")}, nil)
-	ec2Rec.AuthorizeSecurityGroupIngressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
+	ec2Rec.AuthorizeSecurityGroupIngress(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
 		GroupId: aws.String("sg-node-eks-additional"),
 	})).
 		Return(&ec2.AuthorizeSecurityGroupIngressOutput{}, nil).
@@ -747,47 +767,47 @@ func mockedCreateSGCalls(ec2Rec *mocks.MockEC2APIMockRecorder) {
 }
 
 func mockedDescribeInstanceCall(ec2Rec *mocks.MockEC2APIMockRecorder) {
-	ec2Rec.DescribeInstancesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstancesInput{
-		Filters: []*ec2.Filter{
+	ec2Rec.DescribeInstances(context.TODO(), gomock.Eq(&ec2.DescribeInstancesInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("tag:sigs.k8s.io/cluster-api-provider-aws/role"),
-				Values: aws.StringSlice([]string{"bastion"}),
+				Values: []string{"bastion"},
 			},
 			{
 				Name:   aws.String("tag-key"),
-				Values: aws.StringSlice([]string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"}),
+				Values: []string{"sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"},
 			},
 			{
 				Name:   aws.String("instance-state-name"),
-				Values: aws.StringSlice([]string{"pending", "running", "stopping", "stopped"}),
+				Values: []string{"pending", "running", "stopping", "stopped"},
 			},
 		},
 	})).Return(&ec2.DescribeInstancesOutput{
-		Reservations: []*ec2.Reservation{
+		Reservations: []ec2types.Reservation{
 			{
-				Instances: []*ec2.Instance{
+				Instances: []ec2types.Instance{
 					{
 						InstanceId:   aws.String("id-1"),
-						InstanceType: aws.String("m5.large"),
+						InstanceType: ec2types.InstanceTypeM5Large,
 						SubnetId:     aws.String("subnet-1"),
 						ImageId:      aws.String("ami-1"),
-						IamInstanceProfile: &ec2.IamInstanceProfile{
+						IamInstanceProfile: &ec2types.IamInstanceProfile{
 							Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 						},
-						State: &ec2.InstanceState{
-							Code: aws.Int64(16),
-							Name: aws.String(ec2.StateAvailable),
+						State: &ec2types.InstanceState{
+							Code: aws.Int32(16),
+							Name: ec2types.InstanceStateNameRunning,
 						},
 						RootDeviceName: aws.String("device-1"),
-						BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+						BlockDeviceMappings: []ec2types.InstanceBlockDeviceMapping{
 							{
 								DeviceName: aws.String("device-1"),
-								Ebs: &ec2.EbsInstanceBlockDevice{
+								Ebs: &ec2types.EbsInstanceBlockDevice{
 									VolumeId: aws.String("volume-1"),
 								},
 							},
 						},
-						Placement: &ec2.Placement{
+						Placement: &ec2types.Placement{
 							AvailabilityZone: aws.String("us-east-1a"),
 						},
 					},
@@ -907,24 +927,24 @@ func mockedEKSCluster(ctx context.Context, g *WithT, eksRec *mock_eksiface.MockE
 	// AWS precreates a default security group together with the cluster
 	// (https://docs.aws.amazon.com/eks/latest/userguide/sec-group-reqs.html)
 	clusterSgDesc := &ec2.DescribeSecurityGroupsOutput{
-		SecurityGroups: []*ec2.SecurityGroup{
+		SecurityGroups: []ec2types.SecurityGroup{
 			{
 				GroupId:   aws.String("sg-11223344"),
 				GroupName: aws.String("eks-cluster-sg-test-cluster-44556677"),
 			},
 		},
 	}
-	ec2Rec.DescribeSecurityGroupsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSecurityGroupsInput{
-		Filters: []*ec2.Filter{
+	ec2Rec.DescribeSecurityGroups(context.TODO(), gomock.Eq(&ec2.DescribeSecurityGroupsInput{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("tag:aws:eks:cluster-name"),
-				Values: aws.StringSlice([]string{"test-cluster"}),
+				Values: []string{"test-cluster"},
 			},
 		},
 	})).Return(
 		clusterSgDesc, nil)
-	ec2Rec.DescribeSecurityGroupsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSecurityGroupsInput{
-		GroupIds: aws.StringSlice([]string{"eks-cluster-sg-test-cluster-44556677"}),
+	ec2Rec.DescribeSecurityGroups(context.TODO(), gomock.Eq(&ec2.DescribeSecurityGroupsInput{
+		GroupIds: []string{"eks-cluster-sg-test-cluster-44556677"},
 	})).Return(
 		clusterSgDesc, nil)
 
diff --git a/exp/controllers/awsmachinepool_controller_test.go b/exp/controllers/awsmachinepool_controller_test.go
index 616213e2e..71f25c86d 100644
--- a/exp/controllers/awsmachinepool_controller_test.go
+++ b/exp/controllers/awsmachinepool_controller_test.go
@@ -24,9 +24,9 @@ import (
 	"fmt"
 	"testing"
 
+	ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go-v2/service/s3"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/go-logr/logr"
 	"github.com/golang/mock/gomock"
 	. "github.com/onsi/gomega"
@@ -1079,13 +1079,13 @@ func TestAWSMachinePoolReconciler(t *testing.T) {
 
 				var simulatedDeletedVersionNumber int64 = 777
 				bootstrapDataHash := "some-simulated-hash"
-				ec2Svc.EXPECT().PruneLaunchTemplateVersions(gomock.Any()).Return(&ec2.LaunchTemplateVersion{
+				ec2Svc.EXPECT().PruneLaunchTemplateVersions(gomock.Any()).Return(&ec2types.LaunchTemplateVersion{
 					VersionNumber: &simulatedDeletedVersionNumber,
-					LaunchTemplateData: &ec2.ResponseLaunchTemplateData{
-						TagSpecifications: []*ec2.LaunchTemplateTagSpecification{
+					LaunchTemplateData: &ec2types.ResponseLaunchTemplateData{
+						TagSpecifications: []ec2types.LaunchTemplateTagSpecification{
 							{
-								ResourceType: aws.String(ec2.ResourceTypeInstance),
-								Tags: []*ec2.Tag{
+								ResourceType: ec2types.ResourceTypeInstance,
+								Tags: []ec2types.Tag{
 									// Only this tag is relevant for the test. If this is stored in the
 									// launch template version, and the version gets deleted, the S3 object
 									// with the bootstrap data should be deleted as well.
diff --git a/pkg/cloud/services/autoscaling/autoscalinggroup_test.go b/pkg/cloud/services/autoscaling/autoscalinggroup_test.go
index 91660a139..0de5f7ece 100644
--- a/pkg/cloud/services/autoscaling/autoscalinggroup_test.go
+++ b/pkg/cloud/services/autoscaling/autoscalinggroup_test.go
@@ -23,9 +23,10 @@ import (
 
 	"github.com/aws/aws-sdk-go-v2/service/autoscaling"
 	autoscalingtypes "github.com/aws/aws-sdk-go-v2/service/autoscaling/types"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/golang/mock/gomock"
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
@@ -811,8 +812,8 @@ func TestServiceUpdateASGWithSubnetFilters(t *testing.T) {
 				},
 			},
 			expect: func(e *mocks.MockEC2APIMockRecorder, m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				e.DescribeSubnetsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSubnetsInput{})).Return(&ec2.DescribeSubnetsOutput{
-					Subnets: []*ec2.Subnet{{SubnetId: aws.String("subnet-02")}},
+				e.DescribeSubnets(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSubnetsInput{})).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []ec2types.Subnet{{SubnetId: aws.String("subnet-02")}},
 				}, nil)
 				m.UpdateAutoScalingGroup(context.TODO(), gomock.AssignableToTypeOf(&autoscaling.UpdateAutoScalingGroupInput{})).Return(&autoscaling.UpdateAutoScalingGroupOutput{}, nil)
 			},
@@ -832,8 +833,8 @@ func TestServiceUpdateASGWithSubnetFilters(t *testing.T) {
 				},
 			},
 			expect: func(e *mocks.MockEC2APIMockRecorder, m *mock_autoscalingiface.MockAutoScalingAPIMockRecorder) {
-				e.DescribeSubnetsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSubnetsInput{})).Return(&ec2.DescribeSubnetsOutput{
-					Subnets: []*ec2.Subnet{},
+				e.DescribeSubnets(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSubnetsInput{})).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []ec2types.Subnet{},
 				}, nil)
 			},
 		},
diff --git a/pkg/cloud/services/ec2/ami_test.go b/pkg/cloud/services/ec2/ami_test.go
index c84960127..b2e7e831b 100644
--- a/pkg/cloud/services/ec2/ami_test.go
+++ b/pkg/cloud/services/ec2/ami_test.go
@@ -20,10 +20,11 @@ import (
 	"context"
 	"testing"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go-v2/service/ssm"
 	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/golang/mock/gomock"
 	. "github.com/onsi/gomega"
 	"sigs.k8s.io/controller-runtime/pkg/client/fake"
@@ -50,7 +51,7 @@ func TestDefaultAMILookup(t *testing.T) {
 		name   string
 		args   args
 		expect func(m *mocks.MockEC2APIMockRecorder)
-		check  func(g *WithT, img *ec2.Image, err error)
+		check  func(g *WithT, img *ec2types.Image, err error)
 	}{
 		{
 			name: "Should return latest AMI in case of valid inputs",
@@ -62,9 +63,9 @@ func TestDefaultAMILookup(t *testing.T) {
 				amiNameFormat:     "ami-name",
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeImagesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
+				m.DescribeImages(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
 					Return(&ec2.DescribeImagesOutput{
-						Images: []*ec2.Image{
+						Images: []ec2types.Image{
 							{
 								ImageId:      aws.String("ancient"),
 								CreationDate: aws.String("2011-02-08T17:02:31.000Z"),
@@ -80,7 +81,7 @@ func TestDefaultAMILookup(t *testing.T) {
 						},
 					}, nil)
 			},
-			check: func(g *WithT, img *ec2.Image, err error) {
+			check: func(g *WithT, img *ec2types.Image, err error) {
 				g.Expect(err).NotTo(HaveOccurred())
 				g.Expect(*img.ImageId).Should(ContainSubstring("latest"))
 			},
@@ -88,10 +89,10 @@ func TestDefaultAMILookup(t *testing.T) {
 		{
 			name: "Should return with error if AWS DescribeImages call failed with some error",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeImagesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
+				m.DescribeImages(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
 					Return(nil, awserrors.NewFailedDependency("dependency failure"))
 			},
-			check: func(g *WithT, img *ec2.Image, err error) {
+			check: func(g *WithT, img *ec2types.Image, err error) {
 				g.Expect(err).To(HaveOccurred())
 				g.Expect(img).To(BeNil())
 			},
@@ -99,10 +100,10 @@ func TestDefaultAMILookup(t *testing.T) {
 		{
 			name: "Should return with error if empty list of images returned from AWS ",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeImagesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
+				m.DescribeImages(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
 					Return(&ec2.DescribeImagesOutput{}, nil)
 			},
-			check: func(g *WithT, img *ec2.Image, err error) {
+			check: func(g *WithT, img *ec2types.Image, err error) {
 				g.Expect(err).To(HaveOccurred())
 				g.Expect(img).To(BeNil())
 			},
@@ -138,7 +139,7 @@ func TestDefaultAMILookupArm64(t *testing.T) {
 		name   string
 		args   args
 		expect func(m *mocks.MockEC2APIMockRecorder)
-		check  func(g *WithT, img *ec2.Image, err error)
+		check  func(g *WithT, img *ec2types.Image, err error)
 	}{
 		{
 			name: "Should return latest AMI in case of valid inputs",
@@ -150,9 +151,9 @@ func TestDefaultAMILookupArm64(t *testing.T) {
 				amiNameFormat:     "ami-name",
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeImagesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
+				m.DescribeImages(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
 					Return(&ec2.DescribeImagesOutput{
-						Images: []*ec2.Image{
+						Images: []ec2types.Image{
 							{
 								ImageId:      aws.String("ancient"),
 								CreationDate: aws.String("2011-02-08T17:02:31.000Z"),
@@ -168,7 +169,7 @@ func TestDefaultAMILookupArm64(t *testing.T) {
 						},
 					}, nil)
 			},
-			check: func(g *WithT, img *ec2.Image, err error) {
+			check: func(g *WithT, img *ec2types.Image, err error) {
 				g.Expect(err).NotTo(HaveOccurred())
 				g.Expect(*img.ImageId).Should(ContainSubstring("latest"))
 			},
@@ -176,10 +177,10 @@ func TestDefaultAMILookupArm64(t *testing.T) {
 		{
 			name: "Should return with error if AWS DescribeImages call failed with some error",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeImagesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
+				m.DescribeImages(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
 					Return(nil, awserrors.NewFailedDependency("dependency failure"))
 			},
-			check: func(g *WithT, img *ec2.Image, err error) {
+			check: func(g *WithT, img *ec2types.Image, err error) {
 				g.Expect(err).To(HaveOccurred())
 				g.Expect(img).To(BeNil())
 			},
@@ -187,10 +188,10 @@ func TestDefaultAMILookupArm64(t *testing.T) {
 		{
 			name: "Should return with error if empty list of images returned from AWS ",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeImagesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
+				m.DescribeImages(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
 					Return(&ec2.DescribeImagesOutput{}, nil)
 			},
-			check: func(g *WithT, img *ec2.Image, err error) {
+			check: func(g *WithT, img *ec2types.Image, err error) {
 				g.Expect(err).To(HaveOccurred())
 				g.Expect(img).To(BeNil())
 			},
@@ -221,9 +222,9 @@ func TestAMIs(t *testing.T) {
 		{
 			name: "Should return latest AMI in case of valid inputs",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeImagesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
+				m.DescribeImages(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
 					Return(&ec2.DescribeImagesOutput{
-						Images: []*ec2.Image{
+						Images: []ec2types.Image{
 							{
 								ImageId:      aws.String("ancient"),
 								CreationDate: aws.String("2011-02-08T17:02:31.000Z"),
@@ -247,9 +248,9 @@ func TestAMIs(t *testing.T) {
 		{
 			name: "Should return error if invalid creation date passed",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeImagesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
+				m.DescribeImages(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
 					Return(&ec2.DescribeImagesOutput{
-						Images: []*ec2.Image{
+						Images: []ec2types.Image{
 							{
 								ImageId:      aws.String("ancient"),
 								CreationDate: aws.String("2011-02-08T17:02:31.000Z"),
@@ -399,13 +400,13 @@ func TestGenerateAMIName(t *testing.T) {
 func TestGetLatestImage(t *testing.T) {
 	tests := []struct {
 		name    string
-		imgs    []*ec2.Image
-		want    *ec2.Image
+		imgs    []ec2types.Image
+		want    *ec2types.Image
 		wantErr bool
 	}{
 		{
 			name: "Should return image with latest creation date",
-			imgs: []*ec2.Image{
+			imgs: []ec2types.Image{
 				{
 					ImageId:      aws.String("ancient"),
 					CreationDate: aws.String("2011-02-08T17:02:31.000Z"),
@@ -419,7 +420,7 @@ func TestGetLatestImage(t *testing.T) {
 					CreationDate: aws.String("2014-02-08T17:02:31.000Z"),
 				},
 			},
-			want: &ec2.Image{
+			want: &ec2types.Image{
 				ImageId:      aws.String("latest"),
 				CreationDate: aws.String("2019-02-08T17:02:31.000Z"),
 			},
@@ -427,7 +428,7 @@ func TestGetLatestImage(t *testing.T) {
 		},
 		{
 			name: "Should return last image if all images have same creation date",
-			imgs: []*ec2.Image{
+			imgs: []ec2types.Image{
 				{
 					ImageId:      aws.String("image 1"),
 					CreationDate: aws.String("2019-02-08T17:02:31.000Z"),
@@ -441,7 +442,7 @@ func TestGetLatestImage(t *testing.T) {
 					CreationDate: aws.String("2019-02-08T17:02:31.000Z"),
 				},
 			},
-			want: &ec2.Image{
+			want: &ec2types.Image{
 				ImageId:      aws.String("image 3"),
 				CreationDate: aws.String("2019-02-08T17:02:31.000Z"),
 			},
@@ -449,7 +450,7 @@ func TestGetLatestImage(t *testing.T) {
 		},
 		{
 			name: "Should return error if creation date is given in wrong format",
-			imgs: []*ec2.Image{
+			imgs: []ec2types.Image{
 				{
 					ImageId:      aws.String("image 1"),
 					CreationDate: aws.String("2019-02-08"),
diff --git a/pkg/cloud/services/ec2/bastion_test.go b/pkg/cloud/services/ec2/bastion_test.go
index 01b0003d2..511f8a916 100644
--- a/pkg/cloud/services/ec2/bastion_test.go
+++ b/pkg/cloud/services/ec2/bastion_test.go
@@ -21,8 +21,9 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/golang/mock/gomock"
 	. "github.com/onsi/gomega"
 	"github.com/pkg/errors"
@@ -40,28 +41,28 @@ func TestServiceDeleteBastion(t *testing.T) {
 	clusterName := "cluster"
 
 	describeInput := &ec2.DescribeInstancesInput{
-		Filters: []*ec2.Filter{
+		Filters: []types.Filter{
 			filter.EC2.ProviderRole(infrav1.BastionRoleTagValue),
 			filter.EC2.Cluster(clusterName),
 			filter.EC2.InstanceStates(
-				ec2.InstanceStateNamePending,
-				ec2.InstanceStateNameRunning,
-				ec2.InstanceStateNameStopping,
-				ec2.InstanceStateNameStopped,
+				types.InstanceStateNamePending,
+				types.InstanceStateNameRunning,
+				types.InstanceStateNameStopping,
+				types.InstanceStateNameStopped,
 			),
 		},
 	}
 
 	foundOutput := &ec2.DescribeInstancesOutput{
-		Reservations: []*ec2.Reservation{
+		Reservations: []types.Reservation{
 			{
-				Instances: []*ec2.Instance{
+				Instances: []types.Instance{
 					{
 						InstanceId: aws.String("id123"),
-						State: &ec2.InstanceState{
-							Name: aws.String(ec2.InstanceStateNameRunning),
+						State: &types.InstanceState{
+							Name: types.InstanceStateNameRunning,
 						},
-						Placement: &ec2.Placement{
+						Placement: &types.Placement{
 							AvailabilityZone: aws.String("us-east-1"),
 						},
 					},
@@ -80,7 +81,7 @@ func TestServiceDeleteBastion(t *testing.T) {
 			name: "instance not found",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstancesWithContext(context.TODO(), gomock.Eq(describeInput)).
+					DescribeInstances(context.TODO(), gomock.Eq(describeInput)).
 					Return(&ec2.DescribeInstancesOutput{}, nil)
 			},
 			expectError: false,
@@ -89,7 +90,7 @@ func TestServiceDeleteBastion(t *testing.T) {
 			name: "describe error",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstancesWithContext(context.TODO(), gomock.Eq(describeInput)).
+					DescribeInstances(context.TODO(), gomock.Eq(describeInput)).
 					Return(nil, errors.New("some error"))
 			},
 			expectError: true,
@@ -98,12 +99,12 @@ func TestServiceDeleteBastion(t *testing.T) {
 			name: "terminate fails",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstancesWithContext(context.TODO(), gomock.Eq(describeInput)).
+					DescribeInstances(context.TODO(), gomock.Eq(describeInput)).
 					Return(foundOutput, nil)
 				m.
-					TerminateInstancesWithContext(context.TODO(),
+					TerminateInstances(context.TODO(),
 						gomock.Eq(&ec2.TerminateInstancesInput{
-							InstanceIds: aws.StringSlice([]string{"id123"}),
+							InstanceIds: ([]string{"id123"}),
 						}),
 					).
 					Return(nil, errors.New("some error"))
@@ -114,22 +115,44 @@ func TestServiceDeleteBastion(t *testing.T) {
 			name: "wait after terminate fails",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstancesWithContext(context.TODO(), gomock.Eq(describeInput)).
-					Return(foundOutput, nil)
+					DescribeInstances(context.TODO(), gomock.Eq(describeInput)).
+					Return(foundOutput, nil).Times(1)
 				m.
-					TerminateInstancesWithContext(context.TODO(),
+					TerminateInstances(context.TODO(),
 						gomock.Eq(&ec2.TerminateInstancesInput{
-							InstanceIds: aws.StringSlice([]string{"id123"}),
+							InstanceIds: []string{"id123"},
 						}),
 					).
-					Return(nil, nil)
-				m.
-					WaitUntilInstanceTerminatedWithContext(context.TODO(),
-						gomock.Eq(&ec2.DescribeInstancesInput{
-							InstanceIds: aws.StringSlice([]string{"id123"}),
-						}),
-					).
-					Return(errors.New("some error"))
+					Return(&ec2.TerminateInstancesOutput{
+						TerminatingInstances: []types.InstanceStateChange{
+							{
+								InstanceId: aws.String("id123"),
+								CurrentState: &types.InstanceState{
+									Name: types.InstanceStateNameShuttingDown,
+								},
+								PreviousState: &types.InstanceState{
+									Name: types.InstanceStateNameRunning,
+								},
+							},
+						},
+					}, nil)
+				// Simulate an error when waiting for the instance to be terminated by returning a state of "pending" instead of "terminated".
+				m.DescribeInstances(gomock.Any(), gomock.Eq(&ec2.DescribeInstancesInput{
+					InstanceIds: []string{"id123"},
+				}), gomock.Any()).Return(&ec2.DescribeInstancesOutput{
+					Reservations: []types.Reservation{
+						{
+							Instances: []types.Instance{
+								{
+									InstanceId: aws.String("id123"),
+									State: &types.InstanceState{
+										Name: types.InstanceStateNamePending,
+									},
+								},
+							},
+						},
+					},
+				}, nil)
 			},
 			expectError: true,
 		},
@@ -137,22 +160,44 @@ func TestServiceDeleteBastion(t *testing.T) {
 			name: "success",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstancesWithContext(context.TODO(), gomock.Eq(describeInput)).
-					Return(foundOutput, nil)
+					DescribeInstances(context.TODO(), gomock.Eq(describeInput)).
+					Return(foundOutput, nil).Times(1)
 				m.
-					TerminateInstancesWithContext(context.TODO(),
+					TerminateInstances(context.TODO(),
 						gomock.Eq(&ec2.TerminateInstancesInput{
-							InstanceIds: aws.StringSlice([]string{"id123"}),
+							InstanceIds: []string{"id123"},
 						}),
 					).
-					Return(nil, nil)
-				m.
-					WaitUntilInstanceTerminatedWithContext(context.TODO(),
-						gomock.Eq(&ec2.DescribeInstancesInput{
-							InstanceIds: aws.StringSlice([]string{"id123"}),
-						}),
-					).
-					Return(nil)
+					Return(&ec2.TerminateInstancesOutput{
+						TerminatingInstances: []types.InstanceStateChange{
+							{
+								InstanceId: aws.String("id123"),
+								CurrentState: &types.InstanceState{
+									Name: types.InstanceStateNameShuttingDown,
+								},
+								PreviousState: &types.InstanceState{
+									Name: types.InstanceStateNameRunning,
+								},
+							},
+						},
+					}, nil)
+				m.DescribeInstances(gomock.Any(), gomock.Eq(&ec2.DescribeInstancesInput{
+					InstanceIds: []string{"id123"},
+				}), gomock.Any()).
+					Return(&ec2.DescribeInstancesOutput{
+						Reservations: []types.Reservation{
+							{
+								Instances: []types.Instance{
+									{
+										InstanceId: aws.String("id123"),
+										State: &types.InstanceState{
+											Name: types.InstanceStateNameTerminated,
+										},
+									},
+								},
+							},
+						},
+					}, nil)
 			},
 			expectError:   false,
 			bastionStatus: nil,
@@ -228,28 +273,28 @@ func TestServiceReconcileBastion(t *testing.T) {
 	clusterName := "cluster"
 
 	describeInput := &ec2.DescribeInstancesInput{
-		Filters: []*ec2.Filter{
+		Filters: []types.Filter{
 			filter.EC2.ProviderRole(infrav1.BastionRoleTagValue),
 			filter.EC2.Cluster(clusterName),
 			filter.EC2.InstanceStates(
-				ec2.InstanceStateNamePending,
-				ec2.InstanceStateNameRunning,
-				ec2.InstanceStateNameStopping,
-				ec2.InstanceStateNameStopped,
+				types.InstanceStateNamePending,
+				types.InstanceStateNameRunning,
+				types.InstanceStateNameStopping,
+				types.InstanceStateNameStopped,
 			),
 		},
 	}
 
 	foundOutput := &ec2.DescribeInstancesOutput{
-		Reservations: []*ec2.Reservation{
+		Reservations: []types.Reservation{
 			{
-				Instances: []*ec2.Instance{
+				Instances: []types.Instance{
 					{
 						InstanceId: aws.String("id123"),
-						State: &ec2.InstanceState{
-							Name: aws.String(ec2.InstanceStateNameRunning),
+						State: &types.InstanceState{
+							Name: types.InstanceStateNameRunning,
 						},
-						Placement: &ec2.Placement{
+						Placement: &types.Placement{
 							AvailabilityZone: aws.String("us-east-1"),
 						},
 					},
@@ -269,7 +314,7 @@ func TestServiceReconcileBastion(t *testing.T) {
 			name: "Should ignore reconciliation if instance not found",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstancesWithContext(context.TODO(), gomock.Eq(describeInput)).
+					DescribeInstances(context.TODO(), gomock.Eq(describeInput)).
 					Return(&ec2.DescribeInstancesOutput{}, nil)
 			},
 			expectError: false,
@@ -278,7 +323,7 @@ func TestServiceReconcileBastion(t *testing.T) {
 			name: "Should fail reconcile if describe instance fails",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstancesWithContext(context.TODO(), gomock.Eq(describeInput)).
+					DescribeInstances(context.TODO(), gomock.Eq(describeInput)).
 					Return(nil, errors.New("some error"))
 			},
 			expectError: true,
@@ -287,12 +332,12 @@ func TestServiceReconcileBastion(t *testing.T) {
 			name: "Should fail reconcile if terminate instance fails",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstancesWithContext(context.TODO(), gomock.Eq(describeInput)).
+					DescribeInstances(context.TODO(), gomock.Eq(describeInput)).
 					Return(foundOutput, nil).MinTimes(1)
 				m.
-					TerminateInstancesWithContext(context.TODO(),
+					TerminateInstances(context.TODO(),
 						gomock.Eq(&ec2.TerminateInstancesInput{
-							InstanceIds: aws.StringSlice([]string{"id123"}),
+							InstanceIds: []string{"id123"},
 						}),
 					).
 					Return(nil, errors.New("some error"))
@@ -302,28 +347,28 @@ func TestServiceReconcileBastion(t *testing.T) {
 		{
 			name: "Should create bastion successfully",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeInstancesWithContext(context.TODO(), gomock.Eq(describeInput)).
+				m.DescribeInstances(context.TODO(), gomock.Eq(describeInput)).
 					Return(&ec2.DescribeInstancesOutput{}, nil).MinTimes(1)
-				m.DescribeImagesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeImagesInput{Filters: []*ec2.Filter{
+				m.DescribeImages(context.TODO(), gomock.Eq(&ec2.DescribeImagesInput{Filters: []types.Filter{
 					{
 						Name:   aws.String("architecture"),
-						Values: aws.StringSlice([]string{"x86_64"}),
+						Values: []string{"x86_64"},
 					},
 					{
 						Name:   aws.String("state"),
-						Values: aws.StringSlice([]string{"available"}),
+						Values: []string{"available"},
 					},
 					{
 						Name:   aws.String("virtualization-type"),
-						Values: aws.StringSlice([]string{"hvm"}),
+						Values: []string{"hvm"},
 					},
 					{
 						Name:   aws.String("description"),
-						Values: aws.StringSlice([]string{ubuntuImageDescription}),
+						Values: []string{ubuntuImageDescription},
 					},
 					{
 						Name:   aws.String("owner-id"),
-						Values: aws.StringSlice([]string{ubuntuOwnerID}),
+						Values: []string{ubuntuOwnerID},
 					},
 				}})).Return(&ec2.DescribeImagesOutput{Images: images{
 					{
@@ -335,30 +380,30 @@ func TestServiceReconcileBastion(t *testing.T) {
 						CreationDate: aws.String("2014-02-08T17:02:31.000Z"),
 					},
 				}}, nil)
-				m.RunInstancesWithContext(context.TODO(), gomock.Any()).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+				m.RunInstances(context.TODO(), gomock.Any()).
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNameRunning),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNameRunning,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("id123"),
-								InstanceType:   aws.String("t3.micro"),
+								InstanceType:   types.InstanceTypeT3Micro,
 								SubnetId:       aws.String("subnet-1"),
 								ImageId:        aws.String("ubuntu-ami-id-latest"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: aws.String("us-east-1"),
 								},
 							},
@@ -460,28 +505,28 @@ func TestServiceReconcileBastionUSGOV(t *testing.T) {
 	clusterName := "cluster-us-gov"
 
 	describeInput := &ec2.DescribeInstancesInput{
-		Filters: []*ec2.Filter{
+		Filters: []types.Filter{
 			filter.EC2.ProviderRole(infrav1.BastionRoleTagValue),
 			filter.EC2.Cluster(clusterName),
 			filter.EC2.InstanceStates(
-				ec2.InstanceStateNamePending,
-				ec2.InstanceStateNameRunning,
-				ec2.InstanceStateNameStopping,
-				ec2.InstanceStateNameStopped,
+				types.InstanceStateNamePending,
+				types.InstanceStateNameRunning,
+				types.InstanceStateNameStopping,
+				types.InstanceStateNameStopped,
 			),
 		},
 	}
 
 	foundOutput := &ec2.DescribeInstancesOutput{
-		Reservations: []*ec2.Reservation{
+		Reservations: []types.Reservation{
 			{
-				Instances: []*ec2.Instance{
+				Instances: []types.Instance{
 					{
 						InstanceId: aws.String("id123"),
-						State: &ec2.InstanceState{
-							Name: aws.String(ec2.InstanceStateNameRunning),
+						State: &types.InstanceState{
+							Name: types.InstanceStateNameRunning,
 						},
-						Placement: &ec2.Placement{
+						Placement: &types.Placement{
 							AvailabilityZone: aws.String("us-gov-east-1"),
 						},
 					},
@@ -501,7 +546,7 @@ func TestServiceReconcileBastionUSGOV(t *testing.T) {
 			name: "Should ignore reconciliation if instance not found",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstancesWithContext(context.TODO(), gomock.Eq(describeInput)).
+					DescribeInstances(context.TODO(), gomock.Eq(describeInput)).
 					Return(&ec2.DescribeInstancesOutput{}, nil)
 			},
 			expectError: false,
@@ -510,7 +555,7 @@ func TestServiceReconcileBastionUSGOV(t *testing.T) {
 			name: "Should fail reconcile if describe instance fails",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstancesWithContext(context.TODO(), gomock.Eq(describeInput)).
+					DescribeInstances(context.TODO(), gomock.Eq(describeInput)).
 					Return(nil, errors.New("some error"))
 			},
 			expectError: true,
@@ -519,12 +564,12 @@ func TestServiceReconcileBastionUSGOV(t *testing.T) {
 			name: "Should fail reconcile if terminate instance fails",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstancesWithContext(context.TODO(), gomock.Eq(describeInput)).
+					DescribeInstances(context.TODO(), gomock.Eq(describeInput)).
 					Return(foundOutput, nil).MinTimes(1)
 				m.
-					TerminateInstancesWithContext(context.TODO(),
+					TerminateInstances(context.TODO(),
 						gomock.Eq(&ec2.TerminateInstancesInput{
-							InstanceIds: aws.StringSlice([]string{"id123"}),
+							InstanceIds: []string{"id123"},
 						}),
 					).
 					Return(nil, errors.New("some error"))
@@ -534,28 +579,28 @@ func TestServiceReconcileBastionUSGOV(t *testing.T) {
 		{
 			name: "Should create bastion successfully",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeInstancesWithContext(context.TODO(), gomock.Eq(describeInput)).
+				m.DescribeInstances(context.TODO(), gomock.Eq(describeInput)).
 					Return(&ec2.DescribeInstancesOutput{}, nil).MinTimes(1)
-				m.DescribeImagesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeImagesInput{Filters: []*ec2.Filter{
+				m.DescribeImages(context.TODO(), gomock.Eq(&ec2.DescribeImagesInput{Filters: []types.Filter{
 					{
 						Name:   aws.String("architecture"),
-						Values: aws.StringSlice([]string{"x86_64"}),
+						Values: []string{"x86_64"},
 					},
 					{
 						Name:   aws.String("state"),
-						Values: aws.StringSlice([]string{"available"}),
+						Values: []string{"available"},
 					},
 					{
 						Name:   aws.String("virtualization-type"),
-						Values: aws.StringSlice([]string{"hvm"}),
+						Values: []string{"hvm"},
 					},
 					{
 						Name:   aws.String("description"),
-						Values: aws.StringSlice([]string{ubuntuImageDescription}),
+						Values: []string{ubuntuImageDescription},
 					},
 					{
 						Name:   aws.String("owner-id"),
-						Values: aws.StringSlice([]string{ubuntuOwnerIDUsGov}),
+						Values: []string{ubuntuOwnerIDUsGov},
 					},
 				}})).Return(&ec2.DescribeImagesOutput{Images: images{
 					{
@@ -567,30 +612,30 @@ func TestServiceReconcileBastionUSGOV(t *testing.T) {
 						CreationDate: aws.String("2014-02-08T17:02:31.000Z"),
 					},
 				}}, nil)
-				m.RunInstancesWithContext(context.TODO(), gomock.Any()).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+				m.RunInstances(context.TODO(), gomock.Any()).
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNameRunning),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNameRunning,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws-us-gov:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("id123"),
-								InstanceType:   aws.String("t3.micro"),
+								InstanceType:   types.InstanceTypeT3Micro,
 								SubnetId:       aws.String("subnet-1"),
 								ImageId:        aws.String("ubuntu-ami-id-latest"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: aws.String("us-gov-east-1"),
 								},
 							},
diff --git a/pkg/cloud/services/ec2/helper_test.go b/pkg/cloud/services/ec2/helper_test.go
index eb296f85b..2184e12bf 100644
--- a/pkg/cloud/services/ec2/helper_test.go
+++ b/pkg/cloud/services/ec2/helper_test.go
@@ -19,8 +19,8 @@ package ec2
 import (
 	"sort"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -100,8 +100,8 @@ func newAWSCapacityBlockMachinePool() *expinfrav1.AWSMachinePool {
 	}
 }
 
-func defaultEC2Tags(name, clusterName string) []*ec2.Tag {
-	return []*ec2.Tag{
+func defaultEC2Tags(name, clusterName string) []types.Tag {
+	return []types.Tag{
 		{
 			Key:   aws.String("Name"),
 			Value: aws.String(name),
@@ -222,7 +222,7 @@ func newMachinePool() *v1beta1.MachinePool {
 	}
 }
 
-func sortTags(a []*ec2.Tag) {
+func sortTags(a []types.Tag) {
 	sort.Slice(a, func(i, j int) bool {
 		return *(a[i].Key) < *(a[j].Key)
 	})
diff --git a/pkg/cloud/services/ec2/instances_test.go b/pkg/cloud/services/ec2/instances_test.go
index 838cfb740..dfc080d5c 100644
--- a/pkg/cloud/services/ec2/instances_test.go
+++ b/pkg/cloud/services/ec2/instances_test.go
@@ -22,12 +22,14 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/golang/mock/gomock"
 	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
 	. "github.com/onsi/gomega"
 	"github.com/pkg/errors"
 	corev1 "k8s.io/api/core/v1"
@@ -59,8 +61,8 @@ func TestInstanceIfExists(t *testing.T) {
 			name:       "does not exist",
 			instanceID: "hello",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeInstancesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstancesInput{
-					InstanceIds: []*string{aws.String("hello")},
+				m.DescribeInstances(context.TODO(), gomock.Eq(&ec2.DescribeInstancesInput{
+					InstanceIds: []string{"hello"},
 				})).
 					Return(nil, awserrors.NewNotFound("not found"))
 			},
@@ -78,8 +80,8 @@ func TestInstanceIfExists(t *testing.T) {
 			name:       "does not exist with bad request error",
 			instanceID: "hello-does-not-exist",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeInstancesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstancesInput{
-					InstanceIds: []*string{aws.String("hello-does-not-exist")},
+				m.DescribeInstances(context.TODO(), gomock.Eq(&ec2.DescribeInstancesInput{
+					InstanceIds: []string{"hello-does-not-exist"},
 				})).
 					Return(nil, awserr.New(awserrors.InvalidInstanceID, "does not exist", nil))
 			},
@@ -98,35 +100,35 @@ func TestInstanceIfExists(t *testing.T) {
 			instanceID: "id-1",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				az := "test-zone-1a"
-				m.DescribeInstancesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstancesInput{
-					InstanceIds: []*string{aws.String("id-1")},
+				m.DescribeInstances(context.TODO(), gomock.Eq(&ec2.DescribeInstancesInput{
+					InstanceIds: []string{"id-1"},
 				})).
 					Return(&ec2.DescribeInstancesOutput{
-						Reservations: []*ec2.Reservation{
+						Reservations: []types.Reservation{
 							{
-								Instances: []*ec2.Instance{
+								Instances: []types.Instance{
 									{
 										InstanceId:   aws.String("id-1"),
-										InstanceType: aws.String("m5.large"),
+										InstanceType: types.InstanceTypeM5Large,
 										SubnetId:     aws.String("subnet-1"),
 										ImageId:      aws.String("ami-1"),
-										IamInstanceProfile: &ec2.IamInstanceProfile{
+										IamInstanceProfile: &types.IamInstanceProfile{
 											Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 										},
-										State: &ec2.InstanceState{
-											Code: aws.Int64(16),
-											Name: aws.String(ec2.StateAvailable),
+										State: &types.InstanceState{
+											Code: aws.Int32(16),
+											Name: types.InstanceStateNameRunning,
 										},
 										RootDeviceName: aws.String("device-1"),
-										BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+										BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 											{
 												DeviceName: aws.String("device-1"),
-												Ebs: &ec2.EbsInstanceBlockDevice{
+												Ebs: &types.EbsInstanceBlockDevice{
 													VolumeId: aws.String("volume-1"),
 												},
 											},
 										},
-										Placement: &ec2.Placement{
+										Placement: &types.Placement{
 											AvailabilityZone: &az,
 										},
 									},
@@ -153,8 +155,8 @@ func TestInstanceIfExists(t *testing.T) {
 			name:       "error describing instances",
 			instanceID: "one",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeInstancesWithContext(context.TODO(), &ec2.DescribeInstancesInput{
-					InstanceIds: []*string{aws.String("one")},
+				m.DescribeInstances(context.TODO(), &ec2.DescribeInstancesInput{
+					InstanceIds: []string{"one"},
 				}).
 					Return(nil, errors.New("some unknown error"))
 			},
@@ -219,8 +221,8 @@ func TestTerminateInstance(t *testing.T) {
 			name:       "instance exists",
 			instanceID: "i-exist",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.TerminateInstancesWithContext(context.TODO(), gomock.Eq(&ec2.TerminateInstancesInput{
-					InstanceIds: []*string{aws.String("i-exist")},
+				m.TerminateInstances(context.TODO(), gomock.Eq(&ec2.TerminateInstancesInput{
+					InstanceIds: []string{"i-exist"},
 				})).
 					Return(&ec2.TerminateInstancesOutput{}, nil)
 			},
@@ -234,8 +236,8 @@ func TestTerminateInstance(t *testing.T) {
 			name:       "instance does not exist",
 			instanceID: "i-donotexist",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.TerminateInstancesWithContext(context.TODO(), gomock.Eq(&ec2.TerminateInstancesInput{
-					InstanceIds: []*string{aws.String("i-donotexist")},
+				m.TerminateInstances(context.TODO(), gomock.Eq(&ec2.TerminateInstancesInput{
+					InstanceIds: []string{"i-donotexist"},
 				})).
 					Return(&ec2.TerminateInstancesOutput{}, instanceNotFoundError)
 			},
@@ -285,7 +287,7 @@ func TestCreateInstance(t *testing.T) {
 	}
 
 	az := "test-zone-1a"
-	tenancy := "dedicated"
+	tenancy := types.TenancyDedicated
 
 	data := []byte("userData")
 
@@ -362,56 +364,56 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m. // TODO: Restore these parameters, but with the tags as well
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+					RunInstances(context.TODO(), gomock.Any()).
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNamePending),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNamePending,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("two"),
-								InstanceType:   aws.String("m5.large"),
+								InstanceType:   types.InstanceTypeM5Large,
 								SubnetId:       aws.String("subnet-1"),
 								ImageId:        aws.String("ami-1"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: &az,
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -492,56 +494,56 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.2xlarge"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM52xlarge,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m.
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+					RunInstances(context.TODO(), gomock.Any()).
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNamePending),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNamePending,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("two"),
-								InstanceType:   aws.String("m5.large"),
+								InstanceType:   types.InstanceTypeM5Large,
 								SubnetId:       aws.String("subnet-3"),
 								ImageId:        aws.String("ami-1"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: &az,
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -630,31 +632,31 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.2xlarge"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM52xlarge,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
-				m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
-						filter.EC2.SubnetStates(ec2.SubnetStatePending, ec2.SubnetStateAvailable),
+				m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
+						filter.EC2.SubnetStates(types.SubnetStatePending, types.SubnetStateAvailable),
 						{
 							Name:   aws.String("availability-zone"),
-							Values: aws.StringSlice([]string{"us-east-1c"}),
+							Values: []string{"us-east-1c"},
 						},
 					}})).Return(&ec2.DescribeSubnetsOutput{
-					Subnets: []*ec2.Subnet{
+					Subnets: []types.Subnet{
 						{
 							VpcId:               aws.String("vpc-incorrect-1"),
 							SubnetId:            aws.String("subnet-5"),
@@ -679,21 +681,21 @@ func TestCreateInstance(t *testing.T) {
 					},
 				}, nil)
 				m.
-					RunInstancesWithContext(context.TODO(), &ec2.RunInstancesInput{
+					RunInstances(context.TODO(), &ec2.RunInstancesInput{
 						ImageId:      aws.String("abc"),
-						InstanceType: aws.String("m5.2xlarge"),
+						InstanceType: types.InstanceTypeM52xlarge,
 						KeyName:      aws.String("default"),
-						NetworkInterfaces: []*ec2.InstanceNetworkInterfaceSpecification{
+						NetworkInterfaces: []types.InstanceNetworkInterfaceSpecification{
 							{
-								DeviceIndex: aws.Int64(0),
+								DeviceIndex: aws.Int32(0),
 								SubnetId:    aws.String("subnet-3"),
-								Groups:      aws.StringSlice([]string{"2", "3"}),
+								Groups:      []string{"2", "3"},
 							},
 						},
-						TagSpecifications: []*ec2.TagSpecification{
+						TagSpecifications: []types.TagSpecification{
 							{
-								ResourceType: aws.String("instance"),
-								Tags: []*ec2.Tag{
+								ResourceType: types.ResourceTypeInstance,
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("MachineName"),
 										Value: aws.String("/"),
@@ -717,8 +719,8 @@ func TestCreateInstance(t *testing.T) {
 								},
 							},
 							{
-								ResourceType: aws.String("volume"),
-								Tags: []*ec2.Tag{
+								ResourceType: types.ResourceTypeVolume,
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("MachineName"),
 										Value: aws.String("/"),
@@ -742,8 +744,8 @@ func TestCreateInstance(t *testing.T) {
 								},
 							},
 							{
-								ResourceType: aws.String("network-interface"),
-								Tags: []*ec2.Tag{
+								ResourceType: types.ResourceTypeNetworkInterface,
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("MachineName"),
 										Value: aws.String("/"),
@@ -768,40 +770,40 @@ func TestCreateInstance(t *testing.T) {
 							},
 						},
 						UserData: aws.String(base64.StdEncoding.EncodeToString(userDataCompressed)),
-						MaxCount: aws.Int64(1),
-						MinCount: aws.Int64(1),
-					}).Return(&ec2.Reservation{
-					Instances: []*ec2.Instance{
+						MaxCount: aws.Int32(1),
+						MinCount: aws.Int32(1),
+					}).Return(&ec2.RunInstancesOutput{
+					Instances: []types.Instance{
 						{
-							State: &ec2.InstanceState{
-								Name: aws.String(ec2.InstanceStateNamePending),
+							State: &types.InstanceState{
+								Name: types.InstanceStateNamePending,
 							},
-							IamInstanceProfile: &ec2.IamInstanceProfile{
+							IamInstanceProfile: &types.IamInstanceProfile{
 								Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 							},
 							InstanceId:     aws.String("two"),
-							InstanceType:   aws.String("m5.large"),
+							InstanceType:   types.InstanceTypeM5Large,
 							SubnetId:       aws.String("subnet-3"),
 							ImageId:        aws.String("ami-1"),
 							RootDeviceName: aws.String("device-1"),
-							BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+							BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 								{
 									DeviceName: aws.String("device-1"),
-									Ebs: &ec2.EbsInstanceBlockDevice{
+									Ebs: &types.EbsInstanceBlockDevice{
 										VolumeId: aws.String("volume-1"),
 									},
 								},
 							},
-							Placement: &ec2.Placement{
+							Placement: &types.Placement{
 								AvailabilityZone: &az,
 							},
 						},
 					},
 				}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -897,32 +899,32 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.2xlarge"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM52xlarge,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
-				m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
-						filter.EC2.SubnetStates(ec2.SubnetStatePending, ec2.SubnetStateAvailable),
+				m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
+						filter.EC2.SubnetStates(types.SubnetStatePending, types.SubnetStateAvailable),
 						filter.EC2.VPC("vpc-bar"),
 						{
 							Name:   aws.String("availability-zone"),
-							Values: aws.StringSlice([]string{"us-east-1c"}),
+							Values: []string{"us-east-1c"},
 						},
 					}})).Return(&ec2.DescribeSubnetsOutput{
-					Subnets: []*ec2.Subnet{
+					Subnets: []types.Subnet{
 						{
 							VpcId:            aws.String("vpc-bar"),
 							SubnetId:         aws.String("subnet-5"),
@@ -932,21 +934,21 @@ func TestCreateInstance(t *testing.T) {
 					},
 				}, nil)
 				m.
-					RunInstancesWithContext(context.TODO(), &ec2.RunInstancesInput{
+					RunInstances(context.TODO(), &ec2.RunInstancesInput{
 						ImageId:      aws.String("abc"),
-						InstanceType: aws.String("m5.2xlarge"),
+						InstanceType: types.InstanceTypeM52xlarge,
 						KeyName:      aws.String("default"),
-						NetworkInterfaces: []*ec2.InstanceNetworkInterfaceSpecification{
+						NetworkInterfaces: []types.InstanceNetworkInterfaceSpecification{
 							{
-								DeviceIndex: aws.Int64(0),
+								DeviceIndex: aws.Int32(0),
 								SubnetId:    aws.String("subnet-5"),
-								Groups:      aws.StringSlice([]string{"4", "3"}),
+								Groups:      []string{"4", "3"},
 							},
 						},
-						TagSpecifications: []*ec2.TagSpecification{
+						TagSpecifications: []types.TagSpecification{
 							{
-								ResourceType: aws.String("instance"),
-								Tags: []*ec2.Tag{
+								ResourceType: types.ResourceTypeInstance,
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("MachineName"),
 										Value: aws.String("/"),
@@ -970,8 +972,8 @@ func TestCreateInstance(t *testing.T) {
 								},
 							},
 							{
-								ResourceType: aws.String("volume"),
-								Tags: []*ec2.Tag{
+								ResourceType: types.ResourceTypeVolume,
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("MachineName"),
 										Value: aws.String("/"),
@@ -995,8 +997,8 @@ func TestCreateInstance(t *testing.T) {
 								},
 							},
 							{
-								ResourceType: aws.String("network-interface"),
-								Tags: []*ec2.Tag{
+								ResourceType: types.ResourceTypeNetworkInterface,
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("MachineName"),
 										Value: aws.String("/"),
@@ -1021,40 +1023,40 @@ func TestCreateInstance(t *testing.T) {
 							},
 						},
 						UserData: aws.String(base64.StdEncoding.EncodeToString(userDataCompressed)),
-						MaxCount: aws.Int64(1),
-						MinCount: aws.Int64(1),
-					}).Return(&ec2.Reservation{
-					Instances: []*ec2.Instance{
+						MaxCount: aws.Int32(1),
+						MinCount: aws.Int32(1),
+					}).Return(&ec2.RunInstancesOutput{
+					Instances: []types.Instance{
 						{
-							State: &ec2.InstanceState{
-								Name: aws.String(ec2.InstanceStateNamePending),
+							State: &types.InstanceState{
+								Name: types.InstanceStateNamePending,
 							},
-							IamInstanceProfile: &ec2.IamInstanceProfile{
+							IamInstanceProfile: &types.IamInstanceProfile{
 								Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 							},
 							InstanceId:     aws.String("two"),
-							InstanceType:   aws.String("m5.large"),
+							InstanceType:   types.InstanceTypeM5Large,
 							SubnetId:       aws.String("subnet-5"),
 							ImageId:        aws.String("ami-1"),
 							RootDeviceName: aws.String("device-1"),
-							BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+							BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 								{
 									DeviceName: aws.String("device-1"),
-									Ebs: &ec2.EbsInstanceBlockDevice{
+									Ebs: &types.EbsInstanceBlockDevice{
 										VolumeId: aws.String("volume-1"),
 									},
 								},
 							},
-							Placement: &ec2.Placement{
+							Placement: &types.Placement{
 								AvailabilityZone: &az,
 							},
 						},
 					},
 				}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -1128,17 +1130,17 @@ func TestCreateInstance(t *testing.T) {
 					t.Fatalf("Failed to process ami format: %v", err)
 				}
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m6g.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM6gLarge,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("arm64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeArm64,
 									},
 								},
 							},
@@ -1146,32 +1148,32 @@ func TestCreateInstance(t *testing.T) {
 					}, nil)
 				// verify that the ImageLookupOrg is used when finding AMIs
 				m.
-					DescribeImagesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeImagesInput{
-						Filters: []*ec2.Filter{
+					DescribeImages(context.TODO(), gomock.Eq(&ec2.DescribeImagesInput{
+						Filters: []types.Filter{
 							{
 								Name:   aws.String("owner-id"),
-								Values: []*string{aws.String("test-org-123")},
+								Values: []string{"test-org-123"},
 							},
 							{
 								Name:   aws.String("name"),
-								Values: []*string{aws.String(amiName)},
+								Values: []string{amiName},
 							},
 							{
 								Name:   aws.String("architecture"),
-								Values: []*string{aws.String("arm64")},
+								Values: []string{"arm64"},
 							},
 							{
 								Name:   aws.String("state"),
-								Values: []*string{aws.String("available")},
+								Values: []string{"available"},
 							},
 							{
 								Name:   aws.String("virtualization-type"),
-								Values: []*string{aws.String("hvm")},
+								Values: []string{"hvm"},
 							},
 						},
 					})).
 					Return(&ec2.DescribeImagesOutput{
-						Images: []*ec2.Image{
+						Images: []types.Image{
 							{
 								Name:         aws.String("ami-1"),
 								CreationDate: aws.String("2006-01-02T15:04:05.000Z"),
@@ -1179,39 +1181,39 @@ func TestCreateInstance(t *testing.T) {
 						},
 					}, nil)
 				m. // TODO: Restore these parameters, but with the tags as well
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+					RunInstances(context.TODO(), gomock.Any()).
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNamePending),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNamePending,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("two"),
-								InstanceType:   aws.String("m5.large"),
+								InstanceType:   types.InstanceTypeM5Large,
 								SubnetId:       aws.String("subnet-1"),
 								ImageId:        aws.String("ami-1"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: &az,
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -1281,17 +1283,17 @@ func TestCreateInstance(t *testing.T) {
 					t.Fatalf("Failed to process ami format: %v", err)
 				}
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
@@ -1299,32 +1301,32 @@ func TestCreateInstance(t *testing.T) {
 					}, nil)
 				// verify that the ImageLookupOrg is used when finding AMIs
 				m.
-					DescribeImagesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeImagesInput{
-						Filters: []*ec2.Filter{
+					DescribeImages(context.TODO(), gomock.Eq(&ec2.DescribeImagesInput{
+						Filters: []types.Filter{
 							{
 								Name:   aws.String("owner-id"),
-								Values: []*string{aws.String("cluster-level-image-lookup-org")},
+								Values: []string{"cluster-level-image-lookup-org"},
 							},
 							{
 								Name:   aws.String("name"),
-								Values: []*string{aws.String(amiName)},
+								Values: []string{amiName},
 							},
 							{
 								Name:   aws.String("architecture"),
-								Values: []*string{aws.String("x86_64")},
+								Values: []string{"x86_64"},
 							},
 							{
 								Name:   aws.String("state"),
-								Values: []*string{aws.String("available")},
+								Values: []string{"available"},
 							},
 							{
 								Name:   aws.String("virtualization-type"),
-								Values: []*string{aws.String("hvm")},
+								Values: []string{"hvm"},
 							},
 						},
 					})).
 					Return(&ec2.DescribeImagesOutput{
-						Images: []*ec2.Image{
+						Images: []types.Image{
 							{
 								Name:         aws.String("ami-1"),
 								CreationDate: aws.String("2006-01-02T15:04:05.000Z"),
@@ -1332,39 +1334,39 @@ func TestCreateInstance(t *testing.T) {
 						},
 					}, nil)
 				m. // TODO: Restore these parameters, but with the tags as well
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+					RunInstances(context.TODO(), gomock.Any()).
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNamePending),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNamePending,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("two"),
-								InstanceType:   aws.String("m5.large"),
+								InstanceType:   types.InstanceTypeM5Large,
 								SubnetId:       aws.String("subnet-1"),
 								ImageId:        aws.String("ami-1"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: &az,
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -1435,17 +1437,17 @@ func TestCreateInstance(t *testing.T) {
 					t.Fatalf("Failed to process ami format: %v", err)
 				}
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
@@ -1453,32 +1455,32 @@ func TestCreateInstance(t *testing.T) {
 					}, nil)
 				// verify that the ImageLookupOrg is used when finding AMIs
 				m.
-					DescribeImagesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeImagesInput{
-						Filters: []*ec2.Filter{
+					DescribeImages(context.TODO(), gomock.Eq(&ec2.DescribeImagesInput{
+						Filters: []types.Filter{
 							{
 								Name:   aws.String("owner-id"),
-								Values: []*string{aws.String("machine-level-image-lookup-org")},
+								Values: []string{"machine-level-image-lookup-org"},
 							},
 							{
 								Name:   aws.String("name"),
-								Values: []*string{aws.String(amiName)},
+								Values: []string{amiName},
 							},
 							{
 								Name:   aws.String("architecture"),
-								Values: []*string{aws.String("x86_64")},
+								Values: []string{"x86_64"},
 							},
 							{
 								Name:   aws.String("state"),
-								Values: []*string{aws.String("available")},
+								Values: []string{"available"},
 							},
 							{
 								Name:   aws.String("virtualization-type"),
-								Values: []*string{aws.String("hvm")},
+								Values: []string{"hvm"},
 							},
 						},
 					})).
 					Return(&ec2.DescribeImagesOutput{
-						Images: []*ec2.Image{
+						Images: []types.Image{
 							{
 								Name:         aws.String("ami-1"),
 								CreationDate: aws.String("2006-01-02T15:04:05.000Z"),
@@ -1486,39 +1488,39 @@ func TestCreateInstance(t *testing.T) {
 						},
 					}, nil)
 				m. // TODO: Restore these parameters, but with the tags as well
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+					RunInstances(context.TODO(), gomock.Any()).
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNamePending),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNamePending,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("two"),
-								InstanceType:   aws.String("m5.large"),
+								InstanceType:   types.InstanceTypeM5Large,
 								SubnetId:       aws.String("subnet-1"),
 								ImageId:        aws.String("ami-1"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: &az,
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -1583,69 +1585,69 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeSubnetsWithContext(context.TODO(), &ec2.DescribeSubnetsInput{
-						Filters: []*ec2.Filter{
-							filter.EC2.SubnetStates(ec2.SubnetStatePending, ec2.SubnetStateAvailable),
-							{Name: aws.String("tag:some-tag"), Values: aws.StringSlice([]string{"some-value"})},
+					DescribeSubnets(context.TODO(), &ec2.DescribeSubnetsInput{
+						Filters: []types.Filter{
+							filter.EC2.SubnetStates(types.SubnetStatePending, types.SubnetStateAvailable),
+							{Name: aws.String("tag:some-tag"), Values: []string{"some-value"}},
 						},
 					}).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{{
+						Subnets: []types.Subnet{{
 							SubnetId:         aws.String("filtered-subnet-1"),
 							AvailabilityZone: aws.String("us-east-1b"),
 						}},
 					}, nil)
 				m.
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+					RunInstances(context.TODO(), gomock.Any()).
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNamePending),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNamePending,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("two"),
-								InstanceType:   aws.String("m5.large"),
+								InstanceType:   types.InstanceTypeM5Large,
 								SubnetId:       aws.String("subnet-1"),
 								ImageId:        aws.String("ami-1"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: &az,
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -1709,69 +1711,69 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeSubnetsWithContext(context.TODO(), &ec2.DescribeSubnetsInput{
-						Filters: []*ec2.Filter{
-							filter.EC2.SubnetStates(ec2.SubnetStatePending, ec2.SubnetStateAvailable),
-							{Name: aws.String("subnet-id"), Values: aws.StringSlice([]string{"matching-subnet"})},
+					DescribeSubnets(context.TODO(), &ec2.DescribeSubnetsInput{
+						Filters: []types.Filter{
+							filter.EC2.SubnetStates(types.SubnetStatePending, types.SubnetStateAvailable),
+							{Name: aws.String("subnet-id"), Values: []string{"matching-subnet"}},
 						},
 					}).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{{
+						Subnets: []types.Subnet{{
 							SubnetId:         aws.String("matching-subnet"),
 							AvailabilityZone: aws.String("us-east-1b"),
 						}},
 					}, nil)
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m.
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+					RunInstances(context.TODO(), gomock.Any()).
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNamePending),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNamePending,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("two"),
-								InstanceType:   aws.String("m5.large"),
+								InstanceType:   types.InstanceTypeM5Large,
 								SubnetId:       aws.String("matching-subnet"),
 								ImageId:        aws.String("ami-1"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: &az,
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -1835,31 +1837,31 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeSubnetsWithContext(context.TODO(), &ec2.DescribeSubnetsInput{
-						Filters: []*ec2.Filter{
-							filter.EC2.SubnetStates(ec2.SubnetStatePending, ec2.SubnetStateAvailable),
-							{Name: aws.String("subnet-id"), Values: aws.StringSlice([]string{"non-matching-subnet"})},
+					DescribeSubnets(context.TODO(), &ec2.DescribeSubnetsInput{
+						Filters: []types.Filter{
+							filter.EC2.SubnetStates(types.SubnetStatePending, types.SubnetStateAvailable),
+							{Name: aws.String("subnet-id"), Values: []string{"non-matching-subnet"}},
 						},
 					}).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{},
+						Subnets: []types.Subnet{},
 					}, nil)
 			},
 			check: func(instance *infrav1.Instance, err error) {
@@ -1927,68 +1929,68 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+					RunInstances(context.TODO(), gomock.Any()).
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNamePending),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNamePending,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("two"),
-								InstanceType:   aws.String("m5.large"),
+								InstanceType:   types.InstanceTypeM5Large,
 								SubnetId:       aws.String("matching-subnet"),
 								ImageId:        aws.String("ami-1"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: &az,
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeSubnetsWithContext(context.TODO(), &ec2.DescribeSubnetsInput{
-						Filters: []*ec2.Filter{
-							filter.EC2.SubnetStates(ec2.SubnetStatePending, ec2.SubnetStateAvailable),
-							{Name: aws.String("subnet-id"), Values: aws.StringSlice([]string{"matching-subnet"})},
+					DescribeSubnets(context.TODO(), &ec2.DescribeSubnetsInput{
+						Filters: []types.Filter{
+							filter.EC2.SubnetStates(types.SubnetStatePending, types.SubnetStateAvailable),
+							{Name: aws.String("subnet-id"), Values: []string{"matching-subnet"}},
 						},
 					}).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{{
+						Subnets: []types.Subnet{{
 							SubnetId: aws.String("matching-subnet"),
 						}},
 					}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -2054,30 +2056,30 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeSubnetsWithContext(context.TODO(), &ec2.DescribeSubnetsInput{
-						Filters: []*ec2.Filter{
-							filter.EC2.SubnetStates(ec2.SubnetStatePending, ec2.SubnetStateAvailable),
-							{Name: aws.String("subnet-id"), Values: aws.StringSlice([]string{"subnet-1"})},
+					DescribeSubnets(context.TODO(), &ec2.DescribeSubnetsInput{
+						Filters: []types.Filter{
+							filter.EC2.SubnetStates(types.SubnetStatePending, types.SubnetStateAvailable),
+							{Name: aws.String("subnet-id"), Values: []string{"subnet-1"}},
 						},
 					}).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{{
+						Subnets: []types.Subnet{{
 							SubnetId:         aws.String("subnet-1"),
 							AvailabilityZone: aws.String("us-west-1b"),
 						}},
 					}, nil)
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
@@ -2150,17 +2152,17 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
@@ -2234,70 +2236,70 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeSubnetsWithContext(context.TODO(), &ec2.DescribeSubnetsInput{
-						Filters: []*ec2.Filter{
-							filter.EC2.SubnetStates(ec2.SubnetStatePending, ec2.SubnetStateAvailable),
-							{Name: aws.String("subnet-id"), Values: aws.StringSlice([]string{"public-subnet-1"})},
+					DescribeSubnets(context.TODO(), &ec2.DescribeSubnetsInput{
+						Filters: []types.Filter{
+							filter.EC2.SubnetStates(types.SubnetStatePending, types.SubnetStateAvailable),
+							{Name: aws.String("subnet-id"), Values: []string{"public-subnet-1"}},
 						},
 					}).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{{
+						Subnets: []types.Subnet{{
 							SubnetId:            aws.String("public-subnet-1"),
 							AvailabilityZone:    aws.String("us-east-1b"),
 							MapPublicIpOnLaunch: aws.Bool(true),
 						}},
 					}, nil)
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m.
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+					RunInstances(context.TODO(), gomock.Any()).
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNamePending),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNamePending,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("two"),
-								InstanceType:   aws.String("m5.large"),
+								InstanceType:   types.InstanceTypeM5Large,
 								SubnetId:       aws.String("public-subnet-1"),
 								ImageId:        aws.String("ami-1"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: &az,
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -2363,38 +2365,38 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeSubnetsWithContext(context.TODO(), &ec2.DescribeSubnetsInput{
-						Filters: []*ec2.Filter{
-							filter.EC2.SubnetStates(ec2.SubnetStatePending, ec2.SubnetStateAvailable),
-							{Name: aws.String("subnet-id"), Values: aws.StringSlice([]string{"public-subnet-1"})},
+					DescribeSubnets(context.TODO(), &ec2.DescribeSubnetsInput{
+						Filters: []types.Filter{
+							filter.EC2.SubnetStates(types.SubnetStatePending, types.SubnetStateAvailable),
+							{Name: aws.String("subnet-id"), Values: []string{"public-subnet-1"}},
 						},
 					}).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{{
+						Subnets: []types.Subnet{{
 							SubnetId:            aws.String("public-subnet-1"),
 							AvailabilityZone:    aws.String("us-east-1b"),
 							MapPublicIpOnLaunch: aws.Bool(false),
 						}},
 					}, nil)
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m.
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
+					RunInstances(context.TODO(), gomock.Any()).
 					Do(func(_ context.Context, in *ec2.RunInstancesInput, _ ...request.Option) {
 						if len(in.NetworkInterfaces) == 0 {
 							t.Fatalf("expected a NetworkInterface to be defined")
@@ -2409,38 +2411,38 @@ func TestCreateInstance(t *testing.T) {
 							t.Fatalf("expected security groups to be set")
 						}
 					}).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNamePending),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNamePending,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("two"),
-								InstanceType:   aws.String("m5.large"),
+								InstanceType:   types.InstanceTypeM5Large,
 								SubnetId:       aws.String("public-subnet-1"),
 								ImageId:        aws.String("ami-1"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: &az,
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -2508,24 +2510,24 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m.
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
+					RunInstances(context.TODO(), gomock.Any()).
 					Do(func(_ context.Context, in *ec2.RunInstancesInput, _ ...request.Option) {
 						if len(in.NetworkInterfaces) == 0 {
 							t.Fatalf("expected a NetworkInterface to be defined")
@@ -2537,38 +2539,38 @@ func TestCreateInstance(t *testing.T) {
 							t.Fatalf("expected interface type to be \"efa\": got %q", interfaceType)
 						}
 					}).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNamePending),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNamePending,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("two"),
-								InstanceType:   aws.String("m5.large"),
+								InstanceType:   types.InstanceTypeM5Large,
 								SubnetId:       aws.String("subnet-1"),
 								ImageId:        aws.String("ami-1"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: &az,
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -2634,31 +2636,31 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeSubnetsWithContext(context.TODO(), &ec2.DescribeSubnetsInput{
-						Filters: []*ec2.Filter{
-							filter.EC2.SubnetStates(ec2.SubnetStatePending, ec2.SubnetStateAvailable),
-							{Name: aws.String("subnet-id"), Values: aws.StringSlice([]string{"private-subnet-1"})},
+					DescribeSubnets(context.TODO(), &ec2.DescribeSubnetsInput{
+						Filters: []types.Filter{
+							filter.EC2.SubnetStates(types.SubnetStatePending, types.SubnetStateAvailable),
+							{Name: aws.String("subnet-id"), Values: []string{"private-subnet-1"}},
 						},
 					}).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{{
+						Subnets: []types.Subnet{{
 							SubnetId:            aws.String("private-subnet-1"),
 							AvailabilityZone:    aws.String("us-east-1b"),
 							MapPublicIpOnLaunch: aws.Bool(false),
 						}},
 					}, nil)
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
@@ -2741,69 +2743,69 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeSubnetsWithContext(context.TODO(), &ec2.DescribeSubnetsInput{
-						Filters: []*ec2.Filter{
-							filter.EC2.SubnetStates(ec2.SubnetStatePending, ec2.SubnetStateAvailable),
-							{Name: aws.String("tag:some-tag"), Values: aws.StringSlice([]string{"some-value"})},
+					DescribeSubnets(context.TODO(), &ec2.DescribeSubnetsInput{
+						Filters: []types.Filter{
+							filter.EC2.SubnetStates(types.SubnetStatePending, types.SubnetStateAvailable),
+							{Name: aws.String("tag:some-tag"), Values: []string{"some-value"}},
 						},
 					}).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{{
+						Subnets: []types.Subnet{{
 							SubnetId:            aws.String("public-subnet-1"),
 							MapPublicIpOnLaunch: aws.Bool(true),
 						}},
 					}, nil)
 				m.
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+					RunInstances(context.TODO(), gomock.Any()).
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNamePending),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNamePending,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("two"),
-								InstanceType:   aws.String("m5.large"),
+								InstanceType:   types.InstanceTypeM5Large,
 								SubnetId:       aws.String("public-subnet-1"),
 								ImageId:        aws.String("ami-1"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: &az,
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -2878,37 +2880,37 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeSubnetsWithContext(context.TODO(), &ec2.DescribeSubnetsInput{
-						Filters: []*ec2.Filter{
-							filter.EC2.SubnetStates(ec2.SubnetStatePending, ec2.SubnetStateAvailable),
-							{Name: aws.String("tag:some-tag"), Values: aws.StringSlice([]string{"some-value"})},
+					DescribeSubnets(context.TODO(), &ec2.DescribeSubnetsInput{
+						Filters: []types.Filter{
+							filter.EC2.SubnetStates(types.SubnetStatePending, types.SubnetStateAvailable),
+							{Name: aws.String("tag:some-tag"), Values: []string{"some-value"}},
 						},
 					}).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{{
+						Subnets: []types.Subnet{{
 							SubnetId:            aws.String("public-subnet-1"),
 							MapPublicIpOnLaunch: aws.Bool(false),
 						}},
 					}, nil)
 				m.
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
+					RunInstances(context.TODO(), gomock.Any()).
 					Do(func(_ context.Context, in *ec2.RunInstancesInput, _ ...request.Option) {
 						if len(in.NetworkInterfaces) == 0 {
 							t.Fatalf("expected a NetworkInterface to be defined")
@@ -2923,38 +2925,38 @@ func TestCreateInstance(t *testing.T) {
 							t.Fatalf("expected security groups to be set")
 						}
 					}).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNamePending),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNamePending,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("two"),
-								InstanceType:   aws.String("m5.large"),
+								InstanceType:   types.InstanceTypeM5Large,
 								SubnetId:       aws.String("public-subnet-1"),
 								ImageId:        aws.String("ami-1"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: &az,
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -3023,56 +3025,56 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m.
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+					RunInstances(context.TODO(), gomock.Any()).
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNamePending),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNamePending,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("two"),
-								InstanceType:   aws.String("m5.large"),
+								InstanceType:   types.InstanceTypeM5Large,
 								SubnetId:       aws.String("public-subnet-1"),
 								ImageId:        aws.String("ami-1"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: &az,
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -3141,24 +3143,24 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m.
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
+					RunInstances(context.TODO(), gomock.Any()).
 					Do(func(_ context.Context, in *ec2.RunInstancesInput, _ ...request.Option) {
 						if len(in.NetworkInterfaces) == 0 {
 							t.Fatalf("expected a NetworkInterface to be defined")
@@ -3173,38 +3175,38 @@ func TestCreateInstance(t *testing.T) {
 							t.Fatalf("expected security groups to be set")
 						}
 					}).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNamePending),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNamePending,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("two"),
-								InstanceType:   aws.String("m5.large"),
+								InstanceType:   types.InstanceTypeM5Large,
 								SubnetId:       aws.String("public-subnet-1"),
 								ImageId:        aws.String("ami-1"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: &az,
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -3269,17 +3271,17 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
@@ -3358,62 +3360,62 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m. // TODO: Restore these parameters, but with the tags as well
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+					RunInstances(context.TODO(), gomock.Any()).
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNamePending),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNamePending,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("two"),
-								InstanceType:   aws.String("m5.large"),
+								InstanceType:   types.InstanceTypeM5Large,
 								SubnetId:       aws.String("subnet-1"),
 								ImageId:        aws.String("ami-1"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 									{
 										DeviceName: aws.String("device-2"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-2"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: &az,
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -3483,26 +3485,26 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m. // TODO: Restore these parameters, but with the tags as well
-					RunInstancesWithContext(context.TODO(), gomock.Eq(&ec2.RunInstancesInput{
+					RunInstances(context.TODO(), gomock.Eq(&ec2.RunInstancesInput{
 						ImageId:      aws.String("abc"),
-						InstanceType: aws.String("m5.large"),
+						InstanceType: types.InstanceTypeM5Large,
 						KeyName:      aws.String("default"),
-						MaxCount:     aws.Int64(1),
-						MinCount:     aws.Int64(1),
-						Placement: &ec2.Placement{
-							Tenancy: &tenancy,
+						MaxCount:     aws.Int32(1),
+						MinCount:     aws.Int32(1),
+						Placement: &types.Placement{
+							Tenancy: tenancy,
 						},
-						NetworkInterfaces: []*ec2.InstanceNetworkInterfaceSpecification{
+						NetworkInterfaces: []types.InstanceNetworkInterfaceSpecification{
 							{
-								DeviceIndex: aws.Int64(0),
+								DeviceIndex: aws.Int32(0),
 								SubnetId:    aws.String("subnet-1"),
-								Groups:      []*string{aws.String("2"), aws.String("3")},
+								Groups:      []string{"2", "3"},
 							},
 						},
-						TagSpecifications: []*ec2.TagSpecification{
+						TagSpecifications: []types.TagSpecification{
 							{
-								ResourceType: aws.String("instance"),
-								Tags: []*ec2.Tag{
+								ResourceType: types.ResourceTypeInstance,
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("MachineName"),
 										Value: aws.String("default/machine-aws-test1"),
@@ -3526,8 +3528,8 @@ func TestCreateInstance(t *testing.T) {
 								},
 							},
 							{
-								ResourceType: aws.String("volume"),
-								Tags: []*ec2.Tag{
+								ResourceType: types.ResourceTypeVolume,
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("MachineName"),
 										Value: aws.String("default/machine-aws-test1"),
@@ -3551,8 +3553,8 @@ func TestCreateInstance(t *testing.T) {
 								},
 							},
 							{
-								ResourceType: aws.String("network-interface"),
-								Tags: []*ec2.Tag{
+								ResourceType: types.ResourceTypeNetworkInterface,
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("MachineName"),
 										Value: aws.String("default/machine-aws-test1"),
@@ -3578,56 +3580,56 @@ func TestCreateInstance(t *testing.T) {
 						},
 						UserData: aws.String(base64.StdEncoding.EncodeToString(userDataCompressed)),
 					})).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNamePending),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNamePending,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("two"),
-								InstanceType:   aws.String("m5.large"),
+								InstanceType:   types.InstanceTypeM5Large,
 								SubnetId:       aws.String("subnet-1"),
 								ImageId:        aws.String("ami-1"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: &az,
-									Tenancy:          &tenancy,
+									Tenancy:          tenancy,
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -3697,26 +3699,26 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m. // TODO: Restore these parameters, but with the tags as well
-					RunInstancesWithContext(context.TODO(), gomock.Eq(&ec2.RunInstancesInput{
+					RunInstances(context.TODO(), gomock.Eq(&ec2.RunInstancesInput{
 						ImageId:      aws.String("abc"),
-						InstanceType: aws.String("m5.large"),
+						InstanceType: types.InstanceTypeM5Large,
 						KeyName:      aws.String("default"),
-						MaxCount:     aws.Int64(1),
-						MinCount:     aws.Int64(1),
-						Placement: &ec2.Placement{
+						MaxCount:     aws.Int32(1),
+						MinCount:     aws.Int32(1),
+						Placement: &types.Placement{
 							GroupName: aws.String("placement-group1"),
 						},
-						NetworkInterfaces: []*ec2.InstanceNetworkInterfaceSpecification{
+						NetworkInterfaces: []types.InstanceNetworkInterfaceSpecification{
 							{
-								DeviceIndex: aws.Int64(0),
+								DeviceIndex: aws.Int32(0),
 								SubnetId:    aws.String("subnet-1"),
-								Groups:      []*string{aws.String("2"), aws.String("3")},
+								Groups:      []string{"2", "3"},
 							},
 						},
-						TagSpecifications: []*ec2.TagSpecification{
+						TagSpecifications: []types.TagSpecification{
 							{
-								ResourceType: aws.String("instance"),
-								Tags: []*ec2.Tag{
+								ResourceType: types.ResourceTypeInstance,
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("MachineName"),
 										Value: aws.String("default/machine-aws-test1"),
@@ -3740,8 +3742,8 @@ func TestCreateInstance(t *testing.T) {
 								},
 							},
 							{
-								ResourceType: aws.String("volume"),
-								Tags: []*ec2.Tag{
+								ResourceType: types.ResourceTypeVolume,
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("MachineName"),
 										Value: aws.String("default/machine-aws-test1"),
@@ -3765,8 +3767,8 @@ func TestCreateInstance(t *testing.T) {
 								},
 							},
 							{
-								ResourceType: aws.String("network-interface"),
-								Tags: []*ec2.Tag{
+								ResourceType: types.ResourceTypeNetworkInterface,
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("MachineName"),
 										Value: aws.String("default/machine-aws-test1"),
@@ -3792,29 +3794,29 @@ func TestCreateInstance(t *testing.T) {
 						},
 						UserData: aws.String(base64.StdEncoding.EncodeToString(userDataCompressed)),
 					})).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNamePending),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNamePending,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("two"),
-								InstanceType:   aws.String("m5.large"),
+								InstanceType:   types.InstanceTypeM5Large,
 								SubnetId:       aws.String("subnet-1"),
 								ImageId:        aws.String("ami-1"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: &az,
 									GroupName:        aws.String("placement-group1"),
 								},
@@ -3822,26 +3824,26 @@ func TestCreateInstance(t *testing.T) {
 						},
 					}, nil)
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -3914,44 +3916,44 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m. // TODO: Restore these parameters, but with the tags as well
-					RunInstancesWithContext(context.TODO(), gomock.Eq(&ec2.RunInstancesInput{
+					RunInstances(context.TODO(), gomock.Eq(&ec2.RunInstancesInput{
 						ImageId:      aws.String("abc"),
-						InstanceType: aws.String("m5.large"),
+						InstanceType: types.InstanceTypeM5Large,
 						KeyName:      aws.String("default"),
-						MaxCount:     aws.Int64(1),
-						MinCount:     aws.Int64(1),
-						Placement: &ec2.Placement{
-							Tenancy:   &tenancy,
+						MaxCount:     aws.Int32(1),
+						MinCount:     aws.Int32(1),
+						Placement: &types.Placement{
+							Tenancy:   tenancy,
 							GroupName: aws.String("placement-group1"),
 						},
-						NetworkInterfaces: []*ec2.InstanceNetworkInterfaceSpecification{
+						NetworkInterfaces: []types.InstanceNetworkInterfaceSpecification{
 							{
-								DeviceIndex: aws.Int64(0),
+								DeviceIndex: aws.Int32(0),
 								SubnetId:    aws.String("subnet-1"),
-								Groups:      []*string{aws.String("2"), aws.String("3")},
+								Groups:      []string{"2", "3"},
 							},
 						},
-						TagSpecifications: []*ec2.TagSpecification{
+						TagSpecifications: []types.TagSpecification{
 							{
-								ResourceType: aws.String("instance"),
-								Tags: []*ec2.Tag{
+								ResourceType: types.ResourceTypeInstance,
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("MachineName"),
 										Value: aws.String("default/machine-aws-test1"),
@@ -3975,8 +3977,8 @@ func TestCreateInstance(t *testing.T) {
 								},
 							},
 							{
-								ResourceType: aws.String("volume"),
-								Tags: []*ec2.Tag{
+								ResourceType: types.ResourceTypeVolume,
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("MachineName"),
 										Value: aws.String("default/machine-aws-test1"),
@@ -4000,8 +4002,8 @@ func TestCreateInstance(t *testing.T) {
 								},
 							},
 							{
-								ResourceType: aws.String("network-interface"),
-								Tags: []*ec2.Tag{
+								ResourceType: types.ResourceTypeNetworkInterface,
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("MachineName"),
 										Value: aws.String("default/machine-aws-test1"),
@@ -4027,39 +4029,39 @@ func TestCreateInstance(t *testing.T) {
 						},
 						UserData: aws.String(base64.StdEncoding.EncodeToString(data)),
 					})).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNamePending),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNamePending,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("two"),
-								InstanceType:   aws.String("m5.large"),
+								InstanceType:   types.InstanceTypeM5Large,
 								SubnetId:       aws.String("subnet-1"),
 								ImageId:        aws.String("ami-1"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: &az,
-									Tenancy:          &tenancy,
+									Tenancy:          tenancy,
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -4127,27 +4129,27 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m. // TODO: Restore these parameters, but with the tags as well
-					RunInstancesWithContext(context.TODO(), gomock.Eq(&ec2.RunInstancesInput{
+					RunInstances(context.TODO(), gomock.Eq(&ec2.RunInstancesInput{
 						ImageId:      aws.String("abc"),
-						InstanceType: aws.String("m5.large"),
+						InstanceType: types.InstanceTypeM5Large,
 						KeyName:      aws.String("default"),
-						MaxCount:     aws.Int64(1),
-						MinCount:     aws.Int64(1),
-						Placement: &ec2.Placement{
+						MaxCount:     aws.Int32(1),
+						MinCount:     aws.Int32(1),
+						Placement: &types.Placement{
 							GroupName:       aws.String("placement-group1"),
-							PartitionNumber: aws.Int64(2),
+							PartitionNumber: aws.Int32(2),
 						},
-						NetworkInterfaces: []*ec2.InstanceNetworkInterfaceSpecification{
+						NetworkInterfaces: []types.InstanceNetworkInterfaceSpecification{
 							{
-								DeviceIndex: aws.Int64(0),
+								DeviceIndex: aws.Int32(0),
 								SubnetId:    aws.String("subnet-1"),
-								Groups:      aws.StringSlice([]string{"2", "3"}),
+								Groups:      []string{"2", "3"},
 							},
 						},
-						TagSpecifications: []*ec2.TagSpecification{
+						TagSpecifications: []types.TagSpecification{
 							{
-								ResourceType: aws.String("instance"),
-								Tags: []*ec2.Tag{
+								ResourceType: types.ResourceTypeInstance,
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("MachineName"),
 										Value: aws.String("default/machine-aws-test1"),
@@ -4171,8 +4173,8 @@ func TestCreateInstance(t *testing.T) {
 								},
 							},
 							{
-								ResourceType: aws.String("volume"),
-								Tags: []*ec2.Tag{
+								ResourceType: types.ResourceTypeVolume,
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("MachineName"),
 										Value: aws.String("default/machine-aws-test1"),
@@ -4196,8 +4198,8 @@ func TestCreateInstance(t *testing.T) {
 								},
 							},
 							{
-								ResourceType: aws.String("network-interface"),
-								Tags: []*ec2.Tag{
+								ResourceType: types.ResourceTypeNetworkInterface,
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("MachineName"),
 										Value: aws.String("default/machine-aws-test1"),
@@ -4223,57 +4225,57 @@ func TestCreateInstance(t *testing.T) {
 						},
 						UserData: aws.String(base64.StdEncoding.EncodeToString(userDataCompressed)),
 					})).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNamePending),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNamePending,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("two"),
-								InstanceType:   aws.String("m5.large"),
+								InstanceType:   types.InstanceTypeM5Large,
 								SubnetId:       aws.String("subnet-1"),
 								ImageId:        aws.String("ami-1"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: &az,
 									GroupName:        aws.String("placement-group1"),
-									PartitionNumber:  aws.Int64(2),
+									PartitionNumber:  aws.Int32(2),
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -4340,17 +4342,17 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
@@ -4422,26 +4424,26 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeImagesWithContext(context.TODO(), gomock.Any()).
+					DescribeImages(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeImagesOutput{
-						Images: []*ec2.Image{
+						Images: []types.Image{
 							{
 								Name:         aws.String("ami-1"),
 								CreationDate: aws.String("2011-02-08T17:02:31.000Z"),
@@ -4449,37 +4451,37 @@ func TestCreateInstance(t *testing.T) {
 						},
 					}, nil)
 				m. // TODO: Restore these parameters, but with the tags as well
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
-					DoAndReturn(func(ctx context.Context, input *ec2.RunInstancesInput, requestOptions ...request.Option) (*ec2.Reservation, error) {
+					RunInstances(context.TODO(), gomock.Any()).
+					DoAndReturn(func(ctx context.Context, input *ec2.RunInstancesInput, requestOptions ...request.Option) (*ec2.RunInstancesOutput, error) {
 						if input.KeyName == nil {
 							t.Fatal("Expected key name not to be nil")
 						}
 						if *input.KeyName != defaultSSHKeyName {
 							t.Fatalf("Expected SSH key name to be '%s', not '%s'", defaultSSHKeyName, *input.KeyName)
 						}
-						return &ec2.Reservation{
-							Instances: []*ec2.Instance{
+						return &ec2.RunInstancesOutput{
+							Instances: []types.Instance{
 								{
-									State: &ec2.InstanceState{
-										Name: aws.String(ec2.InstanceStateNamePending),
+									State: &types.InstanceState{
+										Name: types.InstanceStateNamePending,
 									},
-									IamInstanceProfile: &ec2.IamInstanceProfile{
+									IamInstanceProfile: &types.IamInstanceProfile{
 										Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 									},
 									InstanceId:     aws.String("two"),
-									InstanceType:   aws.String("m5.large"),
+									InstanceType:   types.InstanceTypeM5Large,
 									SubnetId:       aws.String("subnet-1"),
 									ImageId:        aws.String("ami-1"),
 									RootDeviceName: aws.String("device-1"),
-									BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+									BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 										{
 											DeviceName: aws.String("device-1"),
-											Ebs: &ec2.EbsInstanceBlockDevice{
+											Ebs: &types.EbsInstanceBlockDevice{
 												VolumeId: aws.String("volume-1"),
 											},
 										},
 									},
-									Placement: &ec2.Placement{
+									Placement: &types.Placement{
 										AvailabilityZone: &az,
 									},
 								},
@@ -4487,9 +4489,9 @@ func TestCreateInstance(t *testing.T) {
 						}, nil
 					})
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -4555,26 +4557,26 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeImagesWithContext(context.TODO(), gomock.Any()).
+					DescribeImages(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeImagesOutput{
-						Images: []*ec2.Image{
+						Images: []types.Image{
 							{
 								Name:         aws.String("ami-1"),
 								CreationDate: aws.String("2011-02-08T17:02:31.000Z"),
@@ -4582,37 +4584,37 @@ func TestCreateInstance(t *testing.T) {
 						},
 					}, nil)
 				m. // TODO: Restore these parameters, but with the tags as well
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
-					DoAndReturn(func(ctx context.Context, input *ec2.RunInstancesInput, requestOptions ...request.Option) (*ec2.Reservation, error) {
+					RunInstances(context.TODO(), gomock.Any()).
+					DoAndReturn(func(ctx context.Context, input *ec2.RunInstancesInput, requestOptions ...request.Option) (*ec2.RunInstancesOutput, error) {
 						if input.KeyName == nil {
 							t.Fatal("Expected key name not to be nil")
 						}
 						if *input.KeyName != "specific-cluster-key-name" {
 							t.Fatalf("Expected SSH key name to be '%s', not '%s'", "specific-cluster-key-name", *input.KeyName)
 						}
-						return &ec2.Reservation{
-							Instances: []*ec2.Instance{
+						return &ec2.RunInstancesOutput{
+							Instances: []types.Instance{
 								{
-									State: &ec2.InstanceState{
-										Name: aws.String(ec2.InstanceStateNamePending),
+									State: &types.InstanceState{
+										Name: types.InstanceStateNamePending,
 									},
-									IamInstanceProfile: &ec2.IamInstanceProfile{
+									IamInstanceProfile: &types.IamInstanceProfile{
 										Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 									},
 									InstanceId:     aws.String("two"),
-									InstanceType:   aws.String("m5.large"),
+									InstanceType:   types.InstanceTypeM5Large,
 									SubnetId:       aws.String("subnet-1"),
 									ImageId:        aws.String("ami-1"),
 									RootDeviceName: aws.String("device-1"),
-									BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+									BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 										{
 											DeviceName: aws.String("device-1"),
-											Ebs: &ec2.EbsInstanceBlockDevice{
+											Ebs: &types.EbsInstanceBlockDevice{
 												VolumeId: aws.String("volume-1"),
 											},
 										},
 									},
-									Placement: &ec2.Placement{
+									Placement: &types.Placement{
 										AvailabilityZone: &az,
 									},
 								},
@@ -4620,9 +4622,9 @@ func TestCreateInstance(t *testing.T) {
 						}, nil
 					})
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -4689,26 +4691,26 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeImagesWithContext(context.TODO(), gomock.Any()).
+					DescribeImages(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeImagesOutput{
-						Images: []*ec2.Image{
+						Images: []types.Image{
 							{
 								Name:         aws.String("ami-1"),
 								CreationDate: aws.String("2011-02-08T17:02:31.000Z"),
@@ -4716,37 +4718,37 @@ func TestCreateInstance(t *testing.T) {
 						},
 					}, nil)
 				m. // TODO: Restore these parameters, but with the tags as well
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
-					DoAndReturn(func(ctx context.Context, input *ec2.RunInstancesInput, requestOptions ...request.Option) (*ec2.Reservation, error) {
+					RunInstances(context.TODO(), gomock.Any()).
+					DoAndReturn(func(ctx context.Context, input *ec2.RunInstancesInput, requestOptions ...request.Option) (*ec2.RunInstancesOutput, error) {
 						if input.KeyName == nil {
 							t.Fatal("Expected key name not to be nil")
 						}
 						if *input.KeyName != "specific-machine-ssh-key-name" {
 							t.Fatalf("Expected SSH key name to be '%s', not '%s'", "specific-machine-ssh-key-name", *input.KeyName)
 						}
-						return &ec2.Reservation{
-							Instances: []*ec2.Instance{
+						return &ec2.RunInstancesOutput{
+							Instances: []types.Instance{
 								{
-									State: &ec2.InstanceState{
-										Name: aws.String(ec2.InstanceStateNamePending),
+									State: &types.InstanceState{
+										Name: types.InstanceStateNamePending,
 									},
-									IamInstanceProfile: &ec2.IamInstanceProfile{
+									IamInstanceProfile: &types.IamInstanceProfile{
 										Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 									},
 									InstanceId:     aws.String("two"),
-									InstanceType:   aws.String("m5.large"),
+									InstanceType:   types.InstanceTypeM5Large,
 									SubnetId:       aws.String("subnet-1"),
 									ImageId:        aws.String("ami-1"),
 									RootDeviceName: aws.String("device-1"),
-									BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+									BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 										{
 											DeviceName: aws.String("device-1"),
-											Ebs: &ec2.EbsInstanceBlockDevice{
+											Ebs: &types.EbsInstanceBlockDevice{
 												VolumeId: aws.String("volume-1"),
 											},
 										},
 									},
-									Placement: &ec2.Placement{
+									Placement: &types.Placement{
 										AvailabilityZone: &az,
 									},
 								},
@@ -4754,9 +4756,9 @@ func TestCreateInstance(t *testing.T) {
 						}, nil
 					})
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -4823,26 +4825,26 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeImagesWithContext(context.TODO(), gomock.Any()).
+					DescribeImages(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeImagesOutput{
-						Images: []*ec2.Image{
+						Images: []types.Image{
 							{
 								Name:         aws.String("ami-1"),
 								CreationDate: aws.String("2011-02-08T17:02:31.000Z"),
@@ -4850,34 +4852,34 @@ func TestCreateInstance(t *testing.T) {
 						},
 					}, nil)
 				m. // TODO: Restore these parameters, but with the tags as well
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
-					DoAndReturn(func(ctx context.Context, input *ec2.RunInstancesInput, requestOptions ...request.Option) (*ec2.Reservation, error) {
+					RunInstances(context.TODO(), gomock.Any()).
+					DoAndReturn(func(ctx context.Context, input *ec2.RunInstancesInput, requestOptions ...request.Option) (*ec2.RunInstancesOutput, error) {
 						if input.KeyName != nil {
 							t.Fatalf("Expected key name to be nil/unspecified, not '%s'", *input.KeyName)
 						}
-						return &ec2.Reservation{
-							Instances: []*ec2.Instance{
+						return &ec2.RunInstancesOutput{
+							Instances: []types.Instance{
 								{
-									State: &ec2.InstanceState{
-										Name: aws.String(ec2.InstanceStateNamePending),
+									State: &types.InstanceState{
+										Name: types.InstanceStateNamePending,
 									},
-									IamInstanceProfile: &ec2.IamInstanceProfile{
+									IamInstanceProfile: &types.IamInstanceProfile{
 										Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 									},
 									InstanceId:     aws.String("two"),
-									InstanceType:   aws.String("m5.large"),
+									InstanceType:   types.InstanceTypeM5Large,
 									SubnetId:       aws.String("subnet-1"),
 									ImageId:        aws.String("ami-1"),
 									RootDeviceName: aws.String("device-1"),
-									BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+									BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 										{
 											DeviceName: aws.String("device-1"),
-											Ebs: &ec2.EbsInstanceBlockDevice{
+											Ebs: &types.EbsInstanceBlockDevice{
 												VolumeId: aws.String("volume-1"),
 											},
 										},
 									},
-									Placement: &ec2.Placement{
+									Placement: &types.Placement{
 										AvailabilityZone: &az,
 									},
 								},
@@ -4885,9 +4887,9 @@ func TestCreateInstance(t *testing.T) {
 						}, nil
 					})
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -4954,26 +4956,26 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeImagesWithContext(context.TODO(), gomock.Any()).
+					DescribeImages(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeImagesOutput{
-						Images: []*ec2.Image{
+						Images: []types.Image{
 							{
 								Name:         aws.String("ami-1"),
 								CreationDate: aws.String("2011-02-08T17:02:31.000Z"),
@@ -4981,34 +4983,34 @@ func TestCreateInstance(t *testing.T) {
 						},
 					}, nil)
 				m. // TODO: Restore these parameters, but with the tags as well
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
-					DoAndReturn(func(ctx context.Context, input *ec2.RunInstancesInput, requestOptions ...request.Option) (*ec2.Reservation, error) {
+					RunInstances(context.TODO(), gomock.Any()).
+					DoAndReturn(func(ctx context.Context, input *ec2.RunInstancesInput, requestOptions ...request.Option) (*ec2.RunInstancesOutput, error) {
 						if input.KeyName != nil {
 							t.Fatalf("Expected key name to be nil/unspecified, not '%s'", *input.KeyName)
 						}
-						return &ec2.Reservation{
-							Instances: []*ec2.Instance{
+						return &ec2.RunInstancesOutput{
+							Instances: []types.Instance{
 								{
-									State: &ec2.InstanceState{
-										Name: aws.String(ec2.InstanceStateNamePending),
+									State: &types.InstanceState{
+										Name: types.InstanceStateNamePending,
 									},
-									IamInstanceProfile: &ec2.IamInstanceProfile{
+									IamInstanceProfile: &types.IamInstanceProfile{
 										Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 									},
 									InstanceId:     aws.String("two"),
-									InstanceType:   aws.String("m5.large"),
+									InstanceType:   types.InstanceTypeM5Large,
 									SubnetId:       aws.String("subnet-1"),
 									ImageId:        aws.String("ami-1"),
 									RootDeviceName: aws.String("device-1"),
-									BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+									BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 										{
 											DeviceName: aws.String("device-1"),
-											Ebs: &ec2.EbsInstanceBlockDevice{
+											Ebs: &types.EbsInstanceBlockDevice{
 												VolumeId: aws.String("volume-1"),
 											},
 										},
 									},
-									Placement: &ec2.Placement{
+									Placement: &types.Placement{
 										AvailabilityZone: &az,
 									},
 								},
@@ -5016,9 +5018,9 @@ func TestCreateInstance(t *testing.T) {
 						}, nil
 					})
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -5085,26 +5087,26 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeImagesWithContext(context.TODO(), gomock.Any()).
+					DescribeImages(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeImagesOutput{
-						Images: []*ec2.Image{
+						Images: []types.Image{
 							{
 								Name:         aws.String("ami-1"),
 								CreationDate: aws.String("2011-02-08T17:02:31.000Z"),
@@ -5112,34 +5114,34 @@ func TestCreateInstance(t *testing.T) {
 						},
 					}, nil)
 				m. // TODO: Restore these parameters, but with the tags as well
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
-					DoAndReturn(func(ctx context.Context, input *ec2.RunInstancesInput, requestOptions ...request.Option) (*ec2.Reservation, error) {
+					RunInstances(context.TODO(), gomock.Any()).
+					DoAndReturn(func(ctx context.Context, input *ec2.RunInstancesInput, requestOptions ...request.Option) (*ec2.RunInstancesOutput, error) {
 						if input.KeyName != nil {
 							t.Fatalf("Expected key name to be nil/unspecified, not '%s'", *input.KeyName)
 						}
-						return &ec2.Reservation{
-							Instances: []*ec2.Instance{
+						return &ec2.RunInstancesOutput{
+							Instances: []types.Instance{
 								{
-									State: &ec2.InstanceState{
-										Name: aws.String(ec2.InstanceStateNamePending),
+									State: &types.InstanceState{
+										Name: types.InstanceStateNamePending,
 									},
-									IamInstanceProfile: &ec2.IamInstanceProfile{
+									IamInstanceProfile: &types.IamInstanceProfile{
 										Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 									},
 									InstanceId:     aws.String("two"),
-									InstanceType:   aws.String("m5.large"),
+									InstanceType:   types.InstanceTypeM5Large,
 									SubnetId:       aws.String("subnet-1"),
 									ImageId:        aws.String("ami-1"),
 									RootDeviceName: aws.String("device-1"),
-									BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+									BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 										{
 											DeviceName: aws.String("device-1"),
-											Ebs: &ec2.EbsInstanceBlockDevice{
+											Ebs: &types.EbsInstanceBlockDevice{
 												VolumeId: aws.String("volume-1"),
 											},
 										},
 									},
-									Placement: &ec2.Placement{
+									Placement: &types.Placement{
 										AvailabilityZone: &az,
 									},
 								},
@@ -5147,9 +5149,9 @@ func TestCreateInstance(t *testing.T) {
 						}, nil
 					})
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -5216,33 +5218,33 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m. // TODO: Restore these parameters, but with the tags as well
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+					RunInstances(context.TODO(), gomock.Any()).
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNamePending),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNamePending,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("two"),
-								InstanceType:   aws.String("m5.large"),
+								InstanceType:   types.InstanceTypeM5Large,
 								SubnetId:       aws.String("subnet-1"),
 								ImageId:        aws.String("ami-1"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: &az,
 								},
-								NetworkInterfaces: []*ec2.InstanceNetworkInterface{
+								NetworkInterfaces: []types.InstanceNetworkInterface{
 									{
 										NetworkInterfaceId: aws.String("eni-1"),
 										PrivateIpAddress:   aws.String("192.168.1.10"),
@@ -5254,51 +5256,51 @@ func TestCreateInstance(t *testing.T) {
 						},
 					}, nil)
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 					}, nil)
 				m.
-					DescribeVpcs(&ec2.DescribeVpcsInput{
-						VpcIds: []*string{aws.String("vpc-exists")},
+					DescribeVpcs(context.TODO(), &ec2.DescribeVpcsInput{
+						VpcIds: []string{"vpc-exists"},
 					}).Return(&ec2.DescribeVpcsOutput{
-					Vpcs: []*ec2.Vpc{
+					Vpcs: []types.Vpc{
 						{
 							VpcId:         aws.String("vpc-exists"),
 							CidrBlock:     aws.String("192.168.1.0/24"),
 							IsDefault:     aws.Bool(false),
-							State:         aws.String("available"),
+							State:         types.VpcStateAvailable,
 							DhcpOptionsId: aws.String("dopt-12345678"),
 						},
 					},
 				}, nil)
 				m.
-					DescribeDhcpOptions(&ec2.DescribeDhcpOptionsInput{
-						DhcpOptionsIds: []*string{aws.String("dopt-12345678")},
+					DescribeDhcpOptions(context.TODO(), &ec2.DescribeDhcpOptionsInput{
+						DhcpOptionsIds: []string{"dopt-12345678"},
 					}).Return(&ec2.DescribeDhcpOptionsOutput{
-					DhcpOptions: []*ec2.DhcpOptions{
+					DhcpOptions: []types.DhcpOptions{
 						{
-							DhcpConfigurations: []*ec2.DhcpConfiguration{
+							DhcpConfigurations: []types.DhcpConfiguration{
 								{
 									Key: aws.String("domain-name"),
-									Values: []*ec2.AttributeValue{
+									Values: []types.AttributeValue{
 										{
 											Value: aws.String("example.com"),
 										},
@@ -5385,58 +5387,58 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m. // TODO: Restore these parameters, but with the tags as well
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+					RunInstances(context.TODO(), gomock.Any()).
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNamePending),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNamePending,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("two"),
-								InstanceType:   aws.String("m5.large"),
+								InstanceType:   types.InstanceTypeM5Large,
 								SubnetId:       aws.String("subnet-1"),
 								ImageId:        aws.String("ami-1"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: &az,
 								},
-								InstanceLifecycle:     aws.String(ec2.MarketTypeCapacityBlock),
+								InstanceLifecycle:     types.InstanceLifecycleTypeCapacityBlock,
 								CapacityReservationId: aws.String("cr-12345678901234567"),
 							},
 						},
 					}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -5504,17 +5506,17 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
@@ -5590,58 +5592,58 @@ func TestCreateInstance(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				m.
-					DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-						InstanceTypes: []*string{
-							aws.String("m5.large"),
+					DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+						InstanceTypes: []types.InstanceType{
+							types.InstanceTypeM5Large,
 						},
 					})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &types.ProcessorInfo{
+									SupportedArchitectures: []types.ArchitectureType{
+										types.ArchitectureTypeX8664,
 									},
 								},
 							},
 						},
 					}, nil)
 				m. // TODO: Restore these parameters, but with the tags as well
-					RunInstancesWithContext(context.TODO(), gomock.Any()).
-					Return(&ec2.Reservation{
-						Instances: []*ec2.Instance{
+					RunInstances(context.TODO(), gomock.Any()).
+					Return(&ec2.RunInstancesOutput{
+						Instances: []types.Instance{
 							{
-								State: &ec2.InstanceState{
-									Name: aws.String(ec2.InstanceStateNamePending),
+								State: &types.InstanceState{
+									Name: types.InstanceStateNamePending,
 								},
-								IamInstanceProfile: &ec2.IamInstanceProfile{
+								IamInstanceProfile: &types.IamInstanceProfile{
 									Arn: aws.String("arn:aws:iam::123456789012:instance-profile/foo"),
 								},
 								InstanceId:     aws.String("two"),
-								InstanceType:   aws.String("m5.large"),
+								InstanceType:   types.InstanceTypeM5Large,
 								SubnetId:       aws.String("subnet-1"),
 								ImageId:        aws.String("ami-1"),
 								RootDeviceName: aws.String("device-1"),
-								BlockDeviceMappings: []*ec2.InstanceBlockDeviceMapping{
+								BlockDeviceMappings: []types.InstanceBlockDeviceMapping{
 									{
 										DeviceName: aws.String("device-1"),
-										Ebs: &ec2.EbsInstanceBlockDevice{
+										Ebs: &types.EbsInstanceBlockDevice{
 											VolumeId: aws.String("volume-1"),
 										},
 									},
 								},
-								Placement: &ec2.Placement{
+								Placement: &types.Placement{
 									AvailabilityZone: &az,
 								},
 								CapacityReservationId: aws.String("cr-12345678901234567"),
-								InstanceLifecycle:     aws.String("scheduled"),
+								InstanceLifecycle:     types.InstanceLifecycleTypeScheduled,
 							},
 						},
 					}, nil)
 				m.
-					DescribeNetworkInterfacesWithContext(context.TODO(), gomock.Any()).
+					DescribeNetworkInterfaces(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeNetworkInterfacesOutput{
-						NetworkInterfaces: []*ec2.NetworkInterface{},
+						NetworkInterfaces: []types.NetworkInterface{},
 						NextToken:         nil,
 					}, nil)
 			},
@@ -5731,7 +5733,7 @@ func TestGetInstanceMarketOptionsRequest(t *testing.T) {
 	testCases := []struct {
 		name            string
 		instance        *infrav1.Instance
-		expectedRequest *ec2.InstanceMarketOptionsRequest
+		expectedRequest *types.InstanceMarketOptionsRequest
 		expectedError   error
 	}{
 		{
@@ -5761,11 +5763,11 @@ func TestGetInstanceMarketOptionsRequest(t *testing.T) {
 			instance: &infrav1.Instance{
 				SpotMarketOptions: &infrav1.SpotMarketOptions{},
 			},
-			expectedRequest: &ec2.InstanceMarketOptionsRequest{
-				MarketType: aws.String(ec2.MarketTypeSpot),
-				SpotOptions: &ec2.SpotMarketOptions{
-					InstanceInterruptionBehavior: aws.String(ec2.InstanceInterruptionBehaviorTerminate),
-					SpotInstanceType:             aws.String(ec2.SpotInstanceTypeOneTime),
+			expectedRequest: &types.InstanceMarketOptionsRequest{
+				MarketType: types.MarketTypeSpot,
+				SpotOptions: &types.SpotMarketOptions{
+					InstanceInterruptionBehavior: types.InstanceInterruptionBehaviorTerminate,
+					SpotInstanceType:             types.SpotInstanceTypeOneTime,
 				},
 			},
 			expectedError: nil,
@@ -5775,11 +5777,11 @@ func TestGetInstanceMarketOptionsRequest(t *testing.T) {
 			instance: &infrav1.Instance{
 				MarketType: infrav1.MarketTypeSpot,
 			},
-			expectedRequest: &ec2.InstanceMarketOptionsRequest{
-				MarketType: aws.String(ec2.MarketTypeSpot),
-				SpotOptions: &ec2.SpotMarketOptions{
-					InstanceInterruptionBehavior: aws.String(ec2.InstanceInterruptionBehaviorTerminate),
-					SpotInstanceType:             aws.String(ec2.SpotInstanceTypeOneTime),
+			expectedRequest: &types.InstanceMarketOptionsRequest{
+				MarketType: types.MarketTypeSpot,
+				SpotOptions: &types.SpotMarketOptions{
+					InstanceInterruptionBehavior: types.InstanceInterruptionBehaviorTerminate,
+					SpotInstanceType:             types.SpotInstanceTypeOneTime,
 				},
 			},
 		},
@@ -5806,11 +5808,11 @@ func TestGetInstanceMarketOptionsRequest(t *testing.T) {
 					MaxPrice: aws.String(""),
 				},
 			},
-			expectedRequest: &ec2.InstanceMarketOptionsRequest{
-				MarketType: aws.String(ec2.MarketTypeSpot),
-				SpotOptions: &ec2.SpotMarketOptions{
-					InstanceInterruptionBehavior: aws.String(ec2.InstanceInterruptionBehaviorTerminate),
-					SpotInstanceType:             aws.String(ec2.SpotInstanceTypeOneTime),
+			expectedRequest: &types.InstanceMarketOptionsRequest{
+				MarketType: types.MarketTypeSpot,
+				SpotOptions: &types.SpotMarketOptions{
+					InstanceInterruptionBehavior: types.InstanceInterruptionBehaviorTerminate,
+					SpotInstanceType:             types.SpotInstanceTypeOneTime,
 				},
 			},
 			expectedError: nil,
@@ -5822,11 +5824,11 @@ func TestGetInstanceMarketOptionsRequest(t *testing.T) {
 					MaxPrice: aws.String("0.01"),
 				},
 			},
-			expectedRequest: &ec2.InstanceMarketOptionsRequest{
-				MarketType: aws.String(ec2.MarketTypeSpot),
-				SpotOptions: &ec2.SpotMarketOptions{
-					InstanceInterruptionBehavior: aws.String(ec2.InstanceInterruptionBehaviorTerminate),
-					SpotInstanceType:             aws.String(ec2.SpotInstanceTypeOneTime),
+			expectedRequest: &types.InstanceMarketOptionsRequest{
+				MarketType: types.MarketTypeSpot,
+				SpotOptions: &types.SpotMarketOptions{
+					InstanceInterruptionBehavior: types.InstanceInterruptionBehaviorTerminate,
+					SpotInstanceType:             types.SpotInstanceTypeOneTime,
 					MaxPrice:                     aws.String("0.01"),
 				},
 			},
@@ -5853,8 +5855,8 @@ func TestGetInstanceMarketOptionsRequest(t *testing.T) {
 				MarketType:            infrav1.MarketTypeCapacityBlock,
 				CapacityReservationID: mockCapacityReservationID,
 			},
-			expectedRequest: &ec2.InstanceMarketOptionsRequest{
-				MarketType: aws.String(ec2.MarketTypeCapacityBlock),
+			expectedRequest: &types.InstanceMarketOptionsRequest{
+				MarketType: types.MarketTypeCapacityBlock,
 			},
 			expectedError: nil,
 		},
@@ -5908,16 +5910,16 @@ func TestGetFilteredSecurityGroupID(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSecurityGroupsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSecurityGroupsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSecurityGroups(context.TODO(), gomock.Eq(&ec2.DescribeSecurityGroupsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String(securityGroupFilterName),
-							Values: aws.StringSlice(securityGroupFilterValues),
+							Values: securityGroupFilterValues,
 						},
 					},
 				})).Return(
 					&ec2.DescribeSecurityGroupsOutput{
-						SecurityGroups: []*ec2.SecurityGroup{
+						SecurityGroups: []types.SecurityGroup{
 							{
 								GroupId: aws.String(securityGroupID),
 							},
@@ -5944,16 +5946,16 @@ func TestGetFilteredSecurityGroupID(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSecurityGroupsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSecurityGroupsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSecurityGroups(context.TODO(), gomock.Eq(&ec2.DescribeSecurityGroupsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String(securityGroupFilterName),
-							Values: aws.StringSlice(securityGroupFilterValues),
+							Values: securityGroupFilterValues,
 						},
 					},
 				})).Return(
 					&ec2.DescribeSecurityGroupsOutput{
-						SecurityGroups: []*ec2.SecurityGroup{
+						SecurityGroups: []types.SecurityGroup{
 							{
 								GroupId: aws.String(securityGroupID),
 							},
@@ -6002,11 +6004,11 @@ func TestGetFilteredSecurityGroupID(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSecurityGroupsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSecurityGroupsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSecurityGroups(context.TODO(), gomock.Eq(&ec2.DescribeSecurityGroupsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String(securityGroupFilterName),
-							Values: aws.StringSlice(securityGroupFilterValues),
+							Values: securityGroupFilterValues,
 						},
 					},
 				})).Return(nil, errors.New("some error"))
@@ -6027,16 +6029,16 @@ func TestGetFilteredSecurityGroupID(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSecurityGroupsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSecurityGroupsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSecurityGroups(context.TODO(), gomock.Eq(&ec2.DescribeSecurityGroupsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String(securityGroupFilterName),
-							Values: aws.StringSlice(securityGroupFilterValues),
+							Values: securityGroupFilterValues,
 						},
 					},
 				})).Return(
 					&ec2.DescribeSecurityGroupsOutput{
-						SecurityGroups: []*ec2.SecurityGroup{},
+						SecurityGroups: []types.SecurityGroup{},
 					}, nil)
 			},
 			check: func(ids []string, err error) {
@@ -6069,18 +6071,18 @@ func TestGetDHCPOptionSetDomainName(t *testing.T) {
 	testsCases := []struct {
 		name                   string
 		vpcID                  string
-		dhcpOpt                *ec2.DhcpOptions
+		dhcpOpt                *types.DhcpOptions
 		expectedPrivateDNSName *string
 		mockCalls              func(m *mocks.MockEC2APIMockRecorder)
 	}{
 		{
 			name:  "dhcpOptions with domain-name",
 			vpcID: "vpc-exists",
-			dhcpOpt: &ec2.DhcpOptions{
-				DhcpConfigurations: []*ec2.DhcpConfiguration{
+			dhcpOpt: &types.DhcpOptions{
+				DhcpConfigurations: []types.DhcpConfiguration{
 					{
 						Key: aws.String("domain-name"),
-						Values: []*ec2.AttributeValue{
+						Values: []types.AttributeValue{
 							{
 								Value: aws.String("example.com"),
 							},
@@ -6094,11 +6096,11 @@ func TestGetDHCPOptionSetDomainName(t *testing.T) {
 		{
 			name:  "dhcpOptions without domain-name",
 			vpcID: "vpc-empty-domain-name",
-			dhcpOpt: &ec2.DhcpOptions{
-				DhcpConfigurations: []*ec2.DhcpConfiguration{
+			dhcpOpt: &types.DhcpOptions{
+				DhcpConfigurations: []types.DhcpConfiguration{
 					{
 						Key:    aws.String("domain-name"),
-						Values: []*ec2.AttributeValue{},
+						Values: []types.AttributeValue{},
 					},
 				},
 			},
@@ -6147,28 +6149,28 @@ func TestGetDHCPOptionSetDomainName(t *testing.T) {
 }
 
 func mockedGetPrivateDNSDomainNameFromDHCPOptionsCalls(m *mocks.MockEC2APIMockRecorder) {
-	m.DescribeVpcs(&ec2.DescribeVpcsInput{
-		VpcIds: []*string{aws.String("vpc-exists")},
+	m.DescribeVpcs(context.TODO(), &ec2.DescribeVpcsInput{
+		VpcIds: []string{"vpc-exists"},
 	}).Return(&ec2.DescribeVpcsOutput{
-		Vpcs: []*ec2.Vpc{
+		Vpcs: []types.Vpc{
 			{
 				VpcId:         aws.String("vpc-exists"),
 				CidrBlock:     aws.String("10.0.0.0/16"),
 				IsDefault:     aws.Bool(false),
-				State:         aws.String("available"),
+				State:         types.VpcStateAvailable,
 				DhcpOptionsId: aws.String("dopt-12345678"),
 			},
 		},
 	}, nil)
-	m.DescribeDhcpOptions(&ec2.DescribeDhcpOptionsInput{
-		DhcpOptionsIds: []*string{aws.String("dopt-12345678")},
+	m.DescribeDhcpOptions(context.TODO(), &ec2.DescribeDhcpOptionsInput{
+		DhcpOptionsIds: []string{"dopt-12345678"},
 	}).Return(&ec2.DescribeDhcpOptionsOutput{
-		DhcpOptions: []*ec2.DhcpOptions{
+		DhcpOptions: []types.DhcpOptions{
 			{
-				DhcpConfigurations: []*ec2.DhcpConfiguration{
+				DhcpConfigurations: []types.DhcpConfiguration{
 					{
 						Key: aws.String("domain-name"),
-						Values: []*ec2.AttributeValue{
+						Values: []types.AttributeValue{
 							{
 								Value: aws.String("example.com"),
 							},
@@ -6181,28 +6183,28 @@ func mockedGetPrivateDNSDomainNameFromDHCPOptionsCalls(m *mocks.MockEC2APIMockRe
 }
 
 func mockedGetPrivateDNSDomainNameFromDHCPOptionsEmptyCalls(m *mocks.MockEC2APIMockRecorder) {
-	m.DescribeVpcs(&ec2.DescribeVpcsInput{
-		VpcIds: []*string{aws.String("vpc-empty-domain-name")},
+	m.DescribeVpcs(context.TODO(), &ec2.DescribeVpcsInput{
+		VpcIds: []string{"vpc-empty-domain-name"},
 	}).Return(&ec2.DescribeVpcsOutput{
-		Vpcs: []*ec2.Vpc{
+		Vpcs: []types.Vpc{
 			{
 				VpcId:         aws.String("vpc-exists"),
 				CidrBlock:     aws.String("10.0.0.0/16"),
 				IsDefault:     aws.Bool(false),
-				State:         aws.String("available"),
+				State:         types.VpcStateAvailable,
 				DhcpOptionsId: aws.String("dopt-empty"),
 			},
 		},
 	}, nil)
-	m.DescribeDhcpOptions(&ec2.DescribeDhcpOptionsInput{
-		DhcpOptionsIds: []*string{aws.String("dopt-empty")},
+	m.DescribeDhcpOptions(context.TODO(), &ec2.DescribeDhcpOptionsInput{
+		DhcpOptionsIds: []string{"dopt-empty"},
 	}).Return(&ec2.DescribeDhcpOptionsOutput{
-		DhcpOptions: []*ec2.DhcpOptions{
+		DhcpOptions: []types.DhcpOptions{
 			{
-				DhcpConfigurations: []*ec2.DhcpConfiguration{
+				DhcpConfigurations: []types.DhcpConfiguration{
 					{
 						Key:    aws.String("domain-name"),
-						Values: []*ec2.AttributeValue{},
+						Values: []types.AttributeValue{},
 					},
 				},
 			},
@@ -6216,7 +6218,7 @@ func TestGetCapacityReservationSpecification(t *testing.T) {
 	testCases := []struct {
 		name                  string
 		capacityReservationID *string
-		expectedRequest       *ec2.CapacityReservationSpecification
+		expectedRequest       *types.CapacityReservationSpecification
 	}{
 		{
 			name:                  "with no CapacityReservationID options specified",
@@ -6226,8 +6228,8 @@ func TestGetCapacityReservationSpecification(t *testing.T) {
 		{
 			name:                  "with a valid CapacityReservationID specified",
 			capacityReservationID: mockCapacityReservationIDPtr,
-			expectedRequest: &ec2.CapacityReservationSpecification{
-				CapacityReservationTarget: &ec2.CapacityReservationTarget{
+			expectedRequest: &types.CapacityReservationSpecification{
+				CapacityReservationTarget: &types.CapacityReservationTarget{
 					CapacityReservationId: aws.String(mockCapacityReservationID),
 				},
 			},
@@ -6236,7 +6238,7 @@ func TestGetCapacityReservationSpecification(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			request := getCapacityReservationSpecification(tc.capacityReservationID)
-			if !cmp.Equal(request, tc.expectedRequest) {
+			if !cmp.Equal(request, tc.expectedRequest, cmpopts.IgnoreUnexported(types.CapacityReservationSpecification{}, types.CapacityReservationTarget{})) {
 				t.Errorf("Case: %s. Got: %v, expected: %v", tc.name, request, tc.expectedRequest)
 			}
 		})
diff --git a/pkg/cloud/services/ec2/launchtemplate_test.go b/pkg/cloud/services/ec2/launchtemplate_test.go
index 68e3ab52b..39098948f 100644
--- a/pkg/cloud/services/ec2/launchtemplate_test.go
+++ b/pkg/cloud/services/ec2/launchtemplate_test.go
@@ -21,14 +21,17 @@ import (
 	"encoding/base64"
 	"testing"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go-v2/service/ssm"
 	ssmtypes "github.com/aws/aws-sdk-go-v2/service/ssm/types"
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/aws/smithy-go"
 	"github.com/golang/mock/gomock"
 	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
 	. "github.com/onsi/gomega"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
@@ -84,18 +87,19 @@ var testUserDataHash = userdata.ComputeHash([]byte(testUserData))
 var testBootstrapData = []byte("different from testUserData since bootstrap data may be in S3 while EC2 user data points to that S3 object")
 var testBootstrapDataHash = userdata.ComputeHash(testBootstrapData)
 
-func defaultEC2AndDataTags(name string, clusterName string, userDataSecretKey types.NamespacedName, bootstrapDataHash string) []*ec2.Tag {
+func defaultEC2AndDataTags(name string, clusterName string, userDataSecretKey types.NamespacedName, bootstrapDataHash string) []ec2types.Tag {
 	tags := defaultEC2Tags(name, clusterName)
 	tags = append(
 		tags,
-		&ec2.Tag{
+		ec2types.Tag{
 			Key:   aws.String(infrav1.LaunchTemplateBootstrapDataSecret),
 			Value: aws.String(userDataSecretKey.String()),
 		},
-		&ec2.Tag{
+		ec2types.Tag{
 			Key:   aws.String(infrav1.LaunchTemplateBootstrapDataHash),
 			Value: aws.String(bootstrapDataHash),
 		})
+
 	sortTags(tags)
 	return tags
 }
@@ -122,15 +126,14 @@ func TestGetLaunchTemplate(t *testing.T) {
 			name:               "Should not return error if no launch template exist with given name",
 			launchTemplateName: "foo",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeLaunchTemplateVersionsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeLaunchTemplateVersionsInput{
+				m.DescribeLaunchTemplateVersions(context.TODO(), gomock.Eq(&ec2.DescribeLaunchTemplateVersionsInput{
 					LaunchTemplateName: aws.String("foo"),
-					Versions:           []*string{aws.String("$Latest")},
+					Versions:           []string{"$Latest"},
 				})).
-					Return(nil, awserr.New(
-						awserrors.LaunchTemplateNameNotFound,
-						"The specified launch template, with template name foo, does not exist.",
-						nil,
-					))
+					Return(nil, &smithy.GenericAPIError{
+						Code:    awserrors.LaunchTemplateNameNotFound,
+						Message: "The specified launch template, with template name foo, does not exist.",
+					})
 			},
 			check: func(g *WithT, launchTemplate *expinfrav1.AWSLaunchTemplate, userDataHash string, err error) {
 				g.Expect(err).NotTo(HaveOccurred())
@@ -142,9 +145,9 @@ func TestGetLaunchTemplate(t *testing.T) {
 			name:               "Should return error if AWS failed during launch template fetching",
 			launchTemplateName: "foo",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeLaunchTemplateVersionsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeLaunchTemplateVersionsInput{
+				m.DescribeLaunchTemplateVersions(context.TODO(), gomock.Eq(&ec2.DescribeLaunchTemplateVersionsInput{
 					LaunchTemplateName: aws.String("foo"),
-					Versions:           []*string{aws.String("$Latest")},
+					Versions:           []string{"$Latest"},
 				})).Return(nil, awserrors.NewFailedDependency("dependency failure"))
 			},
 			check: func(g *WithT, launchTemplate *expinfrav1.AWSLaunchTemplate, userDataHash string, err error) {
@@ -157,9 +160,9 @@ func TestGetLaunchTemplate(t *testing.T) {
 			name:               "Should not return with error if no launch template versions received from AWS",
 			launchTemplateName: "foo",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeLaunchTemplateVersionsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeLaunchTemplateVersionsInput{
+				m.DescribeLaunchTemplateVersions(context.TODO(), gomock.Eq(&ec2.DescribeLaunchTemplateVersionsInput{
 					LaunchTemplateName: aws.String("foo"),
-					Versions:           []*string{aws.String("$Latest")},
+					Versions:           []string{"$Latest"},
 				})).Return(nil, nil)
 			},
 			check: func(g *WithT, launchTemplate *expinfrav1.AWSLaunchTemplate, userDataHash string, err error) {
@@ -172,35 +175,35 @@ func TestGetLaunchTemplate(t *testing.T) {
 			name:               "Should successfully return launch template if exist with given name",
 			launchTemplateName: "foo",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeLaunchTemplateVersionsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeLaunchTemplateVersionsInput{
+				m.DescribeLaunchTemplateVersions(context.TODO(), gomock.Eq(&ec2.DescribeLaunchTemplateVersionsInput{
 					LaunchTemplateName: aws.String("foo"),
-					Versions:           []*string{aws.String("$Latest")},
+					Versions:           []string{"$Latest"},
 				})).Return(&ec2.DescribeLaunchTemplateVersionsOutput{
-					LaunchTemplateVersions: []*ec2.LaunchTemplateVersion{
+					LaunchTemplateVersions: []ec2types.LaunchTemplateVersion{
 						{
 							LaunchTemplateId:   aws.String("lt-12345"),
 							LaunchTemplateName: aws.String("foo"),
-							LaunchTemplateData: &ec2.ResponseLaunchTemplateData{
-								SecurityGroupIds: []*string{aws.String("sg-id")},
+							LaunchTemplateData: &ec2types.ResponseLaunchTemplateData{
+								SecurityGroupIds: []string{"sg-id"},
 								ImageId:          aws.String("foo-image"),
-								IamInstanceProfile: &ec2.LaunchTemplateIamInstanceProfileSpecification{
+								IamInstanceProfile: &ec2types.LaunchTemplateIamInstanceProfileSpecification{
 									Arn: aws.String("instance-profile/foo-profile"),
 								},
 								KeyName: aws.String("foo-keyname"),
-								BlockDeviceMappings: []*ec2.LaunchTemplateBlockDeviceMapping{
+								BlockDeviceMappings: []ec2types.LaunchTemplateBlockDeviceMapping{
 									{
 										DeviceName: aws.String("foo-device"),
-										Ebs: &ec2.LaunchTemplateEbsBlockDevice{
+										Ebs: &ec2types.LaunchTemplateEbsBlockDevice{
 											Encrypted:  aws.Bool(true),
-											VolumeSize: aws.Int64(16),
-											VolumeType: aws.String("cool"),
+											VolumeSize: aws.Int32(16),
+											VolumeType: ec2types.VolumeTypeGp2,
 										},
 									},
 								},
-								NetworkInterfaces: []*ec2.LaunchTemplateInstanceNetworkInterfaceSpecification{
+								NetworkInterfaces: []ec2types.LaunchTemplateInstanceNetworkInterfaceSpecification{
 									{
-										DeviceIndex: aws.Int64(1),
-										Groups:      []*string{aws.String("foo-group")},
+										DeviceIndex: aws.Int32(1),
+										Groups:      []string{"foo-group"},
 									},
 								},
 								UserData: aws.String(base64.StdEncoding.EncodeToString([]byte(testUserData))),
@@ -231,35 +234,35 @@ func TestGetLaunchTemplate(t *testing.T) {
 			name:               "Should return computed userData if AWS returns empty userData",
 			launchTemplateName: "foo",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeLaunchTemplateVersionsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeLaunchTemplateVersionsInput{
+				m.DescribeLaunchTemplateVersions(context.TODO(), gomock.Eq(&ec2.DescribeLaunchTemplateVersionsInput{
 					LaunchTemplateName: aws.String("foo"),
-					Versions:           []*string{aws.String("$Latest")},
+					Versions:           []string{"$Latest"},
 				})).Return(&ec2.DescribeLaunchTemplateVersionsOutput{
-					LaunchTemplateVersions: []*ec2.LaunchTemplateVersion{
+					LaunchTemplateVersions: []ec2types.LaunchTemplateVersion{
 						{
 							LaunchTemplateId:   aws.String("lt-12345"),
 							LaunchTemplateName: aws.String("foo"),
-							LaunchTemplateData: &ec2.ResponseLaunchTemplateData{
-								SecurityGroupIds: []*string{aws.String("sg-id")},
+							LaunchTemplateData: &ec2types.ResponseLaunchTemplateData{
+								SecurityGroupIds: []string{"sg-id"},
 								ImageId:          aws.String("foo-image"),
-								IamInstanceProfile: &ec2.LaunchTemplateIamInstanceProfileSpecification{
+								IamInstanceProfile: &ec2types.LaunchTemplateIamInstanceProfileSpecification{
 									Arn: aws.String("instance-profile/foo-profile"),
 								},
 								KeyName: aws.String("foo-keyname"),
-								BlockDeviceMappings: []*ec2.LaunchTemplateBlockDeviceMapping{
+								BlockDeviceMappings: []ec2types.LaunchTemplateBlockDeviceMapping{
 									{
 										DeviceName: aws.String("foo-device"),
-										Ebs: &ec2.LaunchTemplateEbsBlockDevice{
+										Ebs: &ec2types.LaunchTemplateEbsBlockDevice{
 											Encrypted:  aws.Bool(true),
-											VolumeSize: aws.Int64(16),
-											VolumeType: aws.String("cool"),
+											VolumeSize: aws.Int32(16),
+											VolumeType: ec2types.VolumeTypeGp2,
 										},
 									},
 								},
-								NetworkInterfaces: []*ec2.LaunchTemplateInstanceNetworkInterfaceSpecification{
+								NetworkInterfaces: []ec2types.LaunchTemplateInstanceNetworkInterfaceSpecification{
 									{
-										DeviceIndex: aws.Int64(1),
-										Groups:      []*string{aws.String("foo-group")},
+										DeviceIndex: aws.Int32(1),
+										Groups:      []string{"foo-group"},
 									},
 								},
 							},
@@ -314,7 +317,7 @@ func TestGetLaunchTemplate(t *testing.T) {
 func TestServiceSDKToLaunchTemplate(t *testing.T) {
 	tests := []struct {
 		name                  string
-		input                 *ec2.LaunchTemplateVersion
+		input                 ec2types.LaunchTemplateVersion
 		wantLT                *expinfrav1.AWSLaunchTemplate
 		wantUserDataHash      string
 		wantDataSecretKey     *types.NamespacedName
@@ -323,29 +326,29 @@ func TestServiceSDKToLaunchTemplate(t *testing.T) {
 	}{
 		{
 			name: "lots of input",
-			input: &ec2.LaunchTemplateVersion{
+			input: ec2types.LaunchTemplateVersion{
 				LaunchTemplateId:   aws.String("lt-12345"),
 				LaunchTemplateName: aws.String("foo"),
-				LaunchTemplateData: &ec2.ResponseLaunchTemplateData{
+				LaunchTemplateData: &ec2types.ResponseLaunchTemplateData{
 					ImageId: aws.String("foo-image"),
-					IamInstanceProfile: &ec2.LaunchTemplateIamInstanceProfileSpecification{
+					IamInstanceProfile: &ec2types.LaunchTemplateIamInstanceProfileSpecification{
 						Arn: aws.String("instance-profile/foo-profile"),
 					},
 					KeyName: aws.String("foo-keyname"),
-					BlockDeviceMappings: []*ec2.LaunchTemplateBlockDeviceMapping{
+					BlockDeviceMappings: []ec2types.LaunchTemplateBlockDeviceMapping{
 						{
 							DeviceName: aws.String("foo-device"),
-							Ebs: &ec2.LaunchTemplateEbsBlockDevice{
+							Ebs: &ec2types.LaunchTemplateEbsBlockDevice{
 								Encrypted:  aws.Bool(true),
-								VolumeSize: aws.Int64(16),
-								VolumeType: aws.String("cool"),
+								VolumeSize: aws.Int32(16),
+								VolumeType: ec2types.VolumeTypeGp2,
 							},
 						},
 					},
-					NetworkInterfaces: []*ec2.LaunchTemplateInstanceNetworkInterfaceSpecification{
+					NetworkInterfaces: []ec2types.LaunchTemplateInstanceNetworkInterfaceSpecification{
 						{
-							DeviceIndex: aws.Int64(1),
-							Groups:      []*string{aws.String("foo-group")},
+							DeviceIndex: aws.Int32(1),
+							Groups:      []string{"foo-group"},
 						},
 					},
 					UserData: aws.String(base64.StdEncoding.EncodeToString([]byte(testUserData))),
@@ -367,18 +370,18 @@ func TestServiceSDKToLaunchTemplate(t *testing.T) {
 		},
 		{
 			name: "spot market options",
-			input: &ec2.LaunchTemplateVersion{
+			input: ec2types.LaunchTemplateVersion{
 				LaunchTemplateId:   aws.String("lt-12345"),
 				LaunchTemplateName: aws.String("foo"),
-				LaunchTemplateData: &ec2.ResponseLaunchTemplateData{
+				LaunchTemplateData: &ec2types.ResponseLaunchTemplateData{
 					ImageId: aws.String("foo-image"),
-					IamInstanceProfile: &ec2.LaunchTemplateIamInstanceProfileSpecification{
+					IamInstanceProfile: &ec2types.LaunchTemplateIamInstanceProfileSpecification{
 						Arn: aws.String("instance-profile/foo-profile"),
 					},
 					KeyName: aws.String("foo-keyname"),
-					InstanceMarketOptions: &ec2.LaunchTemplateInstanceMarketOptions{
-						MarketType: aws.String(ec2.MarketTypeSpot),
-						SpotOptions: &ec2.LaunchTemplateSpotMarketOptions{
+					InstanceMarketOptions: &ec2types.LaunchTemplateInstanceMarketOptions{
+						MarketType: ec2types.MarketTypeSpot,
+						SpotOptions: &ec2types.LaunchTemplateSpotMarketOptions{
 							MaxPrice: aws.String("0.05"),
 						},
 					},
@@ -403,18 +406,18 @@ func TestServiceSDKToLaunchTemplate(t *testing.T) {
 		},
 		{
 			name: "spot market options with no max price",
-			input: &ec2.LaunchTemplateVersion{
+			input: ec2types.LaunchTemplateVersion{
 				LaunchTemplateId:   aws.String("lt-12345"),
 				LaunchTemplateName: aws.String("foo"),
-				LaunchTemplateData: &ec2.ResponseLaunchTemplateData{
+				LaunchTemplateData: &ec2types.ResponseLaunchTemplateData{
 					ImageId: aws.String("foo-image"),
-					IamInstanceProfile: &ec2.LaunchTemplateIamInstanceProfileSpecification{
+					IamInstanceProfile: &ec2types.LaunchTemplateIamInstanceProfileSpecification{
 						Arn: aws.String("instance-profile/foo-profile"),
 					},
 					KeyName: aws.String("foo-keyname"),
-					InstanceMarketOptions: &ec2.LaunchTemplateInstanceMarketOptions{
-						MarketType:  aws.String(ec2.MarketTypeSpot),
-						SpotOptions: &ec2.LaunchTemplateSpotMarketOptions{},
+					InstanceMarketOptions: &ec2types.LaunchTemplateInstanceMarketOptions{
+						MarketType:  ec2types.MarketTypeSpot,
+						SpotOptions: &ec2types.LaunchTemplateSpotMarketOptions{},
 					},
 					UserData: aws.String(base64.StdEncoding.EncodeToString([]byte(testUserData))),
 				},
@@ -435,17 +438,17 @@ func TestServiceSDKToLaunchTemplate(t *testing.T) {
 		},
 		{
 			name: "spot market options without SpotOptions",
-			input: &ec2.LaunchTemplateVersion{
+			input: ec2types.LaunchTemplateVersion{
 				LaunchTemplateId:   aws.String("lt-12345"),
 				LaunchTemplateName: aws.String("foo"),
-				LaunchTemplateData: &ec2.ResponseLaunchTemplateData{
+				LaunchTemplateData: &ec2types.ResponseLaunchTemplateData{
 					ImageId: aws.String("foo-image"),
-					IamInstanceProfile: &ec2.LaunchTemplateIamInstanceProfileSpecification{
+					IamInstanceProfile: &ec2types.LaunchTemplateIamInstanceProfileSpecification{
 						Arn: aws.String("instance-profile/foo-profile"),
 					},
 					KeyName: aws.String("foo-keyname"),
-					InstanceMarketOptions: &ec2.LaunchTemplateInstanceMarketOptions{
-						MarketType: aws.String(ec2.MarketTypeSpot),
+					InstanceMarketOptions: &ec2types.LaunchTemplateInstanceMarketOptions{
+						MarketType: ec2types.MarketTypeSpot,
 					},
 					UserData: aws.String(base64.StdEncoding.EncodeToString([]byte(testUserData))),
 				},
@@ -466,18 +469,18 @@ func TestServiceSDKToLaunchTemplate(t *testing.T) {
 		},
 		{
 			name: "non-spot market type",
-			input: &ec2.LaunchTemplateVersion{
+			input: ec2types.LaunchTemplateVersion{
 				LaunchTemplateId:   aws.String("lt-12345"),
 				LaunchTemplateName: aws.String("foo"),
-				LaunchTemplateData: &ec2.ResponseLaunchTemplateData{
+				LaunchTemplateData: &ec2types.ResponseLaunchTemplateData{
 					ImageId: aws.String("foo-image"),
-					IamInstanceProfile: &ec2.LaunchTemplateIamInstanceProfileSpecification{
+					IamInstanceProfile: &ec2types.LaunchTemplateIamInstanceProfileSpecification{
 						Arn: aws.String("instance-profile/foo-profile"),
 					},
 					KeyName: aws.String("foo-keyname"),
-					InstanceMarketOptions: &ec2.LaunchTemplateInstanceMarketOptions{
-						MarketType: aws.String("different-market-type"),
-						SpotOptions: &ec2.LaunchTemplateSpotMarketOptions{
+					InstanceMarketOptions: &ec2types.LaunchTemplateInstanceMarketOptions{
+						MarketType: ec2types.MarketTypeCapacityBlock,
+						SpotOptions: &ec2types.LaunchTemplateSpotMarketOptions{
 							MaxPrice: aws.String("0.05"),
 						},
 					},
@@ -500,35 +503,35 @@ func TestServiceSDKToLaunchTemplate(t *testing.T) {
 		},
 		{
 			name: "tag of bootstrap secret",
-			input: &ec2.LaunchTemplateVersion{
+			input: ec2types.LaunchTemplateVersion{
 				LaunchTemplateId:   aws.String("lt-12345"),
 				LaunchTemplateName: aws.String("foo"),
-				LaunchTemplateData: &ec2.ResponseLaunchTemplateData{
+				LaunchTemplateData: &ec2types.ResponseLaunchTemplateData{
 					ImageId: aws.String("foo-image"),
-					IamInstanceProfile: &ec2.LaunchTemplateIamInstanceProfileSpecification{
+					IamInstanceProfile: &ec2types.LaunchTemplateIamInstanceProfileSpecification{
 						Arn: aws.String("instance-profile/foo-profile"),
 					},
 					KeyName: aws.String("foo-keyname"),
-					BlockDeviceMappings: []*ec2.LaunchTemplateBlockDeviceMapping{
+					BlockDeviceMappings: []ec2types.LaunchTemplateBlockDeviceMapping{
 						{
 							DeviceName: aws.String("foo-device"),
-							Ebs: &ec2.LaunchTemplateEbsBlockDevice{
+							Ebs: &ec2types.LaunchTemplateEbsBlockDevice{
 								Encrypted:  aws.Bool(true),
-								VolumeSize: aws.Int64(16),
-								VolumeType: aws.String("cool"),
+								VolumeSize: aws.Int32(16),
+								VolumeType: ec2types.VolumeTypeGp2,
 							},
 						},
 					},
-					NetworkInterfaces: []*ec2.LaunchTemplateInstanceNetworkInterfaceSpecification{
+					NetworkInterfaces: []ec2types.LaunchTemplateInstanceNetworkInterfaceSpecification{
 						{
-							DeviceIndex: aws.Int64(1),
-							Groups:      []*string{aws.String("foo-group")},
+							DeviceIndex: aws.Int32(1),
+							Groups:      []string{"foo-group"},
 						},
 					},
-					TagSpecifications: []*ec2.LaunchTemplateTagSpecification{
+					TagSpecifications: []ec2types.LaunchTemplateTagSpecification{
 						{
-							ResourceType: aws.String(ec2.ResourceTypeInstance),
-							Tags: []*ec2.Tag{
+							ResourceType: ec2types.ResourceTypeInstance,
+							Tags: []ec2types.Tag{
 								{
 									Key:   aws.String("sigs.k8s.io/cluster-api-provider-aws/bootstrap-data-secret"),
 									Value: aws.String("bootstrap-secret-ns/bootstrap-secret"),
@@ -698,10 +701,10 @@ func TestServiceLaunchTemplateNeedsUpdate(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSecurityGroupsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSecurityGroupsInput{Filters: []*ec2.Filter{{Name: aws.String("sg-1"), Values: aws.StringSlice([]string{"test-1"})}}})).
-					Return(&ec2.DescribeSecurityGroupsOutput{SecurityGroups: []*ec2.SecurityGroup{{GroupId: aws.String("sg-1")}}}, nil)
-				m.DescribeSecurityGroupsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSecurityGroupsInput{Filters: []*ec2.Filter{{Name: aws.String("sg-2"), Values: aws.StringSlice([]string{"test-2"})}}})).
-					Return(&ec2.DescribeSecurityGroupsOutput{SecurityGroups: []*ec2.SecurityGroup{{GroupId: aws.String("sg-2")}}}, nil)
+				m.DescribeSecurityGroups(context.TODO(), gomock.Eq(&ec2.DescribeSecurityGroupsInput{Filters: []ec2types.Filter{{Name: aws.String("sg-1"), Values: []string{"test-1"}}}})).
+					Return(&ec2.DescribeSecurityGroupsOutput{SecurityGroups: []ec2types.SecurityGroup{{GroupId: aws.String("sg-1")}}}, nil)
+				m.DescribeSecurityGroups(context.TODO(), gomock.Eq(&ec2.DescribeSecurityGroupsInput{Filters: []ec2types.Filter{{Name: aws.String("sg-2"), Values: []string{"test-2"}}}})).
+					Return(&ec2.DescribeSecurityGroupsOutput{SecurityGroups: []ec2types.SecurityGroup{{GroupId: aws.String("sg-2")}}}, nil)
 			},
 			want:    true,
 			wantErr: false,
@@ -978,9 +981,9 @@ func TestGetLaunchTemplateID(t *testing.T) {
 			name:               "Should not return error if launch template does not exist",
 			launchTemplateName: "foo",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeLaunchTemplateVersionsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeLaunchTemplateVersionsInput{
+				m.DescribeLaunchTemplateVersions(context.TODO(), gomock.Eq(&ec2.DescribeLaunchTemplateVersionsInput{
 					LaunchTemplateName: aws.String("foo"),
-					Versions:           []*string{aws.String("$Latest")},
+					Versions:           []string{"$Latest"},
 				})).Return(nil, awserr.New(
 					awserrors.LaunchTemplateNameNotFound,
 					"The specified launch template, with template name foo, does not exist.",
@@ -996,9 +999,9 @@ func TestGetLaunchTemplateID(t *testing.T) {
 			name:               "Should return with error if AWS failed to fetch launch template",
 			launchTemplateName: "foo",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeLaunchTemplateVersionsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeLaunchTemplateVersionsInput{
+				m.DescribeLaunchTemplateVersions(context.TODO(), gomock.Eq(&ec2.DescribeLaunchTemplateVersionsInput{
 					LaunchTemplateName: aws.String("foo"),
-					Versions:           []*string{aws.String("$Latest")},
+					Versions:           []string{"$Latest"},
 				})).Return(nil, awserrors.NewFailedDependency("Dependency issue from AWS"))
 			},
 			check: func(g *WithT, launchTemplateID string, err error) {
@@ -1010,9 +1013,9 @@ func TestGetLaunchTemplateID(t *testing.T) {
 			name:               "Should not return error if AWS returns no launch template versions info in output",
 			launchTemplateName: "foo",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeLaunchTemplateVersionsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeLaunchTemplateVersionsInput{
+				m.DescribeLaunchTemplateVersions(context.TODO(), gomock.Eq(&ec2.DescribeLaunchTemplateVersionsInput{
 					LaunchTemplateName: aws.String("foo"),
-					Versions:           []*string{aws.String("$Latest")},
+					Versions:           []string{"$Latest"},
 				})).Return(nil, nil)
 			},
 			check: func(g *WithT, launchTemplateID string, err error) {
@@ -1024,34 +1027,34 @@ func TestGetLaunchTemplateID(t *testing.T) {
 			name:               "Should successfully return launch template ID for given name if exists",
 			launchTemplateName: "foo",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeLaunchTemplateVersionsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeLaunchTemplateVersionsInput{
+				m.DescribeLaunchTemplateVersions(context.TODO(), gomock.Eq(&ec2.DescribeLaunchTemplateVersionsInput{
 					LaunchTemplateName: aws.String("foo"),
-					Versions:           []*string{aws.String("$Latest")},
+					Versions:           []string{"$Latest"},
 				})).Return(&ec2.DescribeLaunchTemplateVersionsOutput{
-					LaunchTemplateVersions: []*ec2.LaunchTemplateVersion{
+					LaunchTemplateVersions: []ec2types.LaunchTemplateVersion{
 						{
 							LaunchTemplateId:   aws.String("lt-12345"),
 							LaunchTemplateName: aws.String("foo"),
-							LaunchTemplateData: &ec2.ResponseLaunchTemplateData{
+							LaunchTemplateData: &ec2types.ResponseLaunchTemplateData{
 								ImageId: aws.String("foo-image"),
-								IamInstanceProfile: &ec2.LaunchTemplateIamInstanceProfileSpecification{
+								IamInstanceProfile: &ec2types.LaunchTemplateIamInstanceProfileSpecification{
 									Arn: aws.String("instance-profile/foo-profile"),
 								},
 								KeyName: aws.String("foo-keyname"),
-								BlockDeviceMappings: []*ec2.LaunchTemplateBlockDeviceMapping{
+								BlockDeviceMappings: []ec2types.LaunchTemplateBlockDeviceMapping{
 									{
 										DeviceName: aws.String("foo-device"),
-										Ebs: &ec2.LaunchTemplateEbsBlockDevice{
+										Ebs: &ec2types.LaunchTemplateEbsBlockDevice{
 											Encrypted:  aws.Bool(true),
-											VolumeSize: aws.Int64(16),
-											VolumeType: aws.String("cool"),
+											VolumeSize: aws.Int32(16),
+											VolumeType: ec2types.VolumeTypeGp2,
 										},
 									},
 								},
-								NetworkInterfaces: []*ec2.LaunchTemplateInstanceNetworkInterfaceSpecification{
+								NetworkInterfaces: []ec2types.LaunchTemplateInstanceNetworkInterfaceSpecification{
 									{
-										DeviceIndex: aws.Int64(1),
-										Groups:      []*string{aws.String("foo-group")},
+										DeviceIndex: aws.Int32(1),
+										Groups:      []string{"foo-group"},
 									},
 								},
 								UserData: aws.String(base64.StdEncoding.EncodeToString([]byte(testUserData))),
@@ -1106,7 +1109,7 @@ func TestDeleteLaunchTemplate(t *testing.T) {
 			name:      "Should not return error if successfully deletes given launch template ID",
 			versionID: "1",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DeleteLaunchTemplateWithContext(context.TODO(), gomock.Eq(&ec2.DeleteLaunchTemplateInput{
+				m.DeleteLaunchTemplate(context.TODO(), gomock.Eq(&ec2.DeleteLaunchTemplateInput{
 					LaunchTemplateId: aws.String("1"),
 				})).Return(&ec2.DeleteLaunchTemplateOutput{}, nil)
 			},
@@ -1115,7 +1118,7 @@ func TestDeleteLaunchTemplate(t *testing.T) {
 			name:      "Should return error if failed to delete given launch template ID",
 			versionID: "1",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DeleteLaunchTemplateWithContext(context.TODO(), gomock.Eq(&ec2.DeleteLaunchTemplateInput{
+				m.DeleteLaunchTemplate(context.TODO(), gomock.Eq(&ec2.DeleteLaunchTemplateInput{
 					LaunchTemplateId: aws.String("1"),
 				})).Return(nil, awserrors.NewFailedDependency("dependency failure"))
 			},
@@ -1180,48 +1183,57 @@ func TestCreateLaunchTemplate(t *testing.T) {
 				sgMap[infrav1.SecurityGroupLB] = infrav1.SecurityGroup{ID: "2"}
 
 				expectedInput := &ec2.CreateLaunchTemplateInput{
-					LaunchTemplateData: &ec2.RequestLaunchTemplateData{
-						InstanceType: aws.String("t3.large"),
-						IamInstanceProfile: &ec2.LaunchTemplateIamInstanceProfileSpecificationRequest{
+					LaunchTemplateData: &ec2types.RequestLaunchTemplateData{
+						InstanceType: ec2types.InstanceTypeT3Large,
+						IamInstanceProfile: &ec2types.LaunchTemplateIamInstanceProfileSpecificationRequest{
 							Name: aws.String("instance-profile"),
 						},
 						KeyName:          aws.String("default"),
 						UserData:         ptr.To[string](base64.StdEncoding.EncodeToString(userData)),
-						SecurityGroupIds: aws.StringSlice([]string{"nodeSG", "lbSG", "1"}),
+						SecurityGroupIds: []string{"nodeSG", "lbSG", "1"},
 						ImageId:          aws.String("imageID"),
-						InstanceMarketOptions: &ec2.LaunchTemplateInstanceMarketOptionsRequest{
-							MarketType: aws.String("spot"),
-							SpotOptions: &ec2.LaunchTemplateSpotMarketOptionsRequest{
+						InstanceMarketOptions: &ec2types.LaunchTemplateInstanceMarketOptionsRequest{
+							MarketType: ec2types.MarketTypeSpot,
+							SpotOptions: &ec2types.LaunchTemplateSpotMarketOptionsRequest{
 								MaxPrice: aws.String("0.9"),
 							},
 						},
-						TagSpecifications: []*ec2.LaunchTemplateTagSpecificationRequest{
+						TagSpecifications: []ec2types.LaunchTemplateTagSpecificationRequest{
 							{
-								ResourceType: aws.String(ec2.ResourceTypeInstance),
+								ResourceType: ec2types.ResourceTypeInstance,
 								Tags:         defaultEC2AndDataTags("aws-mp-name", "cluster-name", userDataSecretKey, testBootstrapDataHash),
 							},
 							{
-								ResourceType: aws.String(ec2.ResourceTypeVolume),
+								ResourceType: ec2types.ResourceTypeVolume,
 								Tags:         defaultEC2Tags("aws-mp-name", "cluster-name"),
 							},
 						},
 					},
 					LaunchTemplateName: aws.String("aws-mp-name"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []ec2types.TagSpecification{
 						{
-							ResourceType: aws.String(ec2.ResourceTypeLaunchTemplate),
+							ResourceType: ec2types.ResourceTypeLaunchTemplate,
 							Tags:         defaultEC2Tags("aws-mp-name", "cluster-name"),
 						},
 					},
 				}
-				m.CreateLaunchTemplateWithContext(context.TODO(), gomock.AssignableToTypeOf(expectedInput)).Return(&ec2.CreateLaunchTemplateOutput{
-					LaunchTemplate: &ec2.LaunchTemplate{
+				m.CreateLaunchTemplate(context.TODO(), gomock.AssignableToTypeOf(expectedInput)).Return(&ec2.CreateLaunchTemplateOutput{
+					LaunchTemplate: &ec2types.LaunchTemplate{
 						LaunchTemplateId: aws.String("launch-template-id"),
 					},
 				}, nil).Do(func(ctx context.Context, arg *ec2.CreateLaunchTemplateInput, requestOptions ...request.Option) {
 					// formatting added to match arrays during cmp.Equal
 					formatTagsInput(arg)
-					if !cmp.Equal(expectedInput, arg) {
+					if !cmp.Equal(expectedInput, arg, cmpopts.IgnoreUnexported(
+						ec2types.LaunchTemplateIamInstanceProfileSpecificationRequest{},
+						ec2types.LaunchTemplateSpotMarketOptionsRequest{},
+						ec2types.LaunchTemplateInstanceMarketOptionsRequest{},
+						ec2types.Tag{},
+						ec2types.LaunchTemplateTagSpecificationRequest{},
+						ec2types.RequestLaunchTemplateData{},
+						ec2types.TagSpecification{},
+						ec2.CreateLaunchTemplateInput{},
+					)) {
 						t.Fatalf("mismatch in input expected: %+v, got: %+v, diff: %s", expectedInput, arg, cmp.Diff(expectedInput, arg))
 					}
 				})
@@ -1240,53 +1252,62 @@ func TestCreateLaunchTemplate(t *testing.T) {
 				sgMap[infrav1.SecurityGroupLB] = infrav1.SecurityGroup{ID: "2"}
 
 				expectedInput := &ec2.CreateLaunchTemplateInput{
-					LaunchTemplateData: &ec2.RequestLaunchTemplateData{
-						InstanceType: aws.String("t3.large"),
-						IamInstanceProfile: &ec2.LaunchTemplateIamInstanceProfileSpecificationRequest{
+					LaunchTemplateData: &ec2types.RequestLaunchTemplateData{
+						InstanceType: ec2types.InstanceTypeT3Large,
+						IamInstanceProfile: &ec2types.LaunchTemplateIamInstanceProfileSpecificationRequest{
 							Name: aws.String("instance-profile"),
 						},
 						KeyName:          aws.String("default"),
 						UserData:         ptr.To[string](base64.StdEncoding.EncodeToString(userData)),
-						SecurityGroupIds: aws.StringSlice([]string{"nodeSG", "lbSG", "sg-1"}),
+						SecurityGroupIds: []string{"nodeSG", "lbSG", "sg-1"},
 						ImageId:          aws.String("imageID"),
-						InstanceMarketOptions: &ec2.LaunchTemplateInstanceMarketOptionsRequest{
-							MarketType: aws.String("spot"),
-							SpotOptions: &ec2.LaunchTemplateSpotMarketOptionsRequest{
+						InstanceMarketOptions: &ec2types.LaunchTemplateInstanceMarketOptionsRequest{
+							MarketType: ec2types.MarketTypeSpot,
+							SpotOptions: &ec2types.LaunchTemplateSpotMarketOptionsRequest{
 								MaxPrice: aws.String("0.9"),
 							},
 						},
-						TagSpecifications: []*ec2.LaunchTemplateTagSpecificationRequest{
+						TagSpecifications: []ec2types.LaunchTemplateTagSpecificationRequest{
 							{
-								ResourceType: aws.String(ec2.ResourceTypeInstance),
+								ResourceType: ec2types.ResourceTypeInstance,
 								Tags:         defaultEC2AndDataTags("aws-mp-name", "cluster-name", userDataSecretKey, testBootstrapDataHash),
 							},
 							{
-								ResourceType: aws.String(ec2.ResourceTypeVolume),
+								ResourceType: ec2types.ResourceTypeVolume,
 								Tags:         defaultEC2Tags("aws-mp-name", "cluster-name"),
 							},
 						},
 					},
 					LaunchTemplateName: aws.String("aws-mp-name"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []ec2types.TagSpecification{
 						{
-							ResourceType: aws.String(ec2.ResourceTypeLaunchTemplate),
+							ResourceType: ec2types.ResourceTypeLaunchTemplate,
 							Tags:         defaultEC2Tags("aws-mp-name", "cluster-name"),
 						},
 					},
 				}
-				m.CreateLaunchTemplateWithContext(context.TODO(), gomock.AssignableToTypeOf(expectedInput)).Return(&ec2.CreateLaunchTemplateOutput{
-					LaunchTemplate: &ec2.LaunchTemplate{
+				m.CreateLaunchTemplate(context.TODO(), gomock.AssignableToTypeOf(expectedInput)).Return(&ec2.CreateLaunchTemplateOutput{
+					LaunchTemplate: &ec2types.LaunchTemplate{
 						LaunchTemplateId: aws.String("launch-template-id"),
 					},
 				}, nil).Do(func(ctx context.Context, arg *ec2.CreateLaunchTemplateInput, requestOptions ...request.Option) {
 					// formatting added to match arrays during reflect.DeepEqual
 					formatTagsInput(arg)
-					if !cmp.Equal(expectedInput, arg) {
+					if !cmp.Equal(expectedInput, arg, cmpopts.IgnoreUnexported(
+						ec2types.LaunchTemplateIamInstanceProfileSpecificationRequest{},
+						ec2types.LaunchTemplateSpotMarketOptionsRequest{},
+						ec2types.LaunchTemplateInstanceMarketOptionsRequest{},
+						ec2types.Tag{},
+						ec2types.LaunchTemplateTagSpecificationRequest{},
+						ec2types.RequestLaunchTemplateData{},
+						ec2types.TagSpecification{},
+						ec2.CreateLaunchTemplateInput{},
+					)) {
 						t.Fatalf("mismatch in input expected: %+v, got: %+v", expectedInput, arg)
 					}
 				})
-				m.DescribeSecurityGroupsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSecurityGroupsInput{Filters: []*ec2.Filter{{Name: aws.String("sg-1"), Values: aws.StringSlice([]string{"test"})}}})).
-					Return(&ec2.DescribeSecurityGroupsOutput{SecurityGroups: []*ec2.SecurityGroup{{GroupId: aws.String("sg-1")}}}, nil)
+				m.DescribeSecurityGroups(context.TODO(), gomock.Eq(&ec2.DescribeSecurityGroupsInput{Filters: []ec2types.Filter{{Name: aws.String("sg-1"), Values: []string{"test"}}}})).
+					Return(&ec2.DescribeSecurityGroupsOutput{SecurityGroups: []ec2types.SecurityGroup{{GroupId: aws.String("sg-1")}}}, nil)
 			},
 			check: func(g *WithT, id string, err error) {
 				g.Expect(id).Should(Equal("launch-template-id"))
@@ -1302,45 +1323,54 @@ func TestCreateLaunchTemplate(t *testing.T) {
 				sgMap[infrav1.SecurityGroupLB] = infrav1.SecurityGroup{ID: "2"}
 
 				expectedInput := &ec2.CreateLaunchTemplateInput{
-					LaunchTemplateData: &ec2.RequestLaunchTemplateData{
-						InstanceType: aws.String("t3.large"),
-						IamInstanceProfile: &ec2.LaunchTemplateIamInstanceProfileSpecificationRequest{
+					LaunchTemplateData: &ec2types.RequestLaunchTemplateData{
+						InstanceType: ec2types.InstanceTypeT3Large,
+						IamInstanceProfile: &ec2types.LaunchTemplateIamInstanceProfileSpecificationRequest{
 							Name: aws.String("instance-profile"),
 						},
 						KeyName:          aws.String("default"),
 						UserData:         ptr.To[string](base64.StdEncoding.EncodeToString(userData)),
-						SecurityGroupIds: aws.StringSlice([]string{"nodeSG", "lbSG", "1"}),
+						SecurityGroupIds: []string{"nodeSG", "lbSG", "1"},
 						ImageId:          aws.String("imageID"),
-						InstanceMarketOptions: &ec2.LaunchTemplateInstanceMarketOptionsRequest{
-							MarketType: aws.String("spot"),
-							SpotOptions: &ec2.LaunchTemplateSpotMarketOptionsRequest{
+						InstanceMarketOptions: &ec2types.LaunchTemplateInstanceMarketOptionsRequest{
+							MarketType: ec2types.MarketTypeSpot,
+							SpotOptions: &ec2types.LaunchTemplateSpotMarketOptionsRequest{
 								MaxPrice: aws.String("0.9"),
 							},
 						},
-						TagSpecifications: []*ec2.LaunchTemplateTagSpecificationRequest{
+						TagSpecifications: []ec2types.LaunchTemplateTagSpecificationRequest{
 							{
-								ResourceType: aws.String(ec2.ResourceTypeInstance),
+								ResourceType: ec2types.ResourceTypeInstance,
 								Tags:         defaultEC2AndDataTags("aws-mp-name", "cluster-name", userDataSecretKey, testBootstrapDataHash),
 							},
 							{
-								ResourceType: aws.String(ec2.ResourceTypeVolume),
+								ResourceType: ec2types.ResourceTypeVolume,
 								Tags:         defaultEC2Tags("aws-mp-name", "cluster-name"),
 							},
 						},
 					},
 					LaunchTemplateName: aws.String("aws-mp-name"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []ec2types.TagSpecification{
 						{
-							ResourceType: aws.String(ec2.ResourceTypeLaunchTemplate),
+							ResourceType: ec2types.ResourceTypeLaunchTemplate,
 							Tags:         defaultEC2Tags("aws-mp-name", "cluster-name"),
 						},
 					},
 				}
-				m.CreateLaunchTemplateWithContext(context.TODO(), gomock.AssignableToTypeOf(expectedInput)).Return(nil,
+				m.CreateLaunchTemplate(context.TODO(), gomock.AssignableToTypeOf(expectedInput)).Return(nil,
 					awserrors.NewFailedDependency("dependency failure")).Do(func(ctx context.Context, arg *ec2.CreateLaunchTemplateInput, requestOptions ...request.Option) {
 					// formatting added to match arrays during cmp.Equal
 					formatTagsInput(arg)
-					if !cmp.Equal(expectedInput, arg) {
+					if !cmp.Equal(expectedInput, arg, cmpopts.IgnoreUnexported(
+						ec2types.LaunchTemplateIamInstanceProfileSpecificationRequest{},
+						ec2types.LaunchTemplateSpotMarketOptionsRequest{},
+						ec2types.LaunchTemplateInstanceMarketOptionsRequest{},
+						ec2types.Tag{},
+						ec2types.LaunchTemplateTagSpecificationRequest{},
+						ec2types.RequestLaunchTemplateData{},
+						ec2types.TagSpecification{},
+						ec2.CreateLaunchTemplateInput{},
+					)) {
 						t.Fatalf("mismatch in input expected: %+v, got: %+v", expectedInput, arg)
 					}
 				})
@@ -1429,7 +1459,7 @@ func TestCreateLaunchTemplateVersion(t *testing.T) {
 		awsResourceReference []infrav1.AWSResourceReference
 		expect               func(m *mocks.MockEC2APIMockRecorder)
 		wantErr              bool
-		marketType           *string
+		marketType           ec2types.MarketType
 	}{
 		{
 			name:                 "Should successfully creates launch template version",
@@ -1440,43 +1470,51 @@ func TestCreateLaunchTemplateVersion(t *testing.T) {
 				sgMap[infrav1.SecurityGroupLB] = infrav1.SecurityGroup{ID: "2"}
 
 				expectedInput := &ec2.CreateLaunchTemplateVersionInput{
-					LaunchTemplateData: &ec2.RequestLaunchTemplateData{
-						InstanceType: aws.String("t3.large"),
-						IamInstanceProfile: &ec2.LaunchTemplateIamInstanceProfileSpecificationRequest{
+					LaunchTemplateData: &ec2types.RequestLaunchTemplateData{
+						InstanceType: ec2types.InstanceTypeT3Large,
+						IamInstanceProfile: &ec2types.LaunchTemplateIamInstanceProfileSpecificationRequest{
 							Name: aws.String("instance-profile"),
 						},
 						KeyName:          aws.String("default"),
 						UserData:         ptr.To[string](base64.StdEncoding.EncodeToString(userData)),
-						SecurityGroupIds: aws.StringSlice([]string{"nodeSG", "lbSG", "1"}),
+						SecurityGroupIds: []string{"nodeSG", "lbSG", "1"},
 						ImageId:          aws.String("imageID"),
-						InstanceMarketOptions: &ec2.LaunchTemplateInstanceMarketOptionsRequest{
-							MarketType: aws.String("spot"),
-							SpotOptions: &ec2.LaunchTemplateSpotMarketOptionsRequest{
+						InstanceMarketOptions: &ec2types.LaunchTemplateInstanceMarketOptionsRequest{
+							MarketType: ec2types.MarketTypeSpot,
+							SpotOptions: &ec2types.LaunchTemplateSpotMarketOptionsRequest{
 								MaxPrice: aws.String("0.9"),
 							},
 						},
-						TagSpecifications: []*ec2.LaunchTemplateTagSpecificationRequest{
+						TagSpecifications: []ec2types.LaunchTemplateTagSpecificationRequest{
 							{
-								ResourceType: aws.String(ec2.ResourceTypeInstance),
+								ResourceType: ec2types.ResourceTypeInstance,
 								Tags:         defaultEC2AndDataTags("aws-mp-name", "cluster-name", userDataSecretKey, testBootstrapDataHash),
 							},
 							{
-								ResourceType: aws.String(ec2.ResourceTypeVolume),
+								ResourceType: ec2types.ResourceTypeVolume,
 								Tags:         defaultEC2Tags("aws-mp-name", "cluster-name"),
 							},
 						},
 					},
 					LaunchTemplateId: aws.String("launch-template-id"),
 				}
-				m.CreateLaunchTemplateVersionWithContext(context.TODO(), gomock.AssignableToTypeOf(expectedInput)).Return(&ec2.CreateLaunchTemplateVersionOutput{
-					LaunchTemplateVersion: &ec2.LaunchTemplateVersion{
+				m.CreateLaunchTemplateVersion(context.TODO(), gomock.AssignableToTypeOf(expectedInput)).Return(&ec2.CreateLaunchTemplateVersionOutput{
+					LaunchTemplateVersion: &ec2types.LaunchTemplateVersion{
 						LaunchTemplateId: aws.String("launch-template-id"),
 					},
 				}, nil).Do(
 					func(ctx context.Context, arg *ec2.CreateLaunchTemplateVersionInput, requestOptions ...request.Option) {
 						// formatting added to match tags slice during cmp.Equal()
 						formatTagsInput(arg)
-						if !cmp.Equal(expectedInput, arg) {
+						if !cmp.Equal(expectedInput, arg, cmpopts.IgnoreUnexported(
+							ec2types.LaunchTemplateIamInstanceProfileSpecificationRequest{},
+							ec2types.LaunchTemplateSpotMarketOptionsRequest{},
+							ec2types.LaunchTemplateInstanceMarketOptionsRequest{},
+							ec2types.Tag{},
+							ec2types.LaunchTemplateTagSpecificationRequest{},
+							ec2types.RequestLaunchTemplateData{},
+							ec2.CreateLaunchTemplateVersionInput{},
+						)) {
 							t.Fatalf("mismatch in input expected: %+v, but got %+v, diff: %s", expectedInput, arg, cmp.Diff(expectedInput, arg))
 						}
 					})
@@ -1485,47 +1523,55 @@ func TestCreateLaunchTemplateVersion(t *testing.T) {
 		{
 			name:                 "Should successfully create launch template version with capacity-block",
 			awsResourceReference: []infrav1.AWSResourceReference{{ID: aws.String("1")}},
-			marketType:           aws.String(ec2.MarketTypeCapacityBlock),
+			marketType:           ec2types.MarketTypeCapacityBlock,
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				sgMap := make(map[infrav1.SecurityGroupRole]infrav1.SecurityGroup)
 				sgMap[infrav1.SecurityGroupNode] = infrav1.SecurityGroup{ID: "1"}
 				sgMap[infrav1.SecurityGroupLB] = infrav1.SecurityGroup{ID: "2"}
 
 				expectedInput := &ec2.CreateLaunchTemplateVersionInput{
-					LaunchTemplateData: &ec2.RequestLaunchTemplateData{
-						InstanceType: aws.String("t3.large"),
-						IamInstanceProfile: &ec2.LaunchTemplateIamInstanceProfileSpecificationRequest{
+					LaunchTemplateData: &ec2types.RequestLaunchTemplateData{
+						InstanceType: ec2types.InstanceTypeT3Large,
+						IamInstanceProfile: &ec2types.LaunchTemplateIamInstanceProfileSpecificationRequest{
 							Name: aws.String("instance-profile"),
 						},
 						KeyName:          aws.String("default"),
 						UserData:         ptr.To[string](base64.StdEncoding.EncodeToString(userData)),
-						SecurityGroupIds: aws.StringSlice([]string{"nodeSG", "lbSG", "1"}),
+						SecurityGroupIds: []string{"nodeSG", "lbSG", "1"},
 						ImageId:          aws.String("imageID"),
-						InstanceMarketOptions: &ec2.LaunchTemplateInstanceMarketOptionsRequest{
-							MarketType: aws.String(ec2.MarketTypeCapacityBlock),
+						InstanceMarketOptions: &ec2types.LaunchTemplateInstanceMarketOptionsRequest{
+							MarketType: ec2types.MarketTypeCapacityBlock,
 						},
-						TagSpecifications: []*ec2.LaunchTemplateTagSpecificationRequest{
+						TagSpecifications: []ec2types.LaunchTemplateTagSpecificationRequest{
 							{
-								ResourceType: aws.String(ec2.ResourceTypeInstance),
+								ResourceType: ec2types.ResourceTypeInstance,
 								Tags:         defaultEC2AndDataTags("aws-mp-name", "cluster-name", userDataSecretKey, testBootstrapDataHash),
 							},
 							{
-								ResourceType: aws.String(ec2.ResourceTypeVolume),
+								ResourceType: ec2types.ResourceTypeVolume,
 								Tags:         defaultEC2Tags("aws-mp-name", "cluster-name"),
 							},
 						},
 					},
 					LaunchTemplateId: aws.String("launch-template-id"),
 				}
-				m.CreateLaunchTemplateVersionWithContext(context.TODO(), gomock.AssignableToTypeOf(expectedInput)).Return(&ec2.CreateLaunchTemplateVersionOutput{
-					LaunchTemplateVersion: &ec2.LaunchTemplateVersion{
+				m.CreateLaunchTemplateVersion(context.TODO(), gomock.AssignableToTypeOf(expectedInput)).Return(&ec2.CreateLaunchTemplateVersionOutput{
+					LaunchTemplateVersion: &ec2types.LaunchTemplateVersion{
 						LaunchTemplateId: aws.String("launch-template-id"),
 					},
 				}, nil).Do(
 					func(ctx context.Context, arg *ec2.CreateLaunchTemplateVersionInput, requestOptions ...request.Option) {
 						// formatting added to match tags slice during cmp.Equal()
 						formatTagsInput(arg)
-						if !cmp.Equal(expectedInput, arg) {
+						if !cmp.Equal(expectedInput, arg, cmpopts.IgnoreUnexported(
+							ec2types.LaunchTemplateIamInstanceProfileSpecificationRequest{},
+							ec2types.LaunchTemplateSpotMarketOptionsRequest{},
+							ec2types.LaunchTemplateInstanceMarketOptionsRequest{},
+							ec2types.Tag{},
+							ec2types.LaunchTemplateTagSpecificationRequest{},
+							ec2types.RequestLaunchTemplateData{},
+							ec2.CreateLaunchTemplateVersionInput{},
+						)) {
 							t.Fatalf("mismatch in input expected: %+v, but got %+v, diff: %s", expectedInput, arg, cmp.Diff(expectedInput, arg))
 						}
 					})
@@ -1540,40 +1586,48 @@ func TestCreateLaunchTemplateVersion(t *testing.T) {
 				sgMap[infrav1.SecurityGroupLB] = infrav1.SecurityGroup{ID: "2"}
 
 				expectedInput := &ec2.CreateLaunchTemplateVersionInput{
-					LaunchTemplateData: &ec2.RequestLaunchTemplateData{
-						InstanceType: aws.String("t3.large"),
-						IamInstanceProfile: &ec2.LaunchTemplateIamInstanceProfileSpecificationRequest{
+					LaunchTemplateData: &ec2types.RequestLaunchTemplateData{
+						InstanceType: ec2types.InstanceTypeT3Large,
+						IamInstanceProfile: &ec2types.LaunchTemplateIamInstanceProfileSpecificationRequest{
 							Name: aws.String("instance-profile"),
 						},
 						KeyName:          aws.String("default"),
 						UserData:         ptr.To[string](base64.StdEncoding.EncodeToString(userData)),
-						SecurityGroupIds: aws.StringSlice([]string{"nodeSG", "lbSG", "1"}),
+						SecurityGroupIds: []string{"nodeSG", "lbSG", "1"},
 						ImageId:          aws.String("imageID"),
-						InstanceMarketOptions: &ec2.LaunchTemplateInstanceMarketOptionsRequest{
-							MarketType: aws.String("spot"),
-							SpotOptions: &ec2.LaunchTemplateSpotMarketOptionsRequest{
+						InstanceMarketOptions: &ec2types.LaunchTemplateInstanceMarketOptionsRequest{
+							MarketType: ec2types.MarketTypeSpot,
+							SpotOptions: &ec2types.LaunchTemplateSpotMarketOptionsRequest{
 								MaxPrice: aws.String("0.9"),
 							},
 						},
-						TagSpecifications: []*ec2.LaunchTemplateTagSpecificationRequest{
+						TagSpecifications: []ec2types.LaunchTemplateTagSpecificationRequest{
 							{
-								ResourceType: aws.String(ec2.ResourceTypeInstance),
+								ResourceType: ec2types.ResourceTypeInstance,
 								Tags:         defaultEC2AndDataTags("aws-mp-name", "cluster-name", userDataSecretKey, testBootstrapDataHash),
 							},
 							{
-								ResourceType: aws.String(ec2.ResourceTypeVolume),
+								ResourceType: ec2types.ResourceTypeVolume,
 								Tags:         defaultEC2Tags("aws-mp-name", "cluster-name"),
 							},
 						},
 					},
 					LaunchTemplateId: aws.String("launch-template-id"),
 				}
-				m.CreateLaunchTemplateVersionWithContext(context.TODO(), gomock.AssignableToTypeOf(expectedInput)).Return(nil,
+				m.CreateLaunchTemplateVersion(context.TODO(), gomock.AssignableToTypeOf(expectedInput)).Return(nil,
 					awserrors.NewFailedDependency("dependency failure")).Do(
 					func(ctx context.Context, arg *ec2.CreateLaunchTemplateVersionInput, requestOptions ...request.Option) {
 						// formatting added to match tags slice during cmp.Equal()
 						formatTagsInput(arg)
-						if !cmp.Equal(expectedInput, arg) {
+						if !cmp.Equal(expectedInput, arg, cmpopts.IgnoreUnexported(
+							ec2types.LaunchTemplateIamInstanceProfileSpecificationRequest{},
+							ec2types.LaunchTemplateSpotMarketOptionsRequest{},
+							ec2types.LaunchTemplateInstanceMarketOptionsRequest{},
+							ec2types.Tag{},
+							ec2types.LaunchTemplateTagSpecificationRequest{},
+							ec2types.RequestLaunchTemplateData{},
+							ec2.CreateLaunchTemplateVersionInput{},
+						)) {
 							t.Fatalf("mismatch in input expected: %+v, got: %+v", expectedInput, arg)
 						}
 					})
@@ -1592,7 +1646,7 @@ func TestCreateLaunchTemplateVersion(t *testing.T) {
 			g.Expect(err).NotTo(HaveOccurred())
 
 			var ms *scope.MachinePoolScope
-			if aws.StringValue(tc.marketType) == ec2.MarketTypeCapacityBlock {
+			if tc.marketType == ec2types.MarketTypeCapacityBlock {
 				ms, err = setupCapacityBlocksMachinePoolScope(client, cs)
 			} else {
 				ms, err = setupMachinePoolScope(client, cs)
@@ -1628,18 +1682,18 @@ func TestBuildLaunchTemplateTagSpecificationRequest(t *testing.T) {
 	bootstrapDataHash := userdata.ComputeHash([]byte("shell-script"))
 	testCases := []struct {
 		name  string
-		check func(g *WithT, m []*ec2.LaunchTemplateTagSpecificationRequest)
+		check func(g *WithT, m []ec2types.LaunchTemplateTagSpecificationRequest)
 	}{
 		{
 			name: "Should create tag specification request for building Launch template tags",
-			check: func(g *WithT, res []*ec2.LaunchTemplateTagSpecificationRequest) {
-				expected := []*ec2.LaunchTemplateTagSpecificationRequest{
+			check: func(g *WithT, res []ec2types.LaunchTemplateTagSpecificationRequest) {
+				expected := []ec2types.LaunchTemplateTagSpecificationRequest{
 					{
-						ResourceType: aws.String(ec2.ResourceTypeInstance),
+						ResourceType: ec2types.ResourceTypeInstance,
 						Tags:         defaultEC2AndDataTags("aws-mp-name", "cluster-name", userDataSecretKey, bootstrapDataHash),
 					},
 					{
-						ResourceType: aws.String(ec2.ResourceTypeVolume),
+						ResourceType: ec2types.ResourceTypeVolume,
 						Tags:         defaultEC2Tags("aws-mp-name", "cluster-name"),
 					},
 				}
@@ -1697,9 +1751,9 @@ func TestDiscoverLaunchTemplateAMI(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeImagesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
+				m.DescribeImages(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
 					Return(&ec2.DescribeImagesOutput{
-						Images: []*ec2.Image{
+						Images: []ec2types.Image{
 							{
 								ImageId:      aws.String("ancient"),
 								CreationDate: aws.String("2011-02-08T17:02:31.000Z"),
@@ -1714,17 +1768,17 @@ func TestDiscoverLaunchTemplateAMI(t *testing.T) {
 							},
 						},
 					}, nil)
-				m.DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-					InstanceTypes: []*string{
-						aws.String("m5.large"),
+				m.DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+					InstanceTypes: []ec2types.InstanceType{
+						ec2types.InstanceTypeM5Large,
 					},
 				})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []ec2types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &ec2types.ProcessorInfo{
+									SupportedArchitectures: []ec2types.ArchitectureType{
+										ec2types.ArchitectureTypeX8664,
 									},
 								},
 							},
@@ -1748,9 +1802,9 @@ func TestDiscoverLaunchTemplateAMI(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeImagesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
+				m.DescribeImages(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
 					Return(&ec2.DescribeImagesOutput{
-						Images: []*ec2.Image{
+						Images: []ec2types.Image{
 							{
 								ImageId:      aws.String("ancient"),
 								CreationDate: aws.String("2011-02-08T17:02:31.000Z"),
@@ -1765,17 +1819,17 @@ func TestDiscoverLaunchTemplateAMI(t *testing.T) {
 							},
 						},
 					}, nil)
-				m.DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-					InstanceTypes: []*string{
-						aws.String("m5.large"),
+				m.DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+					InstanceTypes: []ec2types.InstanceType{
+						ec2types.InstanceTypeM5Large,
 					},
 				})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []ec2types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &ec2types.ProcessorInfo{
+									SupportedArchitectures: []ec2types.ArchitectureType{
+										ec2types.ArchitectureTypeX8664,
 									},
 								},
 							},
@@ -1799,9 +1853,9 @@ func TestDiscoverLaunchTemplateAMI(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeImagesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
+				m.DescribeImages(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
 					Return(&ec2.DescribeImagesOutput{
-						Images: []*ec2.Image{
+						Images: []ec2types.Image{
 							{
 								ImageId:      aws.String("ancient"),
 								CreationDate: aws.String("2011-02-08T17:02:31.000Z"),
@@ -1816,17 +1870,17 @@ func TestDiscoverLaunchTemplateAMI(t *testing.T) {
 							},
 						},
 					}, nil)
-				m.DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-					InstanceTypes: []*string{
-						aws.String("t4g.large"),
+				m.DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+					InstanceTypes: []ec2types.InstanceType{
+						ec2types.InstanceTypeT4gLarge,
 					},
 				})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []ec2types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("arm64"),
+								ProcessorInfo: &ec2types.ProcessorInfo{
+									SupportedArchitectures: []ec2types.ArchitectureType{
+										ec2types.ArchitectureTypeArm64,
 									},
 								},
 							},
@@ -1871,19 +1925,19 @@ func TestDiscoverLaunchTemplateAMI(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeImagesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
+				m.DescribeImages(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeImagesInput{})).
 					Return(nil, awserrors.NewFailedDependency("dependency-failure"))
-				m.DescribeInstanceTypesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
-					InstanceTypes: []*string{
-						aws.String("m5.large"),
+				m.DescribeInstanceTypes(context.TODO(), gomock.Eq(&ec2.DescribeInstanceTypesInput{
+					InstanceTypes: []ec2types.InstanceType{
+						ec2types.InstanceTypeM5Large,
 					},
 				})).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []ec2types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &ec2types.ProcessorInfo{
+									SupportedArchitectures: []ec2types.ArchitectureType{
+										ec2types.ArchitectureTypeX8664,
 									},
 								},
 							},
@@ -1943,13 +1997,13 @@ func TestDiscoverLaunchTemplateAMIForEKS(t *testing.T) {
 		{
 			name: "Should return AMI and use EKS infra cluster image details, if not passed in aws launch template",
 			expectEC2: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeInstanceTypesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeInstanceTypes(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeInstanceTypesOutput{
-						InstanceTypes: []*ec2.InstanceTypeInfo{
+						InstanceTypes: []ec2types.InstanceTypeInfo{
 							{
-								ProcessorInfo: &ec2.ProcessorInfo{
-									SupportedArchitectures: []*string{
-										aws.String("x86_64"),
+								ProcessorInfo: &ec2types.ProcessorInfo{
+									SupportedArchitectures: []ec2types.ArchitectureType{
+										ec2types.ArchitectureTypeX8664,
 									},
 								},
 							},
@@ -2030,10 +2084,10 @@ func TestDeleteLaunchTemplateVersion(t *testing.T) {
 				version: aws.Int64(12),
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DeleteLaunchTemplateVersionsWithContext(context.TODO(), gomock.Eq(
+				m.DeleteLaunchTemplateVersions(context.TODO(), gomock.Eq(
 					&ec2.DeleteLaunchTemplateVersionsInput{
 						LaunchTemplateId: aws.String("id"),
-						Versions:         aws.StringSlice([]string{"12"}),
+						Versions:         []string{"12"},
 					},
 				)).Return(nil, awserrors.NewFailedDependency("dependency-failure"))
 			},
@@ -2046,10 +2100,10 @@ func TestDeleteLaunchTemplateVersion(t *testing.T) {
 				version: aws.Int64(12),
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DeleteLaunchTemplateVersionsWithContext(context.TODO(), gomock.Eq(
+				m.DeleteLaunchTemplateVersions(context.TODO(), gomock.Eq(
 					&ec2.DeleteLaunchTemplateVersionsInput{
 						LaunchTemplateId: aws.String("id"),
-						Versions:         aws.StringSlice([]string{"12"}),
+						Versions:         []string{"12"},
 					},
 				)).Return(nil, nil)
 			},
diff --git a/pkg/cloud/services/elb/loadbalancer_test.go b/pkg/cloud/services/elb/loadbalancer_test.go
index 5bf8baae0..d59c15c91 100644
--- a/pkg/cloud/services/elb/loadbalancer_test.go
+++ b/pkg/cloud/services/elb/loadbalancer_test.go
@@ -25,13 +25,14 @@ import (
 	"time"
 
 	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	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/golang/mock/gomock"
 	"github.com/google/go-cmp/cmp"
 	. "github.com/onsi/gomega"
@@ -207,14 +208,14 @@ func TestGetAPIServerClassicELBSpecControlPlaneLoadBalancer(t *testing.T) {
 				Subnets: []string{"subnet-1", "subnet-2"},
 			},
 			mocks: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					SubnetIds: []*string{
-						aws.String("subnet-1"),
-						aws.String("subnet-2"),
+				m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{
+						"subnet-1",
+						"subnet-2",
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{
+						Subnets: []ec2types.Subnet{
 							{
 								SubnetId:         aws.String("subnet-1"),
 								AvailabilityZone: aws.String("us-east-1a"),
@@ -358,14 +359,14 @@ func TestGetAPIServerV2ELBSpecControlPlaneLoadBalancer(t *testing.T) {
 				Subnets: []string{"subnet-1", "subnet-2"},
 			},
 			mocks: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					SubnetIds: []*string{
-						aws.String("subnet-1"),
-						aws.String("subnet-2"),
+				m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{
+						"subnet-1",
+						"subnet-2",
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{
+						Subnets: []ec2types.Subnet{
 							{
 								SubnetId:         aws.String("subnet-1"),
 								AvailabilityZone: aws.String("us-east-1a"),
@@ -632,13 +633,13 @@ func TestRegisterInstanceWithAPIServerELB(t *testing.T) {
 					}, nil)
 			},
 			ec2Mocks: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					SubnetIds: []*string{
-						aws.String(elbSubnetID),
+				m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{
+						elbSubnetID,
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{
+						Subnets: []ec2types.Subnet{
 							{
 								SubnetId:         aws.String(elbSubnetID),
 								AvailabilityZone: aws.String(az),
@@ -707,13 +708,13 @@ func TestRegisterInstanceWithAPIServerELB(t *testing.T) {
 					}, nil)
 			},
 			ec2Mocks: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					SubnetIds: []*string{
-						aws.String(elbSubnetID),
+				m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{
+						elbSubnetID,
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{
+						Subnets: []ec2types.Subnet{
 							{
 								SubnetId:         aws.String(elbSubnetID),
 								AvailabilityZone: aws.String(differentAZ),
diff --git a/pkg/cloud/services/gc/cleanup_test.go b/pkg/cloud/services/gc/cleanup_test.go
index 461303adf..1e7c997a9 100644
--- a/pkg/cloud/services/gc/cleanup_test.go
+++ b/pkg/cloud/services/gc/cleanup_test.go
@@ -40,7 +40,6 @@ import (
 	"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/test/mocks"
-	mocksv2 "sigs.k8s.io/cluster-api-provider-aws/v2/test/mocks/v2"
 	clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
 )
 
@@ -51,7 +50,7 @@ func TestReconcileDelete(t *testing.T) {
 		elbMocks     func(m *mocks.MockELBAPIMockRecorder)
 		elbv2Mocks   func(m *mocks.MockELBV2APIMockRecorder)
 		rgAPIMocks   func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder)
-		ec2Mocks     func(m *mocksv2.MockEC2APIMockRecorder)
+		ec2Mocks     func(m *mocks.MockEC2APIMockRecorder)
 		expectErr    bool
 	}{
 		{
@@ -60,7 +59,7 @@ func TestReconcileDelete(t *testing.T) {
 			rgAPIMocks:   func(m *mocks.MockResourceGroupsTaggingAPIAPIMockRecorder) {},
 			elbMocks:     func(m *mocks.MockELBAPIMockRecorder) {},
 			elbv2Mocks:   func(m *mocks.MockELBV2APIMockRecorder) {},
-			ec2Mocks:     func(m *mocksv2.MockEC2APIMockRecorder) {},
+			ec2Mocks:     func(m *mocks.MockEC2APIMockRecorder) {},
 			expectErr:    false,
 		},
 		{
@@ -82,7 +81,7 @@ func TestReconcileDelete(t *testing.T) {
 			},
 			elbMocks:   func(m *mocks.MockELBAPIMockRecorder) {},
 			elbv2Mocks: func(m *mocks.MockELBV2APIMockRecorder) {},
-			ec2Mocks:   func(m *mocksv2.MockEC2APIMockRecorder) {},
+			ec2Mocks:   func(m *mocks.MockEC2APIMockRecorder) {},
 			expectErr:  false,
 		},
 		{
@@ -104,7 +103,7 @@ func TestReconcileDelete(t *testing.T) {
 			},
 			elbMocks:   func(m *mocks.MockELBAPIMockRecorder) {},
 			elbv2Mocks: func(m *mocks.MockELBV2APIMockRecorder) {},
-			ec2Mocks:   func(m *mocksv2.MockEC2APIMockRecorder) {},
+			ec2Mocks:   func(m *mocks.MockEC2APIMockRecorder) {},
 			expectErr:  false,
 		},
 		{
@@ -126,7 +125,7 @@ func TestReconcileDelete(t *testing.T) {
 			},
 			elbMocks:   func(m *mocks.MockELBAPIMockRecorder) {},
 			elbv2Mocks: func(m *mocks.MockELBV2APIMockRecorder) {},
-			ec2Mocks:   func(m *mocksv2.MockEC2APIMockRecorder) {},
+			ec2Mocks:   func(m *mocks.MockEC2APIMockRecorder) {},
 			expectErr:  false,
 		},
 		{
@@ -158,7 +157,7 @@ func TestReconcileDelete(t *testing.T) {
 			},
 			elbMocks:   func(m *mocks.MockELBAPIMockRecorder) {},
 			elbv2Mocks: func(m *mocks.MockELBV2APIMockRecorder) {},
-			ec2Mocks:   func(m *mocksv2.MockEC2APIMockRecorder) {},
+			ec2Mocks:   func(m *mocks.MockEC2APIMockRecorder) {},
 			expectErr:  false,
 		},
 		{
@@ -190,7 +189,7 @@ func TestReconcileDelete(t *testing.T) {
 			},
 			elbMocks:   func(m *mocks.MockELBAPIMockRecorder) {},
 			elbv2Mocks: func(m *mocks.MockELBV2APIMockRecorder) {},
-			ec2Mocks:   func(m *mocksv2.MockEC2APIMockRecorder) {},
+			ec2Mocks:   func(m *mocks.MockEC2APIMockRecorder) {},
 			expectErr:  false,
 		},
 		{
@@ -230,7 +229,7 @@ func TestReconcileDelete(t *testing.T) {
 				}).Return(&elb.DeleteLoadBalancerOutput{}, nil)
 			},
 			elbv2Mocks: func(m *mocks.MockELBV2APIMockRecorder) {},
-			ec2Mocks:   func(m *mocksv2.MockEC2APIMockRecorder) {},
+			ec2Mocks:   func(m *mocks.MockEC2APIMockRecorder) {},
 			expectErr:  false,
 		},
 		{
@@ -270,7 +269,7 @@ func TestReconcileDelete(t *testing.T) {
 				}).Return(&elb.DeleteLoadBalancerOutput{}, nil)
 			},
 			elbv2Mocks: func(m *mocks.MockELBV2APIMockRecorder) {},
-			ec2Mocks:   func(m *mocksv2.MockEC2APIMockRecorder) {},
+			ec2Mocks:   func(m *mocks.MockEC2APIMockRecorder) {},
 			expectErr:  false,
 		},
 		{
@@ -310,7 +309,7 @@ func TestReconcileDelete(t *testing.T) {
 					LoadBalancerArn: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:loadbalancer/net/aec24434cd2ce4630bd14a955413ee37"),
 				}).Return(&elbv2.DeleteLoadBalancerOutput{}, nil)
 			},
-			ec2Mocks:  func(m *mocksv2.MockEC2APIMockRecorder) {},
+			ec2Mocks:  func(m *mocks.MockEC2APIMockRecorder) {},
 			expectErr: false,
 		},
 		{
@@ -350,7 +349,7 @@ func TestReconcileDelete(t *testing.T) {
 					LoadBalancerArn: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:loadbalancer/net/aec24434cd2ce4630bd14a955413ee37"),
 				}).Return(&elbv2.DeleteLoadBalancerOutput{}, nil)
 			},
-			ec2Mocks:  func(m *mocksv2.MockEC2APIMockRecorder) {},
+			ec2Mocks:  func(m *mocks.MockEC2APIMockRecorder) {},
 			expectErr: false,
 		},
 		{
@@ -390,7 +389,7 @@ func TestReconcileDelete(t *testing.T) {
 					LoadBalancerArn: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:loadbalancer/app/aec24434cd2ce4630bd14a955413ee37"),
 				}).Return(&elbv2.DeleteLoadBalancerOutput{}, nil)
 			},
-			ec2Mocks:  func(m *mocksv2.MockEC2APIMockRecorder) {},
+			ec2Mocks:  func(m *mocks.MockEC2APIMockRecorder) {},
 			expectErr: false,
 		},
 		{
@@ -430,7 +429,7 @@ func TestReconcileDelete(t *testing.T) {
 					LoadBalancerArn: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:loadbalancer/app/aec24434cd2ce4630bd14a955413ee37"),
 				}).Return(&elbv2.DeleteLoadBalancerOutput{}, nil)
 			},
-			ec2Mocks:  func(m *mocksv2.MockEC2APIMockRecorder) {},
+			ec2Mocks:  func(m *mocks.MockEC2APIMockRecorder) {},
 			expectErr: false,
 		},
 		{
@@ -470,7 +469,7 @@ func TestReconcileDelete(t *testing.T) {
 					LoadBalancerArn: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:loadbalancer/app/aec24434cd2ce4630bd14a955413ee37"),
 				}).Return(&elbv2.DeleteLoadBalancerOutput{}, nil)
 			},
-			ec2Mocks:  func(m *mocksv2.MockEC2APIMockRecorder) {},
+			ec2Mocks:  func(m *mocks.MockEC2APIMockRecorder) {},
 			expectErr: false,
 		},
 		{
@@ -540,7 +539,8 @@ func TestReconcileDelete(t *testing.T) {
 					TargetGroupArn: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:targetgroup/k8s-default-podinfo-2c868b281a/e979fe9bd6825433"),
 				}).Return(&elbv2.DeleteTargetGroupOutput{}, nil)
 			},
-			ec2Mocks: func(m *mocksv2.MockEC2APIMockRecorder) {
+			ec2Mocks: func(m *mocks.MockEC2APIMockRecorder) {
+				// ec2Mocks: func(m *mocks.MockEC2APIMockRecorder) {
 				m.DeleteSecurityGroup(gomock.Any(), &ec2.DeleteSecurityGroupInput{
 					GroupId: aws.String("sg-123456"),
 				}).Return(&ec2.DeleteSecurityGroupOutput{}, nil)
@@ -584,7 +584,7 @@ func TestReconcileDelete(t *testing.T) {
 			},
 			elbMocks:   func(m *mocks.MockELBAPIMockRecorder) {},
 			elbv2Mocks: func(m *mocks.MockELBV2APIMockRecorder) {},
-			ec2Mocks:   func(m *mocksv2.MockEC2APIMockRecorder) {},
+			ec2Mocks:   func(m *mocks.MockEC2APIMockRecorder) {},
 			expectErr:  false,
 		},
 		{
@@ -624,7 +624,7 @@ func TestReconcileDelete(t *testing.T) {
 			},
 			elbMocks:   func(m *mocks.MockELBAPIMockRecorder) {},
 			elbv2Mocks: func(m *mocks.MockELBV2APIMockRecorder) {},
-			ec2Mocks:   func(m *mocksv2.MockEC2APIMockRecorder) {},
+			ec2Mocks:   func(m *mocks.MockEC2APIMockRecorder) {},
 			expectErr:  false,
 		},
 		{
@@ -694,7 +694,8 @@ func TestReconcileDelete(t *testing.T) {
 					TargetGroupArn: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:targetgroup/k8s-default-podinfo-2c868b281a/e979fe9bd6825433"),
 				}).Return(&elbv2.DeleteTargetGroupOutput{}, nil)
 			},
-			ec2Mocks: func(m *mocksv2.MockEC2APIMockRecorder) {
+			ec2Mocks: func(m *mocks.MockEC2APIMockRecorder) {
+				// ec2Mocks: func(m *mocks.MockEC2APIMockRecorder) {
 				m.DeleteSecurityGroup(gomock.Any(), &ec2.DeleteSecurityGroupInput{
 					GroupId: aws.String("sg-123456"),
 				}).Return(&ec2.DeleteSecurityGroupOutput{}, nil)
@@ -768,7 +769,7 @@ func TestReconcileDelete(t *testing.T) {
 					TargetGroupArn: aws.String("arn:aws:elasticloadbalancing:eu-west-2:1234567890:targetgroup/k8s-default-podinfo-2c868b281a/e979fe9bd6825433"),
 				}).Return(&elbv2.DeleteTargetGroupOutput{}, nil)
 			},
-			ec2Mocks:  func(m *mocksv2.MockEC2APIMockRecorder) {},
+			ec2Mocks:  func(m *mocks.MockEC2APIMockRecorder) {},
 			expectErr: false,
 		},
 		{
@@ -834,7 +835,7 @@ func TestReconcileDelete(t *testing.T) {
 				}).Return(&elb.DeleteLoadBalancerOutput{}, nil)
 			},
 			elbv2Mocks: func(m *mocks.MockELBV2APIMockRecorder) {},
-			ec2Mocks:   func(m *mocksv2.MockEC2APIMockRecorder) {},
+			ec2Mocks:   func(m *mocks.MockEC2APIMockRecorder) {},
 			expectErr:  false,
 		},
 	}
@@ -848,7 +849,7 @@ func TestReconcileDelete(t *testing.T) {
 			rgapiMock := mocks.NewMockResourceGroupsTaggingAPIAPI(mockCtrl)
 			elbapiMock := mocks.NewMockELBAPI(mockCtrl)
 			elbv2Mock := mocks.NewMockELBV2API(mockCtrl)
-			ec2Mock := mocksv2.NewMockEC2API(mockCtrl)
+			ec2Mock := mocks.NewMockEC2API(mockCtrl)
 
 			tc.rgAPIMocks(rgapiMock.EXPECT())
 			tc.elbMocks(elbapiMock.EXPECT())
diff --git a/pkg/cloud/services/network/carriergateways_test.go b/pkg/cloud/services/network/carriergateways_test.go
index 6608375c7..12c86477a 100644
--- a/pkg/cloud/services/network/carriergateways_test.go
+++ b/pkg/cloud/services/network/carriergateways_test.go
@@ -20,8 +20,9 @@ import (
 	"context"
 	"testing"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/golang/mock/gomock"
 	. "github.com/onsi/gomega"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -52,23 +53,23 @@ func TestReconcileCarrierGateway(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeCarrierGatewaysWithContext(context.TODO(), gomock.Eq(&ec2.DescribeCarrierGatewaysInput{
-					Filters: []*ec2.Filter{
+				m.DescribeCarrierGateways(context.TODO(), gomock.Eq(&ec2.DescribeCarrierGatewaysInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("vpc-id"),
-							Values: aws.StringSlice([]string{"vpc-cagw"}),
+							Values: []string{"vpc-cagw"},
 						},
 					},
 				})).
 					Return(&ec2.DescribeCarrierGatewaysOutput{
-						CarrierGateways: []*ec2.CarrierGateway{
+						CarrierGateways: []types.CarrierGateway{
 							{
 								CarrierGatewayId: ptr.To("cagw-01"),
 							},
 						},
 					}, nil).AnyTimes()
 
-				m.CreateTagsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateTagsInput{})).
+				m.CreateTags(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateTagsInput{})).
 					Return(nil, nil).AnyTimes()
 			},
 		},
@@ -83,15 +84,15 @@ func TestReconcileCarrierGateway(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeCarrierGatewaysWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeCarrierGatewaysInput{})).
+				m.DescribeCarrierGateways(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeCarrierGatewaysInput{})).
 					Return(&ec2.DescribeCarrierGatewaysOutput{}, nil).AnyTimes()
 
-				m.CreateCarrierGatewayWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateCarrierGatewayInput{})).
+				m.CreateCarrierGateway(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateCarrierGatewayInput{})).
 					Return(&ec2.CreateCarrierGatewayOutput{
-						CarrierGateway: &ec2.CarrierGateway{
+						CarrierGateway: &types.CarrierGateway{
 							CarrierGatewayId: aws.String("cagw-1"),
 							VpcId:            aws.String("vpc-cagw"),
-							Tags: []*ec2.Tag{
+							Tags: []types.Tag{
 								{
 									Key:   aws.String(infrav1.ClusterTagKey("test-cluster")),
 									Value: aws.String("owned"),
@@ -180,11 +181,11 @@ func TestDeleteCarrierGateway(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeCarrierGatewaysWithContext(context.TODO(), gomock.Eq(&ec2.DescribeCarrierGatewaysInput{
-					Filters: []*ec2.Filter{
+				m.DescribeCarrierGateways(context.TODO(), gomock.Eq(&ec2.DescribeCarrierGatewaysInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("vpc-id"),
-							Values: aws.StringSlice([]string{"vpc-cagw"}),
+							Values: []string{"vpc-cagw"},
 						},
 					},
 				})).Return(&ec2.DescribeCarrierGatewaysOutput{}, nil)
@@ -201,9 +202,9 @@ func TestDeleteCarrierGateway(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeCarrierGatewaysWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeCarrierGatewaysInput{})).
+				m.DescribeCarrierGateways(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeCarrierGatewaysInput{})).
 					Return(&ec2.DescribeCarrierGatewaysOutput{
-						CarrierGateways: []*ec2.CarrierGateway{
+						CarrierGateways: []types.CarrierGateway{
 							{
 								CarrierGatewayId: aws.String("cagw-0"),
 								VpcId:            aws.String("vpc-gateways"),
@@ -211,7 +212,7 @@ func TestDeleteCarrierGateway(t *testing.T) {
 						},
 					}, nil)
 
-				m.DeleteCarrierGatewayWithContext(context.TODO(), &ec2.DeleteCarrierGatewayInput{
+				m.DeleteCarrierGateway(context.TODO(), &ec2.DeleteCarrierGatewayInput{
 					CarrierGatewayId: aws.String("cagw-0"),
 				}).Return(&ec2.DeleteCarrierGatewayOutput{}, nil)
 			},
diff --git a/pkg/cloud/services/network/egress_only_gateways_test.go b/pkg/cloud/services/network/egress_only_gateways_test.go
index c3dd69954..f85714d95 100644
--- a/pkg/cloud/services/network/egress_only_gateways_test.go
+++ b/pkg/cloud/services/network/egress_only_gateways_test.go
@@ -20,8 +20,9 @@ import (
 	"context"
 	"testing"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/golang/mock/gomock"
 	. "github.com/onsi/gomega"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -55,14 +56,14 @@ func TestReconcileEgressOnlyInternetGateways(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeEgressOnlyInternetGatewaysWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeEgressOnlyInternetGatewaysInput{})).
+				m.DescribeEgressOnlyInternetGateways(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeEgressOnlyInternetGatewaysInput{})).
 					Return(&ec2.DescribeEgressOnlyInternetGatewaysOutput{
-						EgressOnlyInternetGateways: []*ec2.EgressOnlyInternetGateway{
+						EgressOnlyInternetGateways: []types.EgressOnlyInternetGateway{
 							{
 								EgressOnlyInternetGatewayId: aws.String("eigw-0"),
-								Attachments: []*ec2.InternetGatewayAttachment{
+								Attachments: []types.InternetGatewayAttachment{
 									{
-										State: aws.String(ec2.AttachmentStatusAttached),
+										State: types.AttachmentStatusAttached,
 										VpcId: aws.String("vpc-egress-only-gateways"),
 									},
 								},
@@ -70,7 +71,7 @@ func TestReconcileEgressOnlyInternetGateways(t *testing.T) {
 						},
 					}, nil)
 
-				m.CreateTagsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateTagsInput{})).
+				m.CreateTags(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateTagsInput{})).
 					Return(nil, nil)
 			},
 		},
@@ -86,14 +87,14 @@ func TestReconcileEgressOnlyInternetGateways(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeEgressOnlyInternetGatewaysWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeEgressOnlyInternetGatewaysInput{})).
+				m.DescribeEgressOnlyInternetGateways(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeEgressOnlyInternetGatewaysInput{})).
 					Return(&ec2.DescribeEgressOnlyInternetGatewaysOutput{}, nil)
 
-				m.CreateEgressOnlyInternetGatewayWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateEgressOnlyInternetGatewayInput{})).
+				m.CreateEgressOnlyInternetGateway(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateEgressOnlyInternetGatewayInput{})).
 					Return(&ec2.CreateEgressOnlyInternetGatewayOutput{
-						EgressOnlyInternetGateway: &ec2.EgressOnlyInternetGateway{
+						EgressOnlyInternetGateway: &types.EgressOnlyInternetGateway{
 							EgressOnlyInternetGatewayId: aws.String("igw-1"),
-							Tags: []*ec2.Tag{
+							Tags: []types.Tag{
 								{
 									Key:   aws.String(infrav1.ClusterTagKey("test-cluster")),
 									Value: aws.String("owned"),
@@ -107,9 +108,9 @@ func TestReconcileEgressOnlyInternetGateways(t *testing.T) {
 									Value: aws.String("test-cluster-eigw"),
 								},
 							},
-							Attachments: []*ec2.InternetGatewayAttachment{
+							Attachments: []types.InternetGatewayAttachment{
 								{
-									State: aws.String(ec2.AttachmentStatusAttached),
+									State: types.AttachmentStatusAttached,
 									VpcId: aws.String("vpc-egress-only-gateways"),
 								},
 							},
@@ -195,11 +196,11 @@ func TestDeleteEgressOnlyInternetGateways(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeEgressOnlyInternetGatewaysWithContext(context.TODO(), gomock.Eq(&ec2.DescribeEgressOnlyInternetGatewaysInput{
-					Filters: []*ec2.Filter{
+				m.DescribeEgressOnlyInternetGateways(context.TODO(), gomock.Eq(&ec2.DescribeEgressOnlyInternetGatewaysInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("attachment.vpc-id"),
-							Values: aws.StringSlice([]string{"vpc-gateways"}),
+							Values: []string{"vpc-gateways"},
 						},
 					},
 				})).Return(&ec2.DescribeEgressOnlyInternetGatewaysOutput{}, nil)
@@ -217,21 +218,21 @@ func TestDeleteEgressOnlyInternetGateways(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeEgressOnlyInternetGatewaysWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeEgressOnlyInternetGatewaysInput{})).
+				m.DescribeEgressOnlyInternetGateways(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeEgressOnlyInternetGatewaysInput{})).
 					Return(&ec2.DescribeEgressOnlyInternetGatewaysOutput{
-						EgressOnlyInternetGateways: []*ec2.EgressOnlyInternetGateway{
+						EgressOnlyInternetGateways: []types.EgressOnlyInternetGateway{
 							{
 								EgressOnlyInternetGatewayId: aws.String("eigw-0"),
-								Attachments: []*ec2.InternetGatewayAttachment{
+								Attachments: []types.InternetGatewayAttachment{
 									{
-										State: aws.String(ec2.AttachmentStatusAttached),
+										State: types.AttachmentStatusAttached,
 										VpcId: aws.String("vpc-gateways"),
 									},
 								},
 							},
 						},
 					}, nil)
-				m.DeleteEgressOnlyInternetGatewayWithContext(context.TODO(), &ec2.DeleteEgressOnlyInternetGatewayInput{
+				m.DeleteEgressOnlyInternetGateway(context.TODO(), &ec2.DeleteEgressOnlyInternetGatewayInput{
 					EgressOnlyInternetGatewayId: aws.String("eigw-0"),
 				}).Return(&ec2.DeleteEgressOnlyInternetGatewayOutput{}, nil)
 			},
diff --git a/pkg/cloud/services/network/eips_test.go b/pkg/cloud/services/network/eips_test.go
index 9deec16f4..d23fdf431 100644
--- a/pkg/cloud/services/network/eips_test.go
+++ b/pkg/cloud/services/network/eips_test.go
@@ -20,9 +20,10 @@ import (
 	"context"
 	"testing"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/golang/mock/gomock"
 	. "github.com/onsi/gomega"
 	"github.com/pkg/errors"
@@ -48,21 +49,21 @@ func TestServiceReleaseAddresses(t *testing.T) {
 		{
 			name: "Should return error if failed to describe IP addresses",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeAddressesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeAddressesInput{})).Return(nil, awserrors.NewFailedDependency("dependency failure"))
+				m.DescribeAddresses(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeAddressesInput{})).Return(nil, awserrors.NewFailedDependency("dependency failure"))
 			},
 			wantErr: true,
 		},
 		{
 			name: "Should ignore releasing elastic IP addresses if not found",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeAddressesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeAddressesInput{})).Return(nil, nil)
+				m.DescribeAddresses(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeAddressesInput{})).Return(nil, nil)
 			},
 		},
 		{
 			name: "Should return error if failed to disassociate IP address",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeAddressesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeAddressesInput{})).Return(&ec2.DescribeAddressesOutput{
-					Addresses: []*ec2.Address{
+				m.DescribeAddresses(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeAddressesInput{})).Return(&ec2.DescribeAddressesOutput{
+					Addresses: []types.Address{
 						{
 							AssociationId: aws.String("association-id-1"),
 							PublicIp:      aws.String("public-ip"),
@@ -70,15 +71,15 @@ func TestServiceReleaseAddresses(t *testing.T) {
 						},
 					},
 				}, nil)
-				m.DisassociateAddressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DisassociateAddressInput{})).Return(nil, awserrors.NewFailedDependency("dependency-failure"))
+				m.DisassociateAddress(context.TODO(), gomock.AssignableToTypeOf(&ec2.DisassociateAddressInput{})).Return(nil, awserrors.NewFailedDependency("dependency-failure"))
 			},
 			wantErr: true,
 		},
 		{
 			name: "Should be able to release the IP address",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeAddressesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeAddressesInput{})).Return(&ec2.DescribeAddressesOutput{
-					Addresses: []*ec2.Address{
+				m.DescribeAddresses(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeAddressesInput{})).Return(&ec2.DescribeAddressesOutput{
+					Addresses: []types.Address{
 						{
 							AssociationId: aws.String("association-id-1"),
 							PublicIp:      aws.String("public-ip"),
@@ -86,15 +87,15 @@ func TestServiceReleaseAddresses(t *testing.T) {
 						},
 					},
 				}, nil)
-				m.DisassociateAddressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DisassociateAddressInput{})).Return(nil, nil)
-				m.ReleaseAddressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.ReleaseAddressInput{})).Return(nil, nil)
+				m.DisassociateAddress(context.TODO(), gomock.AssignableToTypeOf(&ec2.DisassociateAddressInput{})).Return(nil, nil)
+				m.ReleaseAddress(context.TODO(), gomock.AssignableToTypeOf(&ec2.ReleaseAddressInput{})).Return(nil, nil)
 			},
 		},
 		{
 			name: "Should retry if unable to release the IP address because of Auth Failure",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeAddressesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeAddressesInput{})).Return(&ec2.DescribeAddressesOutput{
-					Addresses: []*ec2.Address{
+				m.DescribeAddresses(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeAddressesInput{})).Return(&ec2.DescribeAddressesOutput{
+					Addresses: []types.Address{
 						{
 							AssociationId: aws.String("association-id-1"),
 							PublicIp:      aws.String("public-ip"),
@@ -102,16 +103,16 @@ func TestServiceReleaseAddresses(t *testing.T) {
 						},
 					},
 				}, nil)
-				m.DisassociateAddressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DisassociateAddressInput{})).Return(nil, nil).Times(2)
-				m.ReleaseAddressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.ReleaseAddressInput{})).Return(nil, awserr.New(awserrors.AuthFailure, awserrors.AuthFailure, errors.Errorf(awserrors.AuthFailure)))
-				m.ReleaseAddressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.ReleaseAddressInput{})).Return(nil, nil)
+				m.DisassociateAddress(context.TODO(), gomock.AssignableToTypeOf(&ec2.DisassociateAddressInput{})).Return(nil, nil).Times(2)
+				m.ReleaseAddress(context.TODO(), gomock.AssignableToTypeOf(&ec2.ReleaseAddressInput{})).Return(nil, awserr.New(awserrors.AuthFailure, awserrors.AuthFailure, errors.Errorf(awserrors.AuthFailure)))
+				m.ReleaseAddress(context.TODO(), gomock.AssignableToTypeOf(&ec2.ReleaseAddressInput{})).Return(nil, nil)
 			},
 		},
 		{
 			name: "Should retry if unable to release the IP address because IP is already in use",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeAddressesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeAddressesInput{})).Return(&ec2.DescribeAddressesOutput{
-					Addresses: []*ec2.Address{
+				m.DescribeAddresses(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeAddressesInput{})).Return(&ec2.DescribeAddressesOutput{
+					Addresses: []types.Address{
 						{
 							AssociationId: aws.String("association-id-1"),
 							PublicIp:      aws.String("public-ip"),
@@ -119,16 +120,16 @@ func TestServiceReleaseAddresses(t *testing.T) {
 						},
 					},
 				}, nil)
-				m.DisassociateAddressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DisassociateAddressInput{})).Return(nil, nil).Times(2)
-				m.ReleaseAddressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.ReleaseAddressInput{})).Return(nil, awserr.New(awserrors.InUseIPAddress, awserrors.InUseIPAddress, errors.Errorf(awserrors.InUseIPAddress)))
-				m.ReleaseAddressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.ReleaseAddressInput{})).Return(nil, nil)
+				m.DisassociateAddress(context.TODO(), gomock.AssignableToTypeOf(&ec2.DisassociateAddressInput{})).Return(nil, nil).Times(2)
+				m.ReleaseAddress(context.TODO(), gomock.AssignableToTypeOf(&ec2.ReleaseAddressInput{})).Return(nil, awserr.New(awserrors.InUseIPAddress, awserrors.InUseIPAddress, errors.Errorf(awserrors.InUseIPAddress)))
+				m.ReleaseAddress(context.TODO(), gomock.AssignableToTypeOf(&ec2.ReleaseAddressInput{})).Return(nil, nil)
 			},
 		},
 		{
 			name: "Should not retry if unable to release the IP address due to dependency failure",
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeAddressesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeAddressesInput{})).Return(&ec2.DescribeAddressesOutput{
-					Addresses: []*ec2.Address{
+				m.DescribeAddresses(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeAddressesInput{})).Return(&ec2.DescribeAddressesOutput{
+					Addresses: []types.Address{
 						{
 							AssociationId: aws.String("association-id-1"),
 							PublicIp:      aws.String("public-ip"),
@@ -136,8 +137,8 @@ func TestServiceReleaseAddresses(t *testing.T) {
 						},
 					},
 				}, nil)
-				m.DisassociateAddressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DisassociateAddressInput{})).Return(nil, nil).Times(2)
-				m.ReleaseAddressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.ReleaseAddressInput{})).Return(nil, awserr.New("dependency-failure", "dependency-failure", errors.Errorf("dependency-failure")))
+				m.DisassociateAddress(context.TODO(), gomock.AssignableToTypeOf(&ec2.DisassociateAddressInput{})).Return(nil, nil).Times(2)
+				m.ReleaseAddress(context.TODO(), gomock.AssignableToTypeOf(&ec2.ReleaseAddressInput{})).Return(nil, awserr.New("dependency-failure", "dependency-failure", errors.Errorf("dependency-failure")))
 			},
 			wantErr: true,
 		},
diff --git a/pkg/cloud/services/network/gateways_test.go b/pkg/cloud/services/network/gateways_test.go
index cf82e42a4..150571c21 100644
--- a/pkg/cloud/services/network/gateways_test.go
+++ b/pkg/cloud/services/network/gateways_test.go
@@ -20,8 +20,9 @@ import (
 	"context"
 	"testing"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/golang/mock/gomock"
 	. "github.com/onsi/gomega"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -54,14 +55,14 @@ func TestReconcileInternetGateways(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeInternetGatewaysWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeInternetGatewaysInput{})).
+				m.DescribeInternetGateways(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeInternetGatewaysInput{})).
 					Return(&ec2.DescribeInternetGatewaysOutput{
-						InternetGateways: []*ec2.InternetGateway{
+						InternetGateways: []types.InternetGateway{
 							{
 								InternetGatewayId: aws.String("igw-0"),
-								Attachments: []*ec2.InternetGatewayAttachment{
+								Attachments: []types.InternetGatewayAttachment{
 									{
-										State: aws.String(ec2.AttachmentStatusAttached),
+										State: types.AttachmentStatusAttached,
 										VpcId: aws.String("vpc-gateways"),
 									},
 								},
@@ -69,7 +70,7 @@ func TestReconcileInternetGateways(t *testing.T) {
 						},
 					}, nil)
 
-				m.CreateTagsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateTagsInput{})).
+				m.CreateTags(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateTagsInput{})).
 					Return(nil, nil)
 			},
 		},
@@ -84,14 +85,14 @@ func TestReconcileInternetGateways(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeInternetGatewaysWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeInternetGatewaysInput{})).
+				m.DescribeInternetGateways(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeInternetGatewaysInput{})).
 					Return(&ec2.DescribeInternetGatewaysOutput{}, nil)
 
-				m.CreateInternetGatewayWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateInternetGatewayInput{})).
+				m.CreateInternetGateway(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateInternetGatewayInput{})).
 					Return(&ec2.CreateInternetGatewayOutput{
-						InternetGateway: &ec2.InternetGateway{
+						InternetGateway: &types.InternetGateway{
 							InternetGatewayId: aws.String("igw-1"),
-							Tags: []*ec2.Tag{
+							Tags: []types.Tag{
 								{
 									Key:   aws.String(infrav1.ClusterTagKey("test-cluster")),
 									Value: aws.String("owned"),
@@ -108,7 +109,7 @@ func TestReconcileInternetGateways(t *testing.T) {
 						},
 					}, nil)
 
-				m.AttachInternetGatewayWithContext(context.TODO(), gomock.Eq(&ec2.AttachInternetGatewayInput{
+				m.AttachInternetGateway(context.TODO(), gomock.Eq(&ec2.AttachInternetGatewayInput{
 					InternetGatewayId: aws.String("igw-1"),
 					VpcId:             aws.String("vpc-gateways"),
 				})).
@@ -182,11 +183,11 @@ func TestDeleteInternetGateways(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeInternetGatewaysWithContext(context.TODO(), gomock.Eq(&ec2.DescribeInternetGatewaysInput{
-					Filters: []*ec2.Filter{
+				m.DescribeInternetGateways(context.TODO(), gomock.Eq(&ec2.DescribeInternetGatewaysInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("attachment.vpc-id"),
-							Values: aws.StringSlice([]string{"vpc-gateways"}),
+							Values: []string{"vpc-gateways"},
 						},
 					},
 				})).Return(&ec2.DescribeInternetGatewaysOutput{}, nil)
@@ -203,25 +204,25 @@ func TestDeleteInternetGateways(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeInternetGatewaysWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeInternetGatewaysInput{})).
+				m.DescribeInternetGateways(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeInternetGatewaysInput{})).
 					Return(&ec2.DescribeInternetGatewaysOutput{
-						InternetGateways: []*ec2.InternetGateway{
+						InternetGateways: []types.InternetGateway{
 							{
 								InternetGatewayId: aws.String("igw-0"),
-								Attachments: []*ec2.InternetGatewayAttachment{
+								Attachments: []types.InternetGatewayAttachment{
 									{
-										State: aws.String(ec2.AttachmentStatusAttached),
+										State: types.AttachmentStatusAttached,
 										VpcId: aws.String("vpc-gateways"),
 									},
 								},
 							},
 						},
 					}, nil)
-				m.DetachInternetGatewayWithContext(context.TODO(), &ec2.DetachInternetGatewayInput{
+				m.DetachInternetGateway(context.TODO(), &ec2.DetachInternetGatewayInput{
 					InternetGatewayId: aws.String("igw-0"),
 					VpcId:             aws.String("vpc-gateways"),
 				}).Return(&ec2.DetachInternetGatewayOutput{}, nil)
-				m.DeleteInternetGatewayWithContext(context.TODO(), &ec2.DeleteInternetGatewayInput{
+				m.DeleteInternetGateway(context.TODO(), &ec2.DeleteInternetGatewayInput{
 					InternetGatewayId: aws.String("igw-0"),
 				}).Return(&ec2.DeleteInternetGatewayOutput{}, nil)
 			},
diff --git a/pkg/cloud/services/network/natgateways_test.go b/pkg/cloud/services/network/natgateways_test.go
index a77686d61..ae3cb2671 100644
--- a/pkg/cloud/services/network/natgateways_test.go
+++ b/pkg/cloud/services/network/natgateways_test.go
@@ -20,9 +20,9 @@ import (
 	"context"
 	"testing"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/golang/mock/gomock"
 	. "github.com/onsi/gomega"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -61,7 +61,7 @@ func TestReconcileNatGateways(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.CreateNatGatewayWithContext(context.TODO(), gomock.Any()).Times(0)
+				m.CreateNatGateway(context.TODO(), gomock.Any()).Times(0)
 			},
 		},
 		{
@@ -75,8 +75,8 @@ func TestReconcileNatGateways(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(), gomock.Any(), gomock.Any()).Times(0)
-				m.CreateNatGatewayWithContext(context.TODO(), gomock.Any()).Times(0)
+				m.DescribeNatGateways(context.TODO(), gomock.Any(), gomock.Any()).Times(0)
+				m.CreateNatGateway(context.TODO(), gomock.Any()).Times(0)
 			},
 		},
 		{
@@ -96,30 +96,30 @@ func TestReconcileNatGateways(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
+				m.DescribeNatGateways(context.TODO(),
 					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
+						Filter: []types.Filter{
 							{
 								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
+								Values: []string{subnetsVPCID},
 							},
 							{
 								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
+								Values: []string{"pending", "available"},
 							},
 						},
 					}),
-					gomock.Any()).Return(nil)
+					gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 
-				m.DescribeAddressesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeAddresses(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeAddressesOutput{}, nil)
 
-				m.AllocateAddressWithContext(context.TODO(), &ec2.AllocateAddressInput{
-					Domain: aws.String("vpc"),
-					TagSpecifications: []*ec2.TagSpecification{
+				m.AllocateAddress(context.TODO(), &ec2.AllocateAddressInput{
+					Domain: types.DomainTypeVpc,
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("elastic-ip"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeElasticIp,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-eip-common"),
@@ -139,13 +139,13 @@ func TestReconcileNatGateways(t *testing.T) {
 					AllocationId: aws.String(ElasticIPAllocationID),
 				}, nil)
 
-				m.CreateNatGatewayWithContext(context.TODO(), &ec2.CreateNatGatewayInput{
+				m.CreateNatGateway(context.TODO(), &ec2.CreateNatGatewayInput{
 					AllocationId: aws.String(ElasticIPAllocationID),
 					SubnetId:     aws.String("subnet-1"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("natgateway"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeNatgateway,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-nat"),
@@ -163,15 +163,23 @@ func TestReconcileNatGateways(t *testing.T) {
 					},
 				},
 				).Return(&ec2.CreateNatGatewayOutput{
-					NatGateway: &ec2.NatGateway{
+					NatGateway: &types.NatGateway{
 						NatGatewayId: aws.String("natgateway"),
 						SubnetId:     aws.String("subnet-1"),
 					},
 				}, nil)
 
-				m.WaitUntilNatGatewayAvailableWithContext(context.TODO(), &ec2.DescribeNatGatewaysInput{
-					NatGatewayIds: []*string{aws.String("natgateway")},
-				}).Return(nil)
+				m.DescribeNatGateways(gomock.Any(), &ec2.DescribeNatGatewaysInput{
+					NatGatewayIds: []string{"natgateway"},
+				}, gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{
+					NatGateways: []types.NatGateway{
+						{
+							State:        types.NatGatewayStateAvailable,
+							NatGatewayId: aws.String("natgateway"),
+							SubnetId:     aws.String("subnet-1"),
+						},
+					},
+				}, nil)
 			},
 		},
 		{
@@ -197,36 +205,38 @@ func TestReconcileNatGateways(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
+				m.DescribeNatGateways(context.TODO(),
 					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
+						Filter: []types.Filter{
 							{
 								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
+								Values: []string{subnetsVPCID},
 							},
 							{
 								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
+								Values: []string{"pending", "available"},
 							},
 						},
 					}),
-					gomock.Any()).Do(func(ctx context.Context, _, y interface{}, requestOptions ...request.Option) {
-					funct := y.(func(page *ec2.DescribeNatGatewaysOutput, lastPage bool) bool)
-					funct(&ec2.DescribeNatGatewaysOutput{NatGateways: []*ec2.NatGateway{{
-						NatGatewayId: aws.String("gateway"),
-						SubnetId:     aws.String("subnet-1"),
-					}}}, true)
-				}).Return(nil)
+					gomock.Any()).
+					Return(&ec2.DescribeNatGatewaysOutput{
+						NatGateways: []types.NatGateway{
+							{
+								NatGatewayId: aws.String("gateway"),
+								SubnetId:     aws.String("subnet-1"),
+							},
+						},
+					}, nil)
 
-				m.DescribeAddressesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeAddresses(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeAddressesOutput{}, nil)
 
-				m.AllocateAddressWithContext(context.TODO(), &ec2.AllocateAddressInput{
-					Domain: aws.String("vpc"),
-					TagSpecifications: []*ec2.TagSpecification{
+				m.AllocateAddress(context.TODO(), &ec2.AllocateAddressInput{
+					Domain: types.DomainTypeVpc,
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("elastic-ip"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeElasticIp,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-eip-common"),
@@ -246,13 +256,13 @@ func TestReconcileNatGateways(t *testing.T) {
 					AllocationId: aws.String(ElasticIPAllocationID),
 				}, nil)
 
-				m.CreateNatGatewayWithContext(context.TODO(), &ec2.CreateNatGatewayInput{
+				m.CreateNatGateway(context.TODO(), &ec2.CreateNatGatewayInput{
 					AllocationId: aws.String(ElasticIPAllocationID),
 					SubnetId:     aws.String("subnet-3"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("natgateway"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeNatgateway,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-nat"),
@@ -269,17 +279,25 @@ func TestReconcileNatGateways(t *testing.T) {
 						},
 					},
 				}).Return(&ec2.CreateNatGatewayOutput{
-					NatGateway: &ec2.NatGateway{
+					NatGateway: &types.NatGateway{
 						NatGatewayId: aws.String("natgateway"),
 						SubnetId:     aws.String("subnet-3"),
 					},
 				}, nil)
 
-				m.WaitUntilNatGatewayAvailableWithContext(context.TODO(), &ec2.DescribeNatGatewaysInput{
-					NatGatewayIds: []*string{aws.String("natgateway")},
-				}).Return(nil)
+				m.DescribeNatGateways(gomock.Any(), &ec2.DescribeNatGatewaysInput{
+					NatGatewayIds: []string{"natgateway"},
+				}, gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{
+					NatGateways: []types.NatGateway{
+						{
+							State:        types.NatGatewayStateAvailable,
+							NatGatewayId: aws.String("natgateway"),
+							SubnetId:     aws.String("subnet-3"),
+						},
+					},
+				}, nil)
 
-				m.CreateTagsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateTagsInput{})).
+				m.CreateTags(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateTagsInput{})).
 					Return(nil, nil).Times(1)
 			},
 		},
@@ -300,44 +318,44 @@ func TestReconcileNatGateways(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
+				m.DescribeNatGateways(context.TODO(),
 					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
+						Filter: []types.Filter{
 							{
 								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
+								Values: []string{subnetsVPCID},
 							},
 							{
 								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
+								Values: []string{"pending", "available"},
 							},
 						},
 					}),
-					gomock.Any()).Do(func(ctx context.Context, _, y interface{}, requestOptions ...request.Option) {
-					funct := y.(func(page *ec2.DescribeNatGatewaysOutput, lastPage bool) bool)
-					funct(&ec2.DescribeNatGatewaysOutput{NatGateways: []*ec2.NatGateway{{
-						NatGatewayId: aws.String("gateway"),
-						SubnetId:     aws.String("subnet-1"),
-						Tags: []*ec2.Tag{
-							{
-								Key:   aws.String("sigs.k8s.io/cluster-api-provider-aws/role"),
-								Value: aws.String("common"),
-							},
-							{
-								Key:   aws.String("Name"),
-								Value: aws.String("test-cluster-nat"),
-							},
-							{
-								Key:   aws.String("sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"),
-								Value: aws.String("owned"),
+					gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{
+					NatGateways: []types.NatGateway{
+						{
+							NatGatewayId: aws.String("gateway"),
+							SubnetId:     aws.String("subnet-1"),
+							Tags: []types.Tag{
+								{
+									Key:   aws.String("sigs.k8s.io/cluster-api-provider-aws/role"),
+									Value: aws.String("common"),
+								},
+								{
+									Key:   aws.String("Name"),
+									Value: aws.String("test-cluster-nat"),
+								},
+								{
+									Key:   aws.String("sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"),
+									Value: aws.String("owned"),
+								},
 							},
 						},
-					}}}, true)
-				}).Return(nil)
+					}}, nil)
 
-				m.DescribeAddressesWithContext(context.TODO(), gomock.Any()).Times(0)
-				m.AllocateAddressWithContext(context.TODO(), gomock.Any()).Times(0)
-				m.CreateNatGatewayWithContext(context.TODO(), gomock.Any()).Times(0)
+				m.DescribeAddresses(context.TODO(), gomock.Any()).Times(0)
+				m.AllocateAddress(context.TODO(), gomock.Any()).Times(0)
+				m.CreateNatGateway(context.TODO(), gomock.Any()).Times(0)
 			},
 		},
 		{
@@ -357,8 +375,8 @@ func TestReconcileNatGateways(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(), gomock.Any(), gomock.Any()).
-					Return(nil).
+				m.DescribeNatGateways(context.TODO(), gomock.Any(), gomock.Any()).
+					Return(&ec2.DescribeNatGatewaysOutput{}, nil).
 					Times(1)
 			},
 		},
@@ -462,20 +480,18 @@ func TestDeleteNatGateways(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String("managed-vpc")},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{"managed-vpc"},
 						},
-					}),
-					gomock.Any()).Return(nil)
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 			},
 		},
 		{
@@ -495,27 +511,33 @@ func TestDeleteNatGateways(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.AssignableToTypeOf(&ec2.DescribeNatGatewaysInput{}),
-					gomock.Any()).Do(mockDescribeNatGatewaysOutput).Return(nil)
+				m.DescribeNatGateways(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeNatGatewaysInput{}), gomock.Any()).
+					Return(&ec2.DescribeNatGatewaysOutput{
+						NatGateways: []types.NatGateway{
+							{
+								NatGatewayId: aws.String("natgateway"),
+								SubnetId:     aws.String("subnet-1"),
+							},
+						},
+					}, nil)
 
-				m.DeleteNatGatewayWithContext(context.TODO(), gomock.Eq(&ec2.DeleteNatGatewayInput{
+				m.DeleteNatGateway(context.TODO(), gomock.Eq(&ec2.DeleteNatGatewayInput{
 					NatGatewayId: aws.String("natgateway"),
 				})).Return(&ec2.DeleteNatGatewayOutput{}, nil)
 
-				m.DescribeNatGatewaysWithContext(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
-					NatGatewayIds: []*string{aws.String("natgateway")},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					NatGatewayIds: []string{"natgateway"},
 				})).Return(&ec2.DescribeNatGatewaysOutput{
-					NatGateways: []*ec2.NatGateway{
+					NatGateways: []types.NatGateway{
 						{
-							State: aws.String("available"),
+							State: types.NatGatewayStateAvailable,
 						},
 					},
 				}, nil)
-				m.DescribeNatGatewaysWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeNatGatewaysInput{})).Return(&ec2.DescribeNatGatewaysOutput{
-					NatGateways: []*ec2.NatGateway{
+				m.DescribeNatGateways(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeNatGatewaysInput{})).Return(&ec2.DescribeNatGatewaysOutput{
+					NatGateways: []types.NatGateway{
 						{
-							State: aws.String("deleted"),
+							State: types.NatGatewayStateDeleted,
 						},
 					},
 				}, nil)
@@ -544,19 +566,26 @@ func TestDeleteNatGateways(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.AssignableToTypeOf(&ec2.DescribeNatGatewaysInput{}), gomock.Any()).Do(mockDescribeNatGatewaysOutput).Return(nil)
+				m.DescribeNatGateways(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeNatGatewaysInput{}), gomock.Any()).
+					Return(&ec2.DescribeNatGatewaysOutput{
+						NatGateways: []types.NatGateway{
+							{
+								NatGatewayId: aws.String("natgateway"),
+								SubnetId:     aws.String("subnet-1"),
+							},
+						},
+					}, nil)
 
-				m.DeleteNatGatewayWithContext(context.TODO(), gomock.Eq(&ec2.DeleteNatGatewayInput{
+				m.DeleteNatGateway(context.TODO(), gomock.Eq(&ec2.DeleteNatGatewayInput{
 					NatGatewayId: aws.String("natgateway"),
 				})).Return(&ec2.DeleteNatGatewayOutput{}, nil)
 
-				m.DescribeNatGatewaysWithContext(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
-					NatGatewayIds: []*string{aws.String("natgateway")},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					NatGatewayIds: []string{"natgateway"},
 				})).Return(&ec2.DescribeNatGatewaysOutput{
-					NatGateways: []*ec2.NatGateway{
+					NatGateways: []types.NatGateway{
 						{
-							State: aws.String("unknown"),
+							State: types.NatGatewayStatePending,
 						},
 					},
 				}, nil)
@@ -580,15 +609,22 @@ func TestDeleteNatGateways(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.AssignableToTypeOf(&ec2.DescribeNatGatewaysInput{}), gomock.Any()).Do(mockDescribeNatGatewaysOutput).Return(nil)
+				m.DescribeNatGateways(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeNatGatewaysInput{}), gomock.Any()).
+					Return(&ec2.DescribeNatGatewaysOutput{
+						NatGateways: []types.NatGateway{
+							{
+								NatGatewayId: aws.String("natgateway"),
+								SubnetId:     aws.String("subnet-1"),
+							},
+						},
+					}, nil)
 
-				m.DeleteNatGatewayWithContext(context.TODO(), gomock.Eq(&ec2.DeleteNatGatewayInput{
+				m.DeleteNatGateway(context.TODO(), gomock.Eq(&ec2.DeleteNatGatewayInput{
 					NatGatewayId: aws.String("natgateway"),
 				})).Return(&ec2.DeleteNatGatewayOutput{}, nil)
 
-				m.DescribeNatGatewaysWithContext(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
-					NatGatewayIds: []*string{aws.String("natgateway")},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					NatGatewayIds: []string{"natgateway"},
 				})).Return(nil, nil)
 			},
 			wantErr: true,
@@ -610,8 +646,8 @@ func TestDeleteNatGateways(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.AssignableToTypeOf(&ec2.DescribeNatGatewaysInput{}), gomock.Any()).Return(awserrors.NewFailedDependency("failed dependency"))
+				m.DescribeNatGateways(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeNatGatewaysInput{}), gomock.Any()).
+					Return(nil, awserrors.NewFailedDependency("failed dependency"))
 			},
 			wantErr: true,
 		},
@@ -632,10 +668,17 @@ func TestDeleteNatGateways(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.AssignableToTypeOf(&ec2.DescribeNatGatewaysInput{}), gomock.Any()).Do(mockDescribeNatGatewaysOutput).Return(nil)
+				m.DescribeNatGateways(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeNatGatewaysInput{}), gomock.Any()).
+					Return(&ec2.DescribeNatGatewaysOutput{
+						NatGateways: []types.NatGateway{
+							{
+								NatGatewayId: aws.String("natgateway"),
+								SubnetId:     aws.String("subnet-1"),
+							},
+						},
+					}, nil)
 
-				m.DeleteNatGatewayWithContext(context.TODO(), gomock.Eq(&ec2.DeleteNatGatewayInput{
+				m.DeleteNatGateway(context.TODO(), gomock.Eq(&ec2.DeleteNatGatewayInput{
 					NatGatewayId: aws.String("natgateway"),
 				})).Return(nil, awserrors.NewFailedDependency("failed dependency"))
 			},
@@ -658,15 +701,22 @@ func TestDeleteNatGateways(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.AssignableToTypeOf(&ec2.DescribeNatGatewaysInput{}), gomock.Any()).Do(mockDescribeNatGatewaysOutput).Return(nil)
+				m.DescribeNatGateways(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeNatGatewaysInput{}), gomock.Any()).
+					Return(&ec2.DescribeNatGatewaysOutput{
+						NatGateways: []types.NatGateway{
+							{
+								NatGatewayId: aws.String("natgateway"),
+								SubnetId:     aws.String("subnet-1"),
+							},
+						},
+					}, nil)
 
-				m.DeleteNatGatewayWithContext(context.TODO(), gomock.Eq(&ec2.DeleteNatGatewayInput{
+				m.DeleteNatGateway(context.TODO(), gomock.Eq(&ec2.DeleteNatGatewayInput{
 					NatGatewayId: aws.String("natgateway"),
 				})).Return(&ec2.DeleteNatGatewayOutput{}, nil)
 
-				m.DescribeNatGatewaysWithContext(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
-					NatGatewayIds: []*string{aws.String("natgateway")},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					NatGatewayIds: []string{"natgateway"},
 				})).Return(nil, awserrors.NewNotFound("not found"))
 			},
 			wantErr: true,
@@ -722,14 +772,6 @@ func TestDeleteNatGateways(t *testing.T) {
 	}
 }
 
-var mockDescribeNatGatewaysOutput = func(ctx context.Context, _, y interface{}, requestOptions ...request.Option) {
-	funct := y.(func(page *ec2.DescribeNatGatewaysOutput, lastPage bool) bool)
-	funct(&ec2.DescribeNatGatewaysOutput{NatGateways: []*ec2.NatGateway{{
-		NatGatewayId: aws.String("natgateway"),
-		SubnetId:     aws.String("subnet-1"),
-	}}}, true)
-}
-
 func TestGetdNatGatewayForEdgeSubnet(t *testing.T) {
 	subnetsSpec := infrav1.Subnets{
 		{
diff --git a/pkg/cloud/services/network/routetables_test.go b/pkg/cloud/services/network/routetables_test.go
index 6b6003a2d..c1ab2825c 100644
--- a/pkg/cloud/services/network/routetables_test.go
+++ b/pkg/cloud/services/network/routetables_test.go
@@ -22,8 +22,9 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/golang/mock/gomock"
 	"github.com/google/go-cmp/cmp"
 	. "github.com/onsi/gomega"
@@ -75,37 +76,37 @@ func TestReconcileRouteTables(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{}, nil)
 
-				privateRouteTable := m.CreateRouteTableWithContext(context.TODO(), matchRouteTableInput(&ec2.CreateRouteTableInput{VpcId: aws.String("vpc-routetables")})).
-					Return(&ec2.CreateRouteTableOutput{RouteTable: &ec2.RouteTable{RouteTableId: aws.String("rt-1")}}, nil)
+				privateRouteTable := m.CreateRouteTable(context.TODO(), matchRouteTableInput(&ec2.CreateRouteTableInput{VpcId: aws.String("vpc-routetables")})).
+					Return(&ec2.CreateRouteTableOutput{RouteTable: &types.RouteTable{RouteTableId: aws.String("rt-1")}}, nil)
 
-				m.CreateRouteWithContext(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
+				m.CreateRoute(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
 					NatGatewayId:         aws.String("nat-01"),
 					DestinationCidrBlock: aws.String("0.0.0.0/0"),
 					RouteTableId:         aws.String("rt-1"),
 				})).
 					After(privateRouteTable)
 
-				m.AssociateRouteTableWithContext(context.TODO(), gomock.Eq(&ec2.AssociateRouteTableInput{
+				m.AssociateRouteTable(context.TODO(), gomock.Eq(&ec2.AssociateRouteTableInput{
 					RouteTableId: aws.String("rt-1"),
 					SubnetId:     aws.String("subnet-routetables-private"),
 				})).
 					Return(&ec2.AssociateRouteTableOutput{}, nil).
 					After(privateRouteTable)
 
-				publicRouteTable := m.CreateRouteTableWithContext(context.TODO(), matchRouteTableInput(&ec2.CreateRouteTableInput{VpcId: aws.String("vpc-routetables")})).
-					Return(&ec2.CreateRouteTableOutput{RouteTable: &ec2.RouteTable{RouteTableId: aws.String("rt-2")}}, nil)
+				publicRouteTable := m.CreateRouteTable(context.TODO(), matchRouteTableInput(&ec2.CreateRouteTableInput{VpcId: aws.String("vpc-routetables")})).
+					Return(&ec2.CreateRouteTableOutput{RouteTable: &types.RouteTable{RouteTableId: aws.String("rt-2")}}, nil)
 
-				m.CreateRouteWithContext(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
+				m.CreateRoute(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
 					GatewayId:            aws.String("igw-01"),
 					DestinationCidrBlock: aws.String("0.0.0.0/0"),
 					RouteTableId:         aws.String("rt-2"),
 				})).
 					After(publicRouteTable)
 
-				m.AssociateRouteTableWithContext(context.TODO(), gomock.Eq(&ec2.AssociateRouteTableInput{
+				m.AssociateRouteTable(context.TODO(), gomock.Eq(&ec2.AssociateRouteTableInput{
 					RouteTableId: aws.String("rt-2"),
 					SubnetId:     aws.String("subnet-routetables-public"),
 				})).
@@ -147,51 +148,51 @@ func TestReconcileRouteTables(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{}, nil)
 
-				privateRouteTable := m.CreateRouteTableWithContext(context.TODO(), matchRouteTableInput(&ec2.CreateRouteTableInput{VpcId: aws.String("vpc-routetables")})).
-					Return(&ec2.CreateRouteTableOutput{RouteTable: &ec2.RouteTable{RouteTableId: aws.String("rt-1")}}, nil)
+				privateRouteTable := m.CreateRouteTable(context.TODO(), matchRouteTableInput(&ec2.CreateRouteTableInput{VpcId: aws.String("vpc-routetables")})).
+					Return(&ec2.CreateRouteTableOutput{RouteTable: &types.RouteTable{RouteTableId: aws.String("rt-1")}}, nil)
 
-				m.CreateRouteWithContext(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
+				m.CreateRoute(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
 					NatGatewayId:         aws.String("nat-01"),
 					DestinationCidrBlock: aws.String("0.0.0.0/0"),
 					RouteTableId:         aws.String("rt-1"),
 				})).
 					After(privateRouteTable)
 
-				m.CreateRouteWithContext(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
+				m.CreateRoute(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
 					DestinationIpv6CidrBlock:    aws.String("::/0"),
 					EgressOnlyInternetGatewayId: aws.String("eigw-01"),
 					RouteTableId:                aws.String("rt-1"),
 				})).
 					After(privateRouteTable)
 
-				m.AssociateRouteTableWithContext(context.TODO(), gomock.Eq(&ec2.AssociateRouteTableInput{
+				m.AssociateRouteTable(context.TODO(), gomock.Eq(&ec2.AssociateRouteTableInput{
 					RouteTableId: aws.String("rt-1"),
 					SubnetId:     aws.String("subnet-routetables-private"),
 				})).
 					Return(&ec2.AssociateRouteTableOutput{}, nil).
 					After(privateRouteTable)
 
-				publicRouteTable := m.CreateRouteTableWithContext(context.TODO(), matchRouteTableInput(&ec2.CreateRouteTableInput{VpcId: aws.String("vpc-routetables")})).
-					Return(&ec2.CreateRouteTableOutput{RouteTable: &ec2.RouteTable{RouteTableId: aws.String("rt-2")}}, nil)
+				publicRouteTable := m.CreateRouteTable(context.TODO(), matchRouteTableInput(&ec2.CreateRouteTableInput{VpcId: aws.String("vpc-routetables")})).
+					Return(&ec2.CreateRouteTableOutput{RouteTable: &types.RouteTable{RouteTableId: aws.String("rt-2")}}, nil)
 
-				m.CreateRouteWithContext(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
+				m.CreateRoute(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
 					GatewayId:            aws.String("igw-01"),
 					DestinationCidrBlock: aws.String("0.0.0.0/0"),
 					RouteTableId:         aws.String("rt-2"),
 				})).
 					After(publicRouteTable)
 
-				m.CreateRouteWithContext(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
+				m.CreateRoute(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
 					DestinationIpv6CidrBlock: aws.String("::/0"),
 					GatewayId:                aws.String("igw-01"),
 					RouteTableId:             aws.String("rt-2"),
 				})).
 					After(publicRouteTable)
 
-				m.AssociateRouteTableWithContext(context.TODO(), gomock.Eq(&ec2.AssociateRouteTableInput{
+				m.AssociateRouteTable(context.TODO(), gomock.Eq(&ec2.AssociateRouteTableInput{
 					RouteTableId: aws.String("rt-2"),
 					SubnetId:     aws.String("subnet-routetables-public"),
 				})).
@@ -233,51 +234,51 @@ func TestReconcileRouteTables(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{}, nil)
 
-				privateRouteTable := m.CreateRouteTableWithContext(context.TODO(), matchRouteTableInput(&ec2.CreateRouteTableInput{VpcId: aws.String("vpc-routetables")})).
-					Return(&ec2.CreateRouteTableOutput{RouteTable: &ec2.RouteTable{RouteTableId: aws.String("rt-1")}}, nil)
+				privateRouteTable := m.CreateRouteTable(context.TODO(), matchRouteTableInput(&ec2.CreateRouteTableInput{VpcId: aws.String("vpc-routetables")})).
+					Return(&ec2.CreateRouteTableOutput{RouteTable: &types.RouteTable{RouteTableId: aws.String("rt-1")}}, nil)
 
-				m.CreateRouteWithContext(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
+				m.CreateRoute(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
 					NatGatewayId:         aws.String("nat-01"),
 					DestinationCidrBlock: aws.String("0.0.0.0/0"),
 					RouteTableId:         aws.String("rt-1"),
 				})).
 					After(privateRouteTable)
 
-				m.CreateRouteWithContext(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
+				m.CreateRoute(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
 					DestinationIpv6CidrBlock:    aws.String("::/0"),
 					EgressOnlyInternetGatewayId: aws.String("eigw-01"),
 					RouteTableId:                aws.String("rt-1"),
 				})).
 					After(privateRouteTable)
 
-				m.AssociateRouteTableWithContext(context.TODO(), gomock.Eq(&ec2.AssociateRouteTableInput{
+				m.AssociateRouteTable(context.TODO(), gomock.Eq(&ec2.AssociateRouteTableInput{
 					RouteTableId: aws.String("rt-1"),
 					SubnetId:     aws.String("subnet-routetables-private"),
 				})).
 					Return(&ec2.AssociateRouteTableOutput{}, nil).
 					After(privateRouteTable)
 
-				publicRouteTable := m.CreateRouteTableWithContext(context.TODO(), matchRouteTableInput(&ec2.CreateRouteTableInput{VpcId: aws.String("vpc-routetables")})).
-					Return(&ec2.CreateRouteTableOutput{RouteTable: &ec2.RouteTable{RouteTableId: aws.String("rt-2")}}, nil)
+				publicRouteTable := m.CreateRouteTable(context.TODO(), matchRouteTableInput(&ec2.CreateRouteTableInput{VpcId: aws.String("vpc-routetables")})).
+					Return(&ec2.CreateRouteTableOutput{RouteTable: &types.RouteTable{RouteTableId: aws.String("rt-2")}}, nil)
 
-				m.CreateRouteWithContext(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
+				m.CreateRoute(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
 					GatewayId:            aws.String("igw-01"),
 					DestinationCidrBlock: aws.String("0.0.0.0/0"),
 					RouteTableId:         aws.String("rt-2"),
 				})).
 					After(publicRouteTable)
 
-				m.CreateRouteWithContext(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
+				m.CreateRoute(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
 					DestinationIpv6CidrBlock: aws.String("::/0"),
 					GatewayId:                aws.String("igw-01"),
 					RouteTableId:             aws.String("rt-2"),
 				})).
 					After(publicRouteTable)
 
-				m.AssociateRouteTableWithContext(context.TODO(), gomock.Eq(&ec2.AssociateRouteTableInput{
+				m.AssociateRouteTable(context.TODO(), gomock.Eq(&ec2.AssociateRouteTableInput{
 					RouteTableId: aws.String("rt-2"),
 					SubnetId:     aws.String("subnet-routetables-public"),
 				})).
@@ -310,7 +311,7 @@ func TestReconcileRouteTables(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{}, nil)
 			},
 			err: errors.New(`no nat gateways available in "us-east-1a"`),
@@ -341,23 +342,23 @@ func TestReconcileRouteTables(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{
-						RouteTables: []*ec2.RouteTable{
+						RouteTables: []types.RouteTable{
 							{
 								RouteTableId: aws.String("route-table-private"),
-								Associations: []*ec2.RouteTableAssociation{
+								Associations: []types.RouteTableAssociation{
 									{
 										SubnetId: aws.String("subnet-routetables-private"),
 									},
 								},
-								Routes: []*ec2.Route{
+								Routes: []types.Route{
 									{
 										DestinationCidrBlock: aws.String("0.0.0.0/0"),
 										NatGatewayId:         aws.String("outdated-nat-01"),
 									},
 								},
-								Tags: []*ec2.Tag{
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/test-cluster"),
 										Value: aws.String("owned"),
@@ -378,18 +379,18 @@ func TestReconcileRouteTables(t *testing.T) {
 							},
 							{
 								RouteTableId: aws.String("route-table-public"),
-								Associations: []*ec2.RouteTableAssociation{
+								Associations: []types.RouteTableAssociation{
 									{
 										SubnetId: aws.String("subnet-routetables-public"),
 									},
 								},
-								Routes: []*ec2.Route{
+								Routes: []types.Route{
 									{
 										DestinationCidrBlock: aws.String("0.0.0.0/0"),
 										GatewayId:            aws.String("igw-01"),
 									},
 								},
-								Tags: []*ec2.Tag{
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/test-cluster"),
 										Value: aws.String("owned"),
@@ -411,7 +412,7 @@ func TestReconcileRouteTables(t *testing.T) {
 						},
 					}, nil)
 
-				m.ReplaceRouteWithContext(context.TODO(), gomock.Eq(
+				m.ReplaceRoute(context.TODO(), gomock.Eq(
 					&ec2.ReplaceRouteInput{
 						DestinationCidrBlock: aws.String("0.0.0.0/0"),
 						RouteTableId:         aws.String("route-table-private"),
@@ -446,17 +447,17 @@ func TestReconcileRouteTables(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{
-						RouteTables: []*ec2.RouteTable{
+						RouteTables: []types.RouteTable{
 							{
 								RouteTableId: aws.String("route-table-private"),
-								Associations: []*ec2.RouteTableAssociation{
+								Associations: []types.RouteTableAssociation{
 									{
 										SubnetId: aws.String("subnet-routetables-private"),
 									},
 								},
-								Routes: []*ec2.Route{
+								Routes: []types.Route{
 									{
 										DestinationCidrBlock: aws.String("0.0.0.0/0"),
 										NatGatewayId:         aws.String("nat-01"),
@@ -466,7 +467,7 @@ func TestReconcileRouteTables(t *testing.T) {
 										DestinationPrefixListId: aws.String("pl-foobar"),
 									},
 								},
-								Tags: []*ec2.Tag{
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/test-cluster"),
 										Value: aws.String("owned"),
@@ -487,18 +488,18 @@ func TestReconcileRouteTables(t *testing.T) {
 							},
 							{
 								RouteTableId: aws.String("route-table-public"),
-								Associations: []*ec2.RouteTableAssociation{
+								Associations: []types.RouteTableAssociation{
 									{
 										SubnetId: aws.String("subnet-routetables-public"),
 									},
 								},
-								Routes: []*ec2.Route{
+								Routes: []types.Route{
 									{
 										DestinationCidrBlock: aws.String("0.0.0.0/0"),
 										GatewayId:            aws.String("igw-01"),
 									},
 								},
-								Tags: []*ec2.Tag{
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("kubernetes.io/cluster/test-cluster"),
 										Value: aws.String("owned"),
@@ -541,20 +542,20 @@ func TestReconcileRouteTables(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{}, nil)
 
-				m.CreateRouteTableWithContext(context.TODO(), matchRouteTableInput(&ec2.CreateRouteTableInput{VpcId: aws.String("vpc-rtbs")})).
-					Return(&ec2.CreateRouteTableOutput{RouteTable: &ec2.RouteTable{RouteTableId: aws.String("rt-1")}}, nil)
+				m.CreateRouteTable(context.TODO(), matchRouteTableInput(&ec2.CreateRouteTableInput{VpcId: aws.String("vpc-rtbs")})).
+					Return(&ec2.CreateRouteTableOutput{RouteTable: &types.RouteTable{RouteTableId: aws.String("rt-1")}}, nil)
 
-				m.CreateRouteWithContext(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
+				m.CreateRoute(context.TODO(), gomock.Eq(&ec2.CreateRouteInput{
 					GatewayId:            aws.String("igw-01"),
 					DestinationCidrBlock: aws.String("0.0.0.0/0"),
 					RouteTableId:         aws.String("rt-1"),
 				})).
 					Return(nil, awserrors.NewNotFound("MissingParameter"))
 
-				m.DeleteRouteTableWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DeleteRouteTableInput{})).
+				m.DeleteRouteTable(context.TODO(), gomock.AssignableToTypeOf(&ec2.DeleteRouteTableInput{})).
 					Return(&ec2.DeleteRouteTableOutput{}, nil)
 			},
 			err: errors.New(`failed to create route in route table "rt-1"`),
@@ -602,35 +603,35 @@ func TestReconcileRouteTables(t *testing.T) {
 
 // Delete Route Table(s).
 var (
-	stubEc2RouteTablePrivate = &ec2.RouteTable{
+	stubEc2RouteTablePrivate = types.RouteTable{
 		RouteTableId: aws.String("route-table-private"),
-		Associations: []*ec2.RouteTableAssociation{
+		Associations: []types.RouteTableAssociation{
 			{
 				SubnetId: nil,
 			},
 		},
-		Routes: []*ec2.Route{
+		Routes: []types.Route{
 			{
 				DestinationCidrBlock: aws.String("0.0.0.0/0"),
 				NatGatewayId:         aws.String("outdated-nat-01"),
 			},
 		},
 	}
-	stubEc2RouteTablePublicWithAssociations = &ec2.RouteTable{
+	stubEc2RouteTablePublicWithAssociations = types.RouteTable{
 		RouteTableId: aws.String("route-table-public"),
-		Associations: []*ec2.RouteTableAssociation{
+		Associations: []types.RouteTableAssociation{
 			{
 				SubnetId:                aws.String("subnet-routetables-public"),
 				RouteTableAssociationId: aws.String("route-table-public"),
 			},
 		},
-		Routes: []*ec2.Route{
+		Routes: []types.Route{
 			{
 				DestinationCidrBlock: aws.String("0.0.0.0/0"),
 				GatewayId:            aws.String("igw-01"),
 			},
 		},
-		Tags: []*ec2.Tag{
+		Tags: []types.Tag{
 			{
 				Key:   aws.String("kubernetes.io/cluster/test-cluster"),
 				Value: aws.String("owned"),
@@ -656,7 +657,7 @@ func TestDeleteRouteTables(t *testing.T) {
 	defer mockCtrl.Finish()
 
 	describeRouteTableOutput := &ec2.DescribeRouteTablesOutput{
-		RouteTables: []*ec2.RouteTable{
+		RouteTables: []types.RouteTable{
 			stubEc2RouteTablePrivate,
 			stubEc2RouteTablePublicWithAssociations,
 		},
@@ -681,18 +682,18 @@ func TestDeleteRouteTables(t *testing.T) {
 			name:  "Should delete route table successfully",
 			input: &infrav1.NetworkSpec{},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(describeRouteTableOutput, nil)
 
-				m.DeleteRouteTableWithContext(context.TODO(), gomock.Eq(&ec2.DeleteRouteTableInput{
+				m.DeleteRouteTable(context.TODO(), gomock.Eq(&ec2.DeleteRouteTableInput{
 					RouteTableId: aws.String("route-table-private"),
 				})).Return(&ec2.DeleteRouteTableOutput{}, nil)
 
-				m.DisassociateRouteTableWithContext(context.TODO(), gomock.Eq(&ec2.DisassociateRouteTableInput{
+				m.DisassociateRouteTable(context.TODO(), gomock.Eq(&ec2.DisassociateRouteTableInput{
 					AssociationId: aws.String("route-table-public"),
 				})).Return(&ec2.DisassociateRouteTableOutput{}, nil)
 
-				m.DeleteRouteTableWithContext(context.TODO(), gomock.Eq(&ec2.DeleteRouteTableInput{
+				m.DeleteRouteTable(context.TODO(), gomock.Eq(&ec2.DeleteRouteTableInput{
 					RouteTableId: aws.String("route-table-public"),
 				})).Return(&ec2.DeleteRouteTableOutput{}, nil)
 			},
@@ -701,7 +702,7 @@ func TestDeleteRouteTables(t *testing.T) {
 			name:  "Should return error if describe route table fails",
 			input: &infrav1.NetworkSpec{},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(nil, awserrors.NewFailedDependency("failed dependency"))
 			},
 			wantErr: true,
@@ -710,10 +711,10 @@ func TestDeleteRouteTables(t *testing.T) {
 			name:  "Should return error if delete route table fails",
 			input: &infrav1.NetworkSpec{},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(describeRouteTableOutput, nil)
 
-				m.DeleteRouteTableWithContext(context.TODO(), gomock.Eq(&ec2.DeleteRouteTableInput{
+				m.DeleteRouteTable(context.TODO(), gomock.Eq(&ec2.DeleteRouteTableInput{
 					RouteTableId: aws.String("route-table-private"),
 				})).Return(nil, awserrors.NewNotFound("not found"))
 			},
@@ -723,14 +724,14 @@ func TestDeleteRouteTables(t *testing.T) {
 			name:  "Should return error if disassociate route table fails",
 			input: &infrav1.NetworkSpec{},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(describeRouteTableOutput, nil)
 
-				m.DeleteRouteTableWithContext(context.TODO(), gomock.Eq(&ec2.DeleteRouteTableInput{
+				m.DeleteRouteTable(context.TODO(), gomock.Eq(&ec2.DeleteRouteTableInput{
 					RouteTableId: aws.String("route-table-private"),
 				})).Return(&ec2.DeleteRouteTableOutput{}, nil)
 
-				m.DisassociateRouteTableWithContext(context.TODO(), gomock.Eq(&ec2.DisassociateRouteTableInput{
+				m.DisassociateRouteTable(context.TODO(), gomock.Eq(&ec2.DisassociateRouteTableInput{
 					AssociationId: aws.String("route-table-public"),
 				})).Return(nil, awserrors.NewNotFound("not found"))
 			},
@@ -782,7 +783,7 @@ func TestDeleteRouteTable(t *testing.T) {
 
 	testCases := []struct {
 		name    string
-		input   *ec2.RouteTable
+		input   types.RouteTable
 		expect  func(m *mocks.MockEC2APIMockRecorder)
 		wantErr bool
 	}{
@@ -790,7 +791,7 @@ func TestDeleteRouteTable(t *testing.T) {
 			name:  "Should delete route table successfully",
 			input: stubEc2RouteTablePrivate,
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DeleteRouteTableWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DeleteRouteTableInput{})).
+				m.DeleteRouteTable(context.TODO(), gomock.AssignableToTypeOf(&ec2.DeleteRouteTableInput{})).
 					Return(&ec2.DeleteRouteTableOutput{}, nil)
 			},
 		},
@@ -798,7 +799,7 @@ func TestDeleteRouteTable(t *testing.T) {
 			name:  "Should return error if delete route table fails",
 			input: stubEc2RouteTablePrivate,
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DeleteRouteTableWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DeleteRouteTableInput{})).
+				m.DeleteRouteTable(context.TODO(), gomock.AssignableToTypeOf(&ec2.DeleteRouteTableInput{})).
 					Return(nil, awserrors.NewNotFound("not found"))
 			},
 			wantErr: true,
@@ -807,7 +808,7 @@ func TestDeleteRouteTable(t *testing.T) {
 			name:  "Should return error if disassociate route table fails",
 			input: stubEc2RouteTablePublicWithAssociations,
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DisassociateRouteTableWithContext(context.TODO(), gomock.Eq(&ec2.DisassociateRouteTableInput{
+				m.DisassociateRouteTable(context.TODO(), gomock.Eq(&ec2.DisassociateRouteTableInput{
 					AssociationId: aws.String("route-table-public"),
 				})).Return(nil, awserrors.NewNotFound("not found"))
 			},
@@ -1350,7 +1351,7 @@ func TestService_getRoutesForSubnet(t *testing.T) {
 				}
 			}
 			if len(tc.want) > 0 {
-				if !cmp.Equal(got, tc.want) {
+				if !cmp.Equal(got, tc.want, cmp.AllowUnexported(ec2.CreateRouteInput{})) {
 					t.Errorf("got unexpect routes:\n%v", cmp.Diff(got, tc.want))
 				}
 			}
diff --git a/pkg/cloud/services/network/secondarycidr_test.go b/pkg/cloud/services/network/secondarycidr_test.go
index d4f16bf3e..856781b2e 100644
--- a/pkg/cloud/services/network/secondarycidr_test.go
+++ b/pkg/cloud/services/network/secondarycidr_test.go
@@ -20,8 +20,9 @@ import (
 	"context"
 	"testing"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/golang/mock/gomock"
 	. "github.com/onsi/gomega"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -76,8 +77,8 @@ func TestServiceAssociateSecondaryCidr(t *testing.T) {
 			fillAWSManagedControlPlaneSecondaryCIDR: false,
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				// No calls expected
-				m.DescribeVpcsWithContext(context.TODO(), gomock.Any()).Times(0)
-				m.AssociateVpcCidrBlockWithContext(context.TODO(), gomock.Any()).Times(0)
+				m.DescribeVpcs(context.TODO(), gomock.Any()).Times(0)
+				m.AssociateVpcCidrBlock(context.TODO(), gomock.Any()).Times(0)
 			},
 			wantErr: false,
 		},
@@ -85,7 +86,7 @@ func TestServiceAssociateSecondaryCidr(t *testing.T) {
 			name:                                    "Should return error if unable to describe VPC",
 			fillAWSManagedControlPlaneSecondaryCIDR: true,
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeVpcsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(nil, awserrors.NewFailedDependency("dependency-failure"))
+				m.DescribeVpcs(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(nil, awserrors.NewFailedDependency("dependency-failure"))
 			},
 			wantErr: true,
 		},
@@ -93,10 +94,10 @@ func TestServiceAssociateSecondaryCidr(t *testing.T) {
 			name:                                    "Should not associate secondary cidr block if already exist in VPC",
 			fillAWSManagedControlPlaneSecondaryCIDR: true,
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeVpcsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
-					Vpcs: []*ec2.Vpc{
+				m.DescribeVpcs(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
+					Vpcs: []types.Vpc{
 						{
-							CidrBlockAssociationSet: []*ec2.VpcCidrBlockAssociation{
+							CidrBlockAssociationSet: []types.VpcCidrBlockAssociation{
 								{CidrBlock: aws.String("secondary-cidr")},
 							},
 						},
@@ -107,8 +108,8 @@ func TestServiceAssociateSecondaryCidr(t *testing.T) {
 			name:                                    "Should return error if no VPC found",
 			fillAWSManagedControlPlaneSecondaryCIDR: true,
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeVpcsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
-					Vpcs: []*ec2.Vpc{},
+				m.DescribeVpcs(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
+					Vpcs: []types.Vpc{},
 				}, nil)
 			},
 			wantErr: true,
@@ -117,13 +118,13 @@ func TestServiceAssociateSecondaryCidr(t *testing.T) {
 			name:                                    "Should return error if failed during associating secondary cidr block",
 			fillAWSManagedControlPlaneSecondaryCIDR: true,
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeVpcsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
-					Vpcs: []*ec2.Vpc{
+				m.DescribeVpcs(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
+					Vpcs: []types.Vpc{
 						{
-							CidrBlockAssociationSet: []*ec2.VpcCidrBlockAssociation{},
+							CidrBlockAssociationSet: []types.VpcCidrBlockAssociation{},
 						},
 					}}, nil)
-				m.AssociateVpcCidrBlockWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.AssociateVpcCidrBlockInput{})).Return(nil, awserrors.NewFailedDependency("dependency-failure"))
+				m.AssociateVpcCidrBlock(context.TODO(), gomock.AssignableToTypeOf(&ec2.AssociateVpcCidrBlockInput{})).Return(nil, awserrors.NewFailedDependency("dependency-failure"))
 			},
 			wantErr: true,
 		},
@@ -131,14 +132,14 @@ func TestServiceAssociateSecondaryCidr(t *testing.T) {
 			name:                                    "Should successfully associate secondary CIDR block if none is associated yet",
 			fillAWSManagedControlPlaneSecondaryCIDR: true,
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeVpcsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
-					Vpcs: []*ec2.Vpc{
+				m.DescribeVpcs(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
+					Vpcs: []types.Vpc{
 						{
-							CidrBlockAssociationSet: []*ec2.VpcCidrBlockAssociation{},
+							CidrBlockAssociationSet: []types.VpcCidrBlockAssociation{},
 						},
 					}}, nil)
-				m.AssociateVpcCidrBlockWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.AssociateVpcCidrBlockInput{})).Return(&ec2.AssociateVpcCidrBlockOutput{
-					CidrBlockAssociation: &ec2.VpcCidrBlockAssociation{
+				m.AssociateVpcCidrBlock(context.TODO(), gomock.AssignableToTypeOf(&ec2.AssociateVpcCidrBlockInput{})).Return(&ec2.AssociateVpcCidrBlockOutput{
+					CidrBlockAssociation: &types.VpcCidrBlockAssociation{
 						AssociationId: ptr.To[string]("association-id-success"),
 					},
 				}, nil)
@@ -164,10 +165,10 @@ func TestServiceAssociateSecondaryCidr(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				// Two are simulated to exist...
-				m.DescribeVpcsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
-					Vpcs: []*ec2.Vpc{
+				m.DescribeVpcs(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
+					Vpcs: []types.Vpc{
 						{
-							CidrBlockAssociationSet: []*ec2.VpcCidrBlockAssociation{
+							CidrBlockAssociationSet: []types.VpcCidrBlockAssociation{
 								{
 									AssociationId: ptr.To[string]("association-id-existing-1"),
 									CidrBlock:     ptr.To[string]("10.0.1.0/24"),
@@ -181,19 +182,19 @@ func TestServiceAssociateSecondaryCidr(t *testing.T) {
 					}}, nil)
 
 				// ...the other two should be created
-				m.AssociateVpcCidrBlockWithContext(context.TODO(), gomock.Eq(&ec2.AssociateVpcCidrBlockInput{
+				m.AssociateVpcCidrBlock(context.TODO(), gomock.Eq(&ec2.AssociateVpcCidrBlockInput{
 					CidrBlock: ptr.To[string]("10.0.2.0/24"),
 					VpcId:     ptr.To[string]("vpc-id"),
 				})).Return(&ec2.AssociateVpcCidrBlockOutput{
-					CidrBlockAssociation: &ec2.VpcCidrBlockAssociation{
+					CidrBlockAssociation: &types.VpcCidrBlockAssociation{
 						AssociationId: ptr.To[string]("association-id-success-2"),
 					},
 				}, nil)
-				m.AssociateVpcCidrBlockWithContext(context.TODO(), gomock.Eq(&ec2.AssociateVpcCidrBlockInput{
+				m.AssociateVpcCidrBlock(context.TODO(), gomock.Eq(&ec2.AssociateVpcCidrBlockInput{
 					CidrBlock: ptr.To[string]("10.0.4.0/24"),
 					VpcId:     ptr.To[string]("vpc-id"),
 				})).Return(&ec2.AssociateVpcCidrBlockOutput{
-					CidrBlockAssociation: &ec2.VpcCidrBlockAssociation{
+					CidrBlockAssociation: &types.VpcCidrBlockAssociation{
 						AssociationId: ptr.To[string]("association-id-success-4"),
 					},
 				}, nil)
@@ -253,8 +254,8 @@ func TestServiceDiassociateSecondaryCidr(t *testing.T) {
 			fillAWSManagedControlPlaneSecondaryCIDR: false,
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				// No calls expected
-				m.DescribeVpcsWithContext(context.TODO(), gomock.Any()).Times(0)
-				m.DisassociateVpcCidrBlockWithContext(context.TODO(), gomock.Any()).Times(0)
+				m.DescribeVpcs(context.TODO(), gomock.Any()).Times(0)
+				m.DisassociateVpcCidrBlock(context.TODO(), gomock.Any()).Times(0)
 			},
 			wantErr: false,
 		},
@@ -262,7 +263,7 @@ func TestServiceDiassociateSecondaryCidr(t *testing.T) {
 			name:                                    "Should return error if unable to describe VPC",
 			fillAWSManagedControlPlaneSecondaryCIDR: true,
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeVpcsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(nil, awserrors.NewFailedDependency("dependency-failure"))
+				m.DescribeVpcs(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(nil, awserrors.NewFailedDependency("dependency-failure"))
 			},
 			wantErr: true,
 		},
@@ -270,7 +271,7 @@ func TestServiceDiassociateSecondaryCidr(t *testing.T) {
 			name:                                    "Should return error if no VPC found",
 			fillAWSManagedControlPlaneSecondaryCIDR: true,
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeVpcsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(nil, nil)
+				m.DescribeVpcs(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(nil, nil)
 			},
 			wantErr: true,
 		},
@@ -278,30 +279,30 @@ func TestServiceDiassociateSecondaryCidr(t *testing.T) {
 			name:                                    "Should diassociate secondary cidr block if already exist in VPC",
 			fillAWSManagedControlPlaneSecondaryCIDR: true,
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeVpcsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
-					Vpcs: []*ec2.Vpc{
+				m.DescribeVpcs(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
+					Vpcs: []types.Vpc{
 						{
-							CidrBlockAssociationSet: []*ec2.VpcCidrBlockAssociation{
+							CidrBlockAssociationSet: []types.VpcCidrBlockAssociation{
 								{CidrBlock: aws.String("secondary-cidr")},
 							},
 						},
 					}}, nil)
-				m.DisassociateVpcCidrBlockWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DisassociateVpcCidrBlockInput{})).Return(nil, nil)
+				m.DisassociateVpcCidrBlock(context.TODO(), gomock.AssignableToTypeOf(&ec2.DisassociateVpcCidrBlockInput{})).Return(nil, nil)
 			},
 		},
 		{
 			name:                                    "Should return error if failed to disassociate secondary cidr block",
 			fillAWSManagedControlPlaneSecondaryCIDR: true,
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeVpcsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
-					Vpcs: []*ec2.Vpc{
+				m.DescribeVpcs(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
+					Vpcs: []types.Vpc{
 						{
-							CidrBlockAssociationSet: []*ec2.VpcCidrBlockAssociation{
+							CidrBlockAssociationSet: []types.VpcCidrBlockAssociation{
 								{CidrBlock: aws.String("secondary-cidr")},
 							},
 						},
 					}}, nil)
-				m.DisassociateVpcCidrBlockWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DisassociateVpcCidrBlockInput{})).Return(nil, awserrors.NewFailedDependency("dependency-failure"))
+				m.DisassociateVpcCidrBlock(context.TODO(), gomock.AssignableToTypeOf(&ec2.DisassociateVpcCidrBlockInput{})).Return(nil, awserrors.NewFailedDependency("dependency-failure"))
 			},
 			wantErr: true,
 		},
@@ -309,15 +310,15 @@ func TestServiceDiassociateSecondaryCidr(t *testing.T) {
 			name:                                    "Should successfully return from disassociating secondary CIDR blocks if none is currently associated",
 			fillAWSManagedControlPlaneSecondaryCIDR: true,
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeVpcsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
-					Vpcs: []*ec2.Vpc{
+				m.DescribeVpcs(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
+					Vpcs: []types.Vpc{
 						{
-							CidrBlockAssociationSet: []*ec2.VpcCidrBlockAssociation{},
+							CidrBlockAssociationSet: []types.VpcCidrBlockAssociation{},
 						},
 					}}, nil)
 
 				// No calls expected
-				m.DisassociateVpcCidrBlockWithContext(context.TODO(), gomock.Any()).Times(0)
+				m.DisassociateVpcCidrBlock(context.TODO(), gomock.Any()).Times(0)
 			},
 			wantErr: false,
 		},
@@ -327,8 +328,8 @@ func TestServiceDiassociateSecondaryCidr(t *testing.T) {
 			unmanagedVPC:                            true,
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				// No calls expected
-				m.DescribeVpcsWithContext(context.TODO(), gomock.Any()).Times(0)
-				m.DisassociateVpcCidrBlockWithContext(context.TODO(), gomock.Any()).Times(0)
+				m.DescribeVpcs(context.TODO(), gomock.Any()).Times(0)
+				m.DisassociateVpcCidrBlock(context.TODO(), gomock.Any()).Times(0)
 			},
 			wantErr: false,
 		},
@@ -351,10 +352,10 @@ func TestServiceDiassociateSecondaryCidr(t *testing.T) {
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				// Two are simulated to exist...
-				m.DescribeVpcsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
-					Vpcs: []*ec2.Vpc{
+				m.DescribeVpcs(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
+					Vpcs: []types.Vpc{
 						{
-							CidrBlockAssociationSet: []*ec2.VpcCidrBlockAssociation{
+							CidrBlockAssociationSet: []types.VpcCidrBlockAssociation{
 								{
 									AssociationId: ptr.To[string]("association-id-existing-1"),
 									CidrBlock:     ptr.To[string]("10.0.1.0/24"),
@@ -367,10 +368,10 @@ func TestServiceDiassociateSecondaryCidr(t *testing.T) {
 						},
 					}}, nil)
 
-				m.DisassociateVpcCidrBlockWithContext(context.TODO(), gomock.Eq(&ec2.DisassociateVpcCidrBlockInput{
+				m.DisassociateVpcCidrBlock(context.TODO(), gomock.Eq(&ec2.DisassociateVpcCidrBlockInput{
 					AssociationId: ptr.To[string]("association-id-existing-1"), // 10.0.1.0/24 (see above)
 				})).Return(&ec2.DisassociateVpcCidrBlockOutput{}, nil)
-				m.DisassociateVpcCidrBlockWithContext(context.TODO(), gomock.Eq(&ec2.DisassociateVpcCidrBlockInput{
+				m.DisassociateVpcCidrBlock(context.TODO(), gomock.Eq(&ec2.DisassociateVpcCidrBlockInput{
 					AssociationId: ptr.To[string]("association-id-existing-3"), // 10.0.3.0/24 (see above)
 				})).Return(&ec2.DisassociateVpcCidrBlockOutput{}, nil)
 			},
diff --git a/pkg/cloud/services/network/subnets_test.go b/pkg/cloud/services/network/subnets_test.go
index ddaf6124f..11dbde0dd 100644
--- a/pkg/cloud/services/network/subnets_test.go
+++ b/pkg/cloud/services/network/subnets_test.go
@@ -24,8 +24,9 @@ import (
 	"slices"
 	"testing"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/golang/mock/gomock"
 	"github.com/google/go-cmp/cmp"
 	. "github.com/onsi/gomega"
@@ -105,20 +106,20 @@ func TestReconcileSubnets(t *testing.T) {
 				},
 			}).WithTagUnmanagedNetworkResources(false),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{
+						Subnets: []types.Subnet{
 							{
 								VpcId:               aws.String(subnetsVPCID),
 								SubnetId:            aws.String("subnet-1"),
@@ -136,18 +137,18 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{
-						RouteTables: []*ec2.RouteTable{
+						RouteTables: []types.RouteTable{
 							{
 								VpcId: aws.String(subnetsVPCID),
-								Associations: []*ec2.RouteTableAssociation{
+								Associations: []types.RouteTableAssociation{
 									{
 										SubnetId:     aws.String("subnet-1"),
 										RouteTableId: aws.String("rt-12345"),
 									},
 								},
-								Routes: []*ec2.Route{
+								Routes: []types.Route{
 									{
 										GatewayId: aws.String("igw-12345"),
 									},
@@ -156,24 +157,22 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{subnetsVPCID},
 						},
-					}),
-					gomock.Any()).Return(nil)
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1a"),
 								ZoneType: aws.String("availability-zone"),
@@ -199,20 +198,20 @@ func TestReconcileSubnets(t *testing.T) {
 				},
 			}).WithTagUnmanagedNetworkResources(true),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{
+						Subnets: []types.Subnet{
 							{
 								VpcId:               aws.String(subnetsVPCID),
 								SubnetId:            aws.String("subnet-1"),
@@ -230,18 +229,18 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{
-						RouteTables: []*ec2.RouteTable{
+						RouteTables: []types.RouteTable{
 							{
 								VpcId: aws.String(subnetsVPCID),
-								Associations: []*ec2.RouteTableAssociation{
+								Associations: []types.RouteTableAssociation{
 									{
 										SubnetId:     aws.String("subnet-1"),
 										RouteTableId: aws.String("rt-12345"),
 									},
 								},
-								Routes: []*ec2.Route{
+								Routes: []types.Route{
 									{
 										GatewayId: aws.String("igw-12345"),
 									},
@@ -250,24 +249,22 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{subnetsVPCID},
 						},
-					}),
-					gomock.Any()).Return(nil)
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 
-				m.CreateTagsWithContext(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
-					Resources: aws.StringSlice([]string{"subnet-1"}),
-					Tags: []*ec2.Tag{
+				m.CreateTags(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
+					Resources: []string{"subnet-1"},
+					Tags: []types.Tag{
 						{
 							Key:   aws.String("kubernetes.io/cluster/test-cluster"),
 							Value: aws.String("shared"),
@@ -280,9 +277,9 @@ func TestReconcileSubnets(t *testing.T) {
 				})).
 					Return(&ec2.CreateTagsOutput{}, nil)
 
-				m.CreateTagsWithContext(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
-					Resources: aws.StringSlice([]string{"subnet-2"}),
-					Tags: []*ec2.Tag{
+				m.CreateTags(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
+					Resources: []string{"subnet-2"},
+					Tags: []types.Tag{
 						{
 							Key:   aws.String("kubernetes.io/cluster/test-cluster"),
 							Value: aws.String("shared"),
@@ -295,9 +292,9 @@ func TestReconcileSubnets(t *testing.T) {
 				})).
 					Return(&ec2.CreateTagsOutput{}, nil)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1a"),
 								ZoneType: aws.String("availability-zone"),
@@ -327,31 +324,31 @@ func TestReconcileSubnets(t *testing.T) {
 				},
 			}).WithTagUnmanagedNetworkResources(true),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{
+						Subnets: []types.Subnet{
 							{
 								VpcId:            aws.String(subnetsVPCID),
 								SubnetId:         aws.String("subnet-1"),
 								AvailabilityZone: aws.String("us-east-1a"),
 								CidrBlock:        aws.String("10.0.10.0/24"),
-								Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{
+								Ipv6CidrBlockAssociationSet: []types.SubnetIpv6CidrBlockAssociation{
 									{
 										AssociationId: aws.String("amazon"),
 										Ipv6CidrBlock: aws.String("2001:db8:1234:1a01::/64"),
-										Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{
-											State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated),
+										Ipv6CidrBlockState: &types.SubnetCidrBlockState{
+											State: types.SubnetCidrBlockStateCodeAssociated,
 										},
 									},
 								},
@@ -363,12 +360,12 @@ func TestReconcileSubnets(t *testing.T) {
 								SubnetId:         aws.String("subnet-2"),
 								AvailabilityZone: aws.String("us-east-1a"),
 								CidrBlock:        aws.String("10.0.20.0/24"),
-								Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{
+								Ipv6CidrBlockAssociationSet: []types.SubnetIpv6CidrBlockAssociation{
 									{
 										AssociationId: aws.String("amazon"),
 										Ipv6CidrBlock: aws.String("2001:db8:1234:1a02::/64"),
-										Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{
-											State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated),
+										Ipv6CidrBlockState: &types.SubnetCidrBlockState{
+											State: types.SubnetCidrBlockStateCodeAssociated,
 										},
 									},
 								},
@@ -378,18 +375,18 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{
-						RouteTables: []*ec2.RouteTable{
+						RouteTables: []types.RouteTable{
 							{
 								VpcId: aws.String(subnetsVPCID),
-								Associations: []*ec2.RouteTableAssociation{
+								Associations: []types.RouteTableAssociation{
 									{
 										SubnetId:     aws.String("subnet-1"),
 										RouteTableId: aws.String("rt-12345"),
 									},
 								},
-								Routes: []*ec2.Route{
+								Routes: []types.Route{
 									{
 										GatewayId: aws.String("igw-12345"),
 									},
@@ -398,24 +395,22 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{subnetsVPCID},
 						},
-					}),
-					gomock.Any()).Return(nil)
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 
-				m.CreateTagsWithContext(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
-					Resources: aws.StringSlice([]string{"subnet-1"}),
-					Tags: []*ec2.Tag{
+				m.CreateTags(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
+					Resources: []string{"subnet-1"},
+					Tags: []types.Tag{
 						{
 							Key:   aws.String("kubernetes.io/cluster/test-cluster"),
 							Value: aws.String("shared"),
@@ -428,9 +423,9 @@ func TestReconcileSubnets(t *testing.T) {
 				})).
 					Return(&ec2.CreateTagsOutput{}, nil)
 
-				m.CreateTagsWithContext(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
-					Resources: aws.StringSlice([]string{"subnet-2"}),
-					Tags: []*ec2.Tag{
+				m.CreateTags(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
+					Resources: []string{"subnet-2"},
+					Tags: []types.Tag{
 						{
 							Key:   aws.String("kubernetes.io/cluster/test-cluster"),
 							Value: aws.String("shared"),
@@ -443,9 +438,9 @@ func TestReconcileSubnets(t *testing.T) {
 				})).
 					Return(&ec2.CreateTagsOutput{}, nil)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1a"),
 								ZoneType: aws.String("availability-zone"),
@@ -472,20 +467,20 @@ func TestReconcileSubnets(t *testing.T) {
 				},
 			}).WithTagUnmanagedNetworkResources(true),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{
+						Subnets: []types.Subnet{
 							{
 								VpcId:               aws.String(subnetsVPCID),
 								SubnetId:            aws.String("subnet-1"),
@@ -503,27 +498,25 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{subnetsVPCID},
 						},
-					}),
-					gomock.Any()).Return(nil)
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 
-				m.CreateTagsWithContext(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
-					Resources: aws.StringSlice([]string{"subnet-1"}),
-					Tags: []*ec2.Tag{
+				m.CreateTags(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
+					Resources: []string{"subnet-1"},
+					Tags: []types.Tag{
 						{
 							Key:   aws.String("kubernetes.io/cluster/test-cluster"),
 							Value: aws.String("shared"),
@@ -536,9 +529,9 @@ func TestReconcileSubnets(t *testing.T) {
 				})).
 					Return(&ec2.CreateTagsOutput{}, nil)
 
-				m.CreateTagsWithContext(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
-					Resources: aws.StringSlice([]string{"subnet-2"}),
-					Tags: []*ec2.Tag{
+				m.CreateTags(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
+					Resources: []string{"subnet-2"},
+					Tags: []types.Tag{
 						{
 							Key:   aws.String("kubernetes.io/cluster/test-cluster"),
 							Value: aws.String("shared"),
@@ -551,9 +544,9 @@ func TestReconcileSubnets(t *testing.T) {
 				})).
 					Return(&ec2.CreateTagsOutput{}, nil)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1a"),
 								ZoneType: aws.String("availability-zone"),
@@ -577,20 +570,20 @@ func TestReconcileSubnets(t *testing.T) {
 				},
 			}).WithTagUnmanagedNetworkResources(true),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{
+						Subnets: []types.Subnet{
 							{
 								VpcId:               aws.String(subnetsVPCID),
 								SubnetId:            aws.String("subnet-1"),
@@ -601,18 +594,18 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{
-						RouteTables: []*ec2.RouteTable{
+						RouteTables: []types.RouteTable{
 							{
 								VpcId: aws.String(subnetsVPCID),
-								Associations: []*ec2.RouteTableAssociation{
+								Associations: []types.RouteTableAssociation{
 									{
 										SubnetId:     aws.String("subnet-1"),
 										RouteTableId: aws.String("rt-12345"),
 									},
 								},
-								Routes: []*ec2.Route{
+								Routes: []types.Route{
 									{
 										GatewayId: aws.String("igw-12345"),
 									},
@@ -621,28 +614,26 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{subnetsVPCID},
 						},
-					}),
-					gomock.Any()).Return(nil)
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 
-				stubMockDescribeAvailabilityZonesWithContextCustomZones(m, []*ec2.AvailabilityZone{
+				stubMockDescribeAvailabilityZonesWithContextCustomZones(m, []types.AvailabilityZone{
 					{ZoneName: aws.String("us-east-1a"), ZoneType: aws.String("availability-zone")},
 				}).AnyTimes()
 
-				m.CreateTagsWithContext(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
-					Resources: aws.StringSlice([]string{"subnet-1"}),
-					Tags: []*ec2.Tag{
+				m.CreateTags(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
+					Resources: []string{"subnet-1"},
+					Tags: []types.Tag{
 						{
 							Key:   aws.String("kubernetes.io/cluster/test-cluster"),
 							Value: aws.String("shared"),
@@ -679,20 +670,20 @@ func TestReconcileSubnets(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{
+						Subnets: []types.Subnet{
 							{
 								VpcId:               aws.String(subnetsVPCID),
 								SubnetId:            aws.String("subnet-1"),
@@ -703,18 +694,18 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{
-						RouteTables: []*ec2.RouteTable{
+						RouteTables: []types.RouteTable{
 							{
 								VpcId: aws.String(subnetsVPCID),
-								Associations: []*ec2.RouteTableAssociation{
+								Associations: []types.RouteTableAssociation{
 									{
 										SubnetId:     aws.String("subnet-1"),
 										RouteTableId: aws.String("rt-12345"),
 									},
 								},
-								Routes: []*ec2.Route{
+								Routes: []types.Route{
 									{
 										GatewayId: aws.String("igw-12345"),
 									},
@@ -723,28 +714,26 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{subnetsVPCID},
 						},
-					}),
-					gomock.Any()).Return(nil)
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 
-				stubMockDescribeAvailabilityZonesWithContextCustomZones(m, []*ec2.AvailabilityZone{
+				stubMockDescribeAvailabilityZonesWithContextCustomZones(m, []types.AvailabilityZone{
 					{ZoneName: aws.String("us-east-1a")},
 				}).AnyTimes()
 
-				m.CreateTagsWithContext(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
-					Resources: aws.StringSlice([]string{"subnet-1"}),
-					Tags: []*ec2.Tag{
+				m.CreateTags(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
+					Resources: []string{"subnet-1"},
+					Tags: []types.Tag{
 						{
 							Key:   aws.String("kubernetes.io/cluster/test-cluster"),
 							Value: aws.String("shared"),
@@ -791,20 +780,20 @@ func TestReconcileSubnets(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{
+						Subnets: []types.Subnet{
 							{
 								VpcId:               aws.String(subnetsVPCID),
 								SubnetId:            aws.String("subnet-1"),
@@ -822,18 +811,18 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{
-						RouteTables: []*ec2.RouteTable{
+						RouteTables: []types.RouteTable{
 							{
 								VpcId: aws.String(subnetsVPCID),
-								Associations: []*ec2.RouteTableAssociation{
+								Associations: []types.RouteTableAssociation{
 									{
 										SubnetId:     aws.String("subnet-1"),
 										RouteTableId: aws.String("rt-12345"),
 									},
 								},
-								Routes: []*ec2.Route{
+								Routes: []types.Route{
 									{
 										GatewayId: aws.String("igw-12345"),
 									},
@@ -841,13 +830,13 @@ func TestReconcileSubnets(t *testing.T) {
 							},
 							{
 								VpcId: aws.String(subnetsVPCID),
-								Associations: []*ec2.RouteTableAssociation{
+								Associations: []types.RouteTableAssociation{
 									{
 										SubnetId:     aws.String("subnet-2"),
 										RouteTableId: aws.String("rt-00000"),
 									},
 								},
-								Routes: []*ec2.Route{
+								Routes: []types.Route{
 									{
 										GatewayId: aws.String("igw-12345"),
 									},
@@ -856,28 +845,26 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{subnetsVPCID},
 						},
-					}),
-					gomock.Any()).Return(nil)
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 
-				stubMockDescribeAvailabilityZonesWithContextCustomZones(m, []*ec2.AvailabilityZone{
+				stubMockDescribeAvailabilityZonesWithContextCustomZones(m, []types.AvailabilityZone{
 					{ZoneName: aws.String("us-east-1a")}, {ZoneName: aws.String("us-east-1b")},
 				}).AnyTimes()
 
-				subnet1tag := m.CreateTagsWithContext(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
-					Resources: aws.StringSlice([]string{"subnet-1"}),
-					Tags: []*ec2.Tag{
+				subnet1tag := m.CreateTags(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
+					Resources: []string{"subnet-1"},
+					Tags: []types.Tag{
 						{
 							Key:   aws.String("kubernetes.io/cluster/test-cluster"),
 							Value: aws.String("shared"),
@@ -890,9 +877,9 @@ func TestReconcileSubnets(t *testing.T) {
 				})).
 					Return(&ec2.CreateTagsOutput{}, fmt.Errorf("tagging failed"))
 
-				m.CreateTagsWithContext(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
-					Resources: aws.StringSlice([]string{"subnet-2"}),
-					Tags: []*ec2.Tag{
+				m.CreateTags(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
+					Resources: []string{"subnet-2"},
+					Tags: []types.Tag{
 						{
 							Key:   aws.String("kubernetes.io/cluster/test-cluster"),
 							Value: aws.String("shared"),
@@ -923,20 +910,20 @@ func TestReconcileSubnets(t *testing.T) {
 				},
 			}).WithTagUnmanagedNetworkResources(true),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{
+						Subnets: []types.Subnet{
 							{
 								VpcId:               aws.String(subnetsVPCID),
 								SubnetId:            aws.String("subnet-1"),
@@ -954,18 +941,18 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{
-						RouteTables: []*ec2.RouteTable{
+						RouteTables: []types.RouteTable{
 							{
 								VpcId: aws.String(subnetsVPCID),
-								Associations: []*ec2.RouteTableAssociation{
+								Associations: []types.RouteTableAssociation{
 									{
 										SubnetId:     aws.String("subnet-1"),
 										RouteTableId: aws.String("rt-12345"),
 									},
 								},
-								Routes: []*ec2.Route{
+								Routes: []types.Route{
 									{
 										GatewayId: aws.String("igw-12345"),
 									},
@@ -973,13 +960,13 @@ func TestReconcileSubnets(t *testing.T) {
 							},
 							{
 								VpcId: aws.String(subnetsVPCID),
-								Associations: []*ec2.RouteTableAssociation{
+								Associations: []types.RouteTableAssociation{
 									{
 										SubnetId:     aws.String("subnet-2"),
 										RouteTableId: aws.String("rt-22222"),
 									},
 								},
-								Routes: []*ec2.Route{
+								Routes: []types.Route{
 									{
 										GatewayId: aws.String("igw-12345"),
 									},
@@ -988,28 +975,26 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{subnetsVPCID},
 						},
-					}),
-					gomock.Any()).Return(nil)
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 
-				stubMockDescribeAvailabilityZonesWithContextCustomZones(m, []*ec2.AvailabilityZone{
+				stubMockDescribeAvailabilityZonesWithContextCustomZones(m, []types.AvailabilityZone{
 					{ZoneName: aws.String("us-east-1a")}, {ZoneName: aws.String("us-east-1b")},
 				}).AnyTimes()
 
-				secondSubnetTag := m.CreateTagsWithContext(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
-					Resources: aws.StringSlice([]string{"subnet-1"}),
-					Tags: []*ec2.Tag{
+				secondSubnetTag := m.CreateTags(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
+					Resources: []string{"subnet-1"},
+					Tags: []types.Tag{
 						{
 							Key:   aws.String("kubernetes.io/cluster/test-cluster"),
 							Value: aws.String("shared"),
@@ -1022,14 +1007,14 @@ func TestReconcileSubnets(t *testing.T) {
 				})).
 					Return(&ec2.CreateTagsOutput{}, nil)
 
-				stubMockDescribeAvailabilityZonesWithContextCustomZones(m, []*ec2.AvailabilityZone{
+				stubMockDescribeAvailabilityZonesWithContextCustomZones(m, []types.AvailabilityZone{
 					{ZoneName: aws.String("us-east-1a"), ZoneType: aws.String("availability-zone")},
 					{ZoneName: aws.String("us-east-1b"), ZoneType: aws.String("availability-zone")},
 				}).AnyTimes()
 
-				m.CreateTagsWithContext(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
-					Resources: aws.StringSlice([]string{"subnet-2"}),
-					Tags: []*ec2.Tag{
+				m.CreateTags(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
+					Resources: []string{"subnet-2"},
+					Tags: []types.Tag{
 						{
 							Key:   aws.String("kubernetes.io/cluster/test-cluster"),
 							Value: aws.String("shared"),
@@ -1076,37 +1061,35 @@ func TestReconcileSubnets(t *testing.T) {
 				},
 			}).WithTagUnmanagedNetworkResources(true),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{subnetsVPCID},
 						},
-					}),
-					gomock.Any()).Return(nil)
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 			},
 			errorExpected:                true,
 			tagUnmanagedNetworkResources: true,
@@ -1131,20 +1114,20 @@ func TestReconcileSubnets(t *testing.T) {
 				},
 			}).WithTagUnmanagedNetworkResources(true),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{
+						Subnets: []types.Subnet{
 							{
 								VpcId:               aws.String(subnetsVPCID),
 								SubnetId:            aws.String("subnet-1"),
@@ -1162,27 +1145,25 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{subnetsVPCID},
 						},
-					}),
-					gomock.Any()).Return(nil)
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 
-				m.CreateTagsWithContext(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
-					Resources: aws.StringSlice([]string{"subnet-1"}),
-					Tags: []*ec2.Tag{
+				m.CreateTags(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
+					Resources: []string{"subnet-1"},
+					Tags: []types.Tag{
 						{
 							Key:   aws.String("kubernetes.io/cluster/test-cluster"),
 							Value: aws.String("shared"),
@@ -1195,9 +1176,9 @@ func TestReconcileSubnets(t *testing.T) {
 				})).
 					Return(&ec2.CreateTagsOutput{}, nil)
 
-				m.CreateTagsWithContext(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
-					Resources: aws.StringSlice([]string{"subnet-2"}),
-					Tags: []*ec2.Tag{
+				m.CreateTags(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
+					Resources: []string{"subnet-2"},
+					Tags: []types.Tag{
 						{
 							Key:   aws.String("kubernetes.io/cluster/test-cluster"),
 							Value: aws.String("shared"),
@@ -1210,9 +1191,9 @@ func TestReconcileSubnets(t *testing.T) {
 				})).
 					Return(&ec2.CreateTagsOutput{}, nil)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1a"),
 								ZoneType: aws.String("availability-zone"),
@@ -1246,46 +1227,44 @@ func TestReconcileSubnets(t *testing.T) {
 				},
 			}),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				describeCall := m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				describeCall := m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
-				})).
+				}), gomock.Any()).
 					Return(&ec2.DescribeSubnetsOutput{}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{subnetsVPCID},
 						},
-					}),
-					gomock.Any()).Return(nil)
-
-				firstSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
+				// Create the first subnet
+				firstSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.1.0.0/16"),
 					AvailabilityZone: aws.String("us-east-1a"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-private-us-east-1a"),
@@ -1311,7 +1290,7 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:               aws.String(subnetsVPCID),
 							SubnetId:            aws.String("subnet-1"),
 							CidrBlock:           aws.String("10.1.0.0/16"),
@@ -1321,17 +1300,28 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(describeCall)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
-					After(firstSubnet)
+				// Wait until first subnet is available
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-1"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-1"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).After(firstSubnet)
 
-				secondSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				// Create the second subnet
+				secondSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.2.0.0/16"),
 					AvailabilityZone: aws.String("us-east-1b"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-public-us-east-1b"),
@@ -1357,7 +1347,7 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:               aws.String(subnetsVPCID),
 							SubnetId:            aws.String("subnet-2"),
 							CidrBlock:           aws.String("10.2.0.0/16"),
@@ -1367,11 +1357,21 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(firstSubnet)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
-					After(secondSubnet)
+				// Wait until second subnet is available
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-2"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-2"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).After(secondSubnet)
 
-				m.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
-					MapPublicIpOnLaunch: &ec2.AttributeBooleanValue{
+				m.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
+					MapPublicIpOnLaunch: &types.AttributeBooleanValue{
 						Value: aws.Bool(true),
 					},
 					SubnetId: aws.String("subnet-2"),
@@ -1379,9 +1379,9 @@ func TestReconcileSubnets(t *testing.T) {
 					Return(&ec2.ModifySubnetAttributeOutput{}, nil).
 					After(secondSubnet)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1a"),
 								ZoneType: aws.String("availability-zone"),
@@ -1412,41 +1412,39 @@ func TestReconcileSubnets(t *testing.T) {
 				},
 			}),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{subnetsVPCID},
 						},
-					}),
-					gomock.Any()).Return(nil)
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1a"),
 								ZoneType: aws.String("availability-zone"),
@@ -1473,43 +1471,41 @@ func TestReconcileSubnets(t *testing.T) {
 				Subnets: []infrav1.SubnetSpec{},
 			}),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				describeCall := m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				describeCall := m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{subnetsVPCID},
 						},
-					}),
-					gomock.Any()).Return(nil)
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
-					ZoneNames: aws.StringSlice([]string{"us-east-1c"}),
+				m.DescribeAvailabilityZones(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
+					ZoneNames: []string{"us-east-1c"},
 				}).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1c"),
 								ZoneType: aws.String("availability-zone"),
@@ -1517,14 +1513,14 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil).AnyTimes()
 
-				firstSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				firstSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.0.0/17"),
 					AvailabilityZone: aws.String("us-east-1c"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-public-us-east-1c"),
@@ -1550,7 +1546,7 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:               aws.String(subnetsVPCID),
 							SubnetId:            aws.String("subnet-1"),
 							CidrBlock:           aws.String("10.0.0.0/17"),
@@ -1560,11 +1556,22 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(describeCall)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
+				// Wait until first subnet is available
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-1"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-1"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).
 					After(firstSubnet)
 
-				m.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
-					MapPublicIpOnLaunch: &ec2.AttributeBooleanValue{
+				m.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
+					MapPublicIpOnLaunch: &types.AttributeBooleanValue{
 						Value: aws.Bool(true),
 					},
 					SubnetId: aws.String("subnet-1"),
@@ -1572,14 +1579,14 @@ func TestReconcileSubnets(t *testing.T) {
 					Return(&ec2.ModifySubnetAttributeOutput{}, nil).
 					After(firstSubnet)
 
-				secondSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				secondSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.128.0/17"),
 					AvailabilityZone: aws.String("us-east-1c"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-private-us-east-1c"),
@@ -1605,7 +1612,7 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:               aws.String(subnetsVPCID),
 							SubnetId:            aws.String("subnet-2"),
 							CidrBlock:           aws.String("10.0.128.0/17"),
@@ -1615,12 +1622,22 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(firstSubnet)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
-					After(secondSubnet)
+				// Wait until second subnet is available
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-2"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-2"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).After(secondSubnet)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1c"),
 								ZoneType: aws.String("availability-zone"),
@@ -1646,43 +1663,41 @@ func TestReconcileSubnets(t *testing.T) {
 				Subnets: []infrav1.SubnetSpec{},
 			}),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				describeCall := m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				describeCall := m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{subnetsVPCID},
 						},
-					}),
-					gomock.Any()).Return(nil)
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
-					ZoneNames: aws.StringSlice([]string{"us-east-1c"}),
+				m.DescribeAvailabilityZones(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
+					ZoneNames: []string{"us-east-1c"},
 				}).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1c"),
 								ZoneType: aws.String("availability-zone"),
@@ -1690,15 +1705,15 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil).AnyTimes()
 
-				firstSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				firstSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.0.0/17"),
 					AvailabilityZone: aws.String("us-east-1c"),
 					Ipv6CidrBlock:    aws.String("2001:db8:1234:1a03::/64"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-public-us-east-1c"),
@@ -1724,17 +1739,17 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:                       aws.String(subnetsVPCID),
 							SubnetId:                    aws.String("subnet-1"),
 							CidrBlock:                   aws.String("10.0.0.0/17"),
 							AssignIpv6AddressOnCreation: aws.Bool(true),
-							Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{
+							Ipv6CidrBlockAssociationSet: []types.SubnetIpv6CidrBlockAssociation{
 								{
 									AssociationId: aws.String("amazon"),
 									Ipv6CidrBlock: aws.String("2001:db8:1234:1a03::/64"),
-									Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{
-										State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated),
+									Ipv6CidrBlockState: &types.SubnetCidrBlockState{
+										State: types.SubnetCidrBlockStateCodeAssociated,
 									},
 								},
 							},
@@ -1744,45 +1759,53 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(describeCall)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
+				// Wait until first subnet is available
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-1"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-1"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).
 					After(firstSubnet)
 
-				m.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
-					AssignIpv6AddressOnCreation: &ec2.AttributeBooleanValue{
+				m.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
+					AssignIpv6AddressOnCreation: &types.AttributeBooleanValue{
 						Value: aws.Bool(true),
 					},
 					SubnetId: aws.String("subnet-1"),
-				}).
-					Return(&ec2.ModifySubnetAttributeOutput{}, nil).
+				}).Return(&ec2.ModifySubnetAttributeOutput{}, nil).
 					After(firstSubnet)
 
-				m.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
-					AssignIpv6AddressOnCreation: &ec2.AttributeBooleanValue{
+				m.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
+					AssignIpv6AddressOnCreation: &types.AttributeBooleanValue{
 						Value: aws.Bool(true),
 					},
 					SubnetId: aws.String("subnet-2"),
-				}).
-					Return(&ec2.ModifySubnetAttributeOutput{}, nil).
+				}).Return(&ec2.ModifySubnetAttributeOutput{}, nil).
 					After(firstSubnet)
 
-				m.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
-					MapPublicIpOnLaunch: &ec2.AttributeBooleanValue{
+				m.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
+					MapPublicIpOnLaunch: &types.AttributeBooleanValue{
 						Value: aws.Bool(true),
 					},
 					SubnetId: aws.String("subnet-1"),
-				}).
-					Return(&ec2.ModifySubnetAttributeOutput{}, nil).
+				}).Return(&ec2.ModifySubnetAttributeOutput{}, nil).
 					After(firstSubnet)
 
-				secondSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				secondSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.128.0/17"),
 					AvailabilityZone: aws.String("us-east-1c"),
 					Ipv6CidrBlock:    aws.String("2001:db8:1234:1a02::/64"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-private-us-east-1c"),
@@ -1808,17 +1831,17 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:                       aws.String(subnetsVPCID),
 							SubnetId:                    aws.String("subnet-2"),
 							CidrBlock:                   aws.String("10.0.128.0/17"),
 							AssignIpv6AddressOnCreation: aws.Bool(true),
-							Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{
+							Ipv6CidrBlockAssociationSet: []types.SubnetIpv6CidrBlockAssociation{
 								{
 									AssociationId: aws.String("amazon"),
 									Ipv6CidrBlock: aws.String("2001:db8:1234:1a02::/64"),
-									Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{
-										State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated),
+									Ipv6CidrBlockState: &types.SubnetCidrBlockState{
+										State: types.SubnetCidrBlockStateCodeAssociated,
 									},
 								},
 							},
@@ -1828,12 +1851,23 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(firstSubnet)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
+				// Wait until second subnet is available
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-2"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-2"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).
 					After(secondSubnet)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1c"),
 								ZoneType: aws.String("availability-zone"),
@@ -1855,41 +1889,38 @@ func TestReconcileSubnets(t *testing.T) {
 				Subnets: []infrav1.SubnetSpec{},
 			}),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				describeCall := m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				describeCall := m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
-				})).
-					Return(&ec2.DescribeSubnetsOutput{}, nil)
+				})).Return(&ec2.DescribeSubnetsOutput{}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{subnetsVPCID},
 						},
-					}),
-					gomock.Any()).Return(nil)
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1b"),
 								ZoneType: aws.String("availability-zone"),
@@ -1902,11 +1933,11 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).AnyTimes()
 
 				// Zone1
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeAvailabilityZonesInput{
-					ZoneNames: aws.StringSlice([]string{"us-east-1b"}),
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Eq(&ec2.DescribeAvailabilityZonesInput{
+					ZoneNames: []string{"us-east-1b"},
 				})).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1b"),
 								ZoneType: aws.String("availability-zone"),
@@ -1914,14 +1945,14 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil).MaxTimes(2)
 
-				zone1PublicSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				zone1PublicSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.0.0/19"),
 					AvailabilityZone: aws.String("us-east-1b"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-public-us-east-1b"),
@@ -1947,7 +1978,7 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:               aws.String(subnetsVPCID),
 							SubnetId:            aws.String("subnet-1"),
 							CidrBlock:           aws.String("10.0.0.0/19"),
@@ -1957,11 +1988,22 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(describeCall)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
+				// Wait until first subnet is available
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-1"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-1"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).
 					After(zone1PublicSubnet)
 
-				m.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
-					MapPublicIpOnLaunch: &ec2.AttributeBooleanValue{
+				m.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
+					MapPublicIpOnLaunch: &types.AttributeBooleanValue{
 						Value: aws.Bool(true),
 					},
 					SubnetId: aws.String("subnet-1"),
@@ -1969,14 +2011,14 @@ func TestReconcileSubnets(t *testing.T) {
 					Return(&ec2.ModifySubnetAttributeOutput{}, nil).
 					After(zone1PublicSubnet)
 
-				zone1PrivateSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				zone1PrivateSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.64.0/18"),
 					AvailabilityZone: aws.String("us-east-1b"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-private-us-east-1b"),
@@ -2002,7 +2044,7 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:               aws.String(subnetsVPCID),
 							SubnetId:            aws.String("subnet-2"),
 							CidrBlock:           aws.String("10.0.64.0/18"),
@@ -2012,15 +2054,26 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(zone1PublicSubnet)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
+				// Wait until second subnet is available
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-2"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-2"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).
 					After(zone1PrivateSubnet)
 
 				// zone 2
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
-					ZoneNames: aws.StringSlice([]string{"us-east-1c"}),
+				m.DescribeAvailabilityZones(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
+					ZoneNames: []string{"us-east-1c"},
 				}).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1c"),
 								ZoneType: aws.String("availability-zone"),
@@ -2028,14 +2081,14 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil).AnyTimes()
 
-				zone2PublicSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				zone2PublicSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.32.0/19"),
 					AvailabilityZone: aws.String("us-east-1c"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-public-us-east-1c"),
@@ -2061,7 +2114,7 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:               aws.String(subnetsVPCID),
 							SubnetId:            aws.String("subnet-1"),
 							CidrBlock:           aws.String("10.0.32.0/19"),
@@ -2071,11 +2124,22 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(zone1PrivateSubnet)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
+				// Wait until first subnet is available
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-1"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-1"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).
 					After(zone2PublicSubnet)
 
-				m.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
-					MapPublicIpOnLaunch: &ec2.AttributeBooleanValue{
+				m.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
+					MapPublicIpOnLaunch: &types.AttributeBooleanValue{
 						Value: aws.Bool(true),
 					},
 					SubnetId: aws.String("subnet-1"),
@@ -2083,14 +2147,14 @@ func TestReconcileSubnets(t *testing.T) {
 					Return(&ec2.ModifySubnetAttributeOutput{}, nil).
 					After(zone2PublicSubnet)
 
-				zone2PrivateSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				zone2PrivateSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.128.0/18"),
 					AvailabilityZone: aws.String("us-east-1c"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-private-us-east-1c"),
@@ -2116,7 +2180,7 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:               aws.String(subnetsVPCID),
 							SubnetId:            aws.String("subnet-2"),
 							CidrBlock:           aws.String("10.0.128.0/18"),
@@ -2126,7 +2190,18 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(zone2PublicSubnet)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
+				// Wait until second subnet is available
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-2"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-2"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).
 					After(zone2PrivateSubnet)
 			},
 		},
@@ -2145,41 +2220,39 @@ func TestReconcileSubnets(t *testing.T) {
 				Subnets: []infrav1.SubnetSpec{},
 			}),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				describeCall := m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				describeCall := m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{subnetsVPCID},
 						},
-					}),
-					gomock.Any()).Return(nil)
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1b"),
 								ZoneType: aws.String("availability-zone"),
@@ -2187,14 +2260,14 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil).AnyTimes()
 
-				zone1PublicSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				zone1PublicSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.0.0/17"),
 					AvailabilityZone: aws.String("us-east-1b"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-public-us-east-1b"),
@@ -2220,7 +2293,7 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:               aws.String(subnetsVPCID),
 							SubnetId:            aws.String("subnet-1"),
 							CidrBlock:           aws.String("10.0.0.0/17"),
@@ -2230,11 +2303,20 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(describeCall)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
-					After(zone1PublicSubnet)
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-1"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-1"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).After(zone1PublicSubnet)
 
-				m.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
-					MapPublicIpOnLaunch: &ec2.AttributeBooleanValue{
+				m.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
+					MapPublicIpOnLaunch: &types.AttributeBooleanValue{
 						Value: aws.Bool(true),
 					},
 					SubnetId: aws.String("subnet-1"),
@@ -2242,14 +2324,14 @@ func TestReconcileSubnets(t *testing.T) {
 					Return(&ec2.ModifySubnetAttributeOutput{}, nil).
 					After(zone1PublicSubnet)
 
-				zone1PrivateSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				zone1PrivateSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.128.0/17"),
 					AvailabilityZone: aws.String("us-east-1b"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-private-us-east-1b"),
@@ -2275,7 +2357,7 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:               aws.String(subnetsVPCID),
 							SubnetId:            aws.String("subnet-2"),
 							CidrBlock:           aws.String("10.0.128.0/17"),
@@ -2285,8 +2367,17 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(zone1PublicSubnet)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
-					After(zone1PrivateSubnet)
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-2"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-2"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).After(zone1PrivateSubnet)
 			},
 		},
 		{
@@ -2313,26 +2404,26 @@ func TestReconcileSubnets(t *testing.T) {
 				},
 			}),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{
+						Subnets: []types.Subnet{
 							{
 								VpcId:            aws.String(subnetsVPCID),
 								SubnetId:         aws.String("subnet-1"),
 								AvailabilityZone: aws.String("us-east-1a"),
 								CidrBlock:        aws.String("10.0.0.0/17"),
-								Tags: []*ec2.Tag{
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"),
 										Value: aws.String("owned"),
@@ -2354,32 +2445,30 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{subnetsVPCID},
 						},
-					}),
-					gomock.Any()).Return(nil)
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 
-				m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.128.0/17"),
 					AvailabilityZone: aws.String("us-east-1a"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-private-us-east-1a"),
@@ -2405,7 +2494,7 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:            aws.String(subnetsVPCID),
 							SubnetId:         aws.String("subnet-2"),
 							CidrBlock:        aws.String("10.0.128.0/17"),
@@ -2413,15 +2502,25 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any())
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-2"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-2"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil)
 
 				// Public subnet
-				m.CreateTagsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateTagsInput{})).
+				m.CreateTags(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateTagsInput{})).
 					Return(nil, nil)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1a"),
 								ZoneType: aws.String("availability-zone"),
@@ -2455,26 +2554,26 @@ func TestReconcileSubnets(t *testing.T) {
 				},
 			}),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{
+						Subnets: []types.Subnet{
 							{
 								VpcId:            aws.String(subnetsVPCID),
 								SubnetId:         aws.String("subnet-1"),
 								AvailabilityZone: aws.String("us-east-1a"),
 								CidrBlock:        aws.String("10.0.0.0/17"),
-								Tags: []*ec2.Tag{
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"),
 										Value: aws.String("owned"),
@@ -2496,32 +2595,30 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{subnetsVPCID},
 						},
-					}),
-					gomock.Any()).Return(nil)
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 
-				m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.128.0/17"),
 					AvailabilityZone: aws.String("us-east-1a"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("custom-sub"), // must use the provided `Name` tag, not generate a name
@@ -2547,7 +2644,7 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:            aws.String(subnetsVPCID),
 							SubnetId:         aws.String("subnet-2"),
 							CidrBlock:        aws.String("10.0.128.0/17"),
@@ -2555,15 +2652,25 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any())
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-2"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-2"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil)
 
 				// Public subnet
-				m.CreateTagsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateTagsInput{})).
+				m.CreateTags(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateTagsInput{})).
 					Return(nil, nil)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1a"),
 								ZoneType: aws.String("availability-zone"),
@@ -2597,7 +2704,7 @@ func TestReconcileSubnets(t *testing.T) {
 				},
 			}),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				tagsOnSubnet1 := []*ec2.Tag{
+				tagsOnSubnet1 := []types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String("test-cluster-subnet-public"),
@@ -2611,7 +2718,7 @@ func TestReconcileSubnets(t *testing.T) {
 						Value: aws.String("public"),
 					},
 				}
-				tagsOnSubnet2 := []*ec2.Tag{
+				tagsOnSubnet2 := []types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String("test-cluster-subnet-private"),
@@ -2625,20 +2732,20 @@ func TestReconcileSubnets(t *testing.T) {
 						Value: aws.String("private"),
 					},
 				}
-				m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{
+						Subnets: []types.Subnet{
 							{
 								VpcId:            aws.String(subnetsVPCID),
 								SubnetId:         aws.String("subnet-1"),
@@ -2656,26 +2763,24 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{subnetsVPCID},
 						},
-					}),
-					gomock.Any()).Return(nil)
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 
 				// Public subnet
-				expectedAppliedAwsTagsForSubnet1 := []*ec2.Tag{
+				expectedAppliedAwsTagsForSubnet1 := []types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String("test-cluster-subnet-public-us-east-1a"),
@@ -2700,14 +2805,14 @@ func TestReconcileSubnets(t *testing.T) {
 						Key:   aws.String("this-tag-is-in-the-spec"),
 						Value: aws.String("but-its-not-on-aws"),
 					}}
-				m.CreateTagsWithContext(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
-					Resources: aws.StringSlice([]string{"subnet-1"}),
+				m.CreateTags(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
+					Resources: []string{"subnet-1"},
 					Tags:      expectedAppliedAwsTagsForSubnet1,
 				})).
 					Return(nil, nil)
 
 				// Private subnet
-				expectedAppliedAwsTagsForSubnet2 := []*ec2.Tag{
+				expectedAppliedAwsTagsForSubnet2 := []types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String("test-cluster-subnet-private-us-east-1a"),
@@ -2732,15 +2837,15 @@ func TestReconcileSubnets(t *testing.T) {
 						Key:   aws.String("subnet-2-this-tag-is-in-the-spec"),
 						Value: aws.String("subnet-2-but-its-not-on-aws"),
 					}}
-				m.CreateTagsWithContext(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
-					Resources: aws.StringSlice([]string{"subnet-2"}),
+				m.CreateTags(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
+					Resources: []string{"subnet-2"},
 					Tags:      expectedAppliedAwsTagsForSubnet2,
 				})).
 					Return(nil, nil)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1a"),
 								ZoneType: aws.String("availability-zone"),
@@ -2764,9 +2869,9 @@ func TestReconcileSubnets(t *testing.T) {
 					Subnets: []infrav1.SubnetSpec{},
 				}),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1b"),
 								ZoneType: aws.String("availability-zone"),
@@ -2778,42 +2883,40 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil).AnyTimes()
 
-				describeCall := m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				describeCall := m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{subnetsVPCID},
 						},
-					}),
-					gomock.Any()).Return(nil)
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 
 				// Zone 1 subnet.
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1b"),
 								ZoneType: aws.String("availability-zone"),
@@ -2821,14 +2924,14 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil).AnyTimes()
 
-				zone1PublicSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				zone1PublicSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.0.0/19"),
 					AvailabilityZone: aws.String("us-east-1b"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-public-us-east-1b"),
@@ -2854,7 +2957,7 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:               aws.String(subnetsVPCID),
 							SubnetId:            aws.String("subnet-1"),
 							CidrBlock:           aws.String("10.0.0.0/19"),
@@ -2864,11 +2967,21 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(describeCall)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-1"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-1"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).
 					After(zone1PublicSubnet)
 
-				m.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
-					MapPublicIpOnLaunch: &ec2.AttributeBooleanValue{
+				m.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
+					MapPublicIpOnLaunch: &types.AttributeBooleanValue{
 						Value: aws.Bool(true),
 					},
 					SubnetId: aws.String("subnet-1"),
@@ -2876,14 +2989,14 @@ func TestReconcileSubnets(t *testing.T) {
 					Return(&ec2.ModifySubnetAttributeOutput{}, nil).
 					After(zone1PublicSubnet)
 
-				zone1PrivateSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				zone1PrivateSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.64.0/18"),
 					AvailabilityZone: aws.String("us-east-1b"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-private-us-east-1b"),
@@ -2909,7 +3022,7 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:               aws.String(subnetsVPCID),
 							SubnetId:            aws.String("subnet-2"),
 							CidrBlock:           aws.String("10.0.64.0/18"),
@@ -2919,18 +3032,28 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(zone1PublicSubnet)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-2"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-2"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).
 					After(zone1PrivateSubnet)
 
 				// zone 2
-				zone2PublicSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				zone2PublicSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.32.0/19"),
 					AvailabilityZone: aws.String("us-east-1c"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-public-us-east-1c"),
@@ -2956,7 +3079,7 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:               aws.String(subnetsVPCID),
 							SubnetId:            aws.String("subnet-1"),
 							CidrBlock:           aws.String("10.0.32.0/19"),
@@ -2966,11 +3089,21 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(zone1PrivateSubnet)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-1"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-1"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).
 					After(zone2PublicSubnet)
 
-				m.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
-					MapPublicIpOnLaunch: &ec2.AttributeBooleanValue{
+				m.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
+					MapPublicIpOnLaunch: &types.AttributeBooleanValue{
 						Value: aws.Bool(true),
 					},
 					SubnetId: aws.String("subnet-1"),
@@ -2978,11 +3111,11 @@ func TestReconcileSubnets(t *testing.T) {
 					Return(&ec2.ModifySubnetAttributeOutput{}, nil).
 					After(zone2PublicSubnet)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeAvailabilityZonesInput{
-					ZoneNames: aws.StringSlice([]string{"us-east-1c"}),
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Eq(&ec2.DescribeAvailabilityZonesInput{
+					ZoneNames: []string{"us-east-1c"},
 				})).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1c"),
 								ZoneType: aws.String("availability-zone"),
@@ -2990,14 +3123,14 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil).AnyTimes()
 
-				zone2PrivateSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				zone2PrivateSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.128.0/18"),
 					AvailabilityZone: aws.String("us-east-1c"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-private-us-east-1c"),
@@ -3023,7 +3156,7 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:               aws.String(subnetsVPCID),
 							SubnetId:            aws.String("subnet-2"),
 							CidrBlock:           aws.String("10.0.128.0/18"),
@@ -3033,7 +3166,17 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(zone2PublicSubnet)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-2"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-2"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).
 					After(zone2PrivateSubnet)
 			},
 		},
@@ -3048,40 +3191,38 @@ func TestReconcileSubnets(t *testing.T) {
 			}(),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				describeCall := stubMockDescribeSubnetsWithContextManaged(m)
-				stubMockDescribeRouteTablesWithContext(m)
-				stubMockDescribeNatGatewaysPagesWithContext(m)
-				stubMockDescribeAvailabilityZonesWithContextCustomZones(m, []*ec2.AvailabilityZone{
+				stubMockDescribeRouteTables(m)
+				stubMockDescribeNatGateways(m)
+				stubMockDescribeAvailabilityZonesWithContextCustomZones(m, []types.AvailabilityZone{
 					{ZoneName: aws.String("us-east-1a"), ZoneType: aws.String("availability-zone")},
 					{ZoneName: aws.String("us-east-1b"), ZoneType: aws.String("availability-zone")},
 					{ZoneName: aws.String("us-east-1-nyc-1a"), ZoneType: aws.String("local-zone"), ParentZoneName: aws.String("us-east-1a")},
 					{ZoneName: aws.String("us-east-1-wl1-nyc-wlz-1"), ZoneType: aws.String("wavelength-zone"), ParentZoneName: aws.String("us-east-1a")},
 				}).AnyTimes()
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).AnyTimes()
-
 				// Zone 1a subnets
-				az1aPrivate := stubGenMockCreateSubnetWithContext(m, "test-cluster", "us-east-1a", "private", "10.0.1.0/24", false).
+				az1aPrivate := stubGenMockCreateSubnet(m, "test-cluster", "us-east-1a", "private", "10.0.1.0/24", false).
 					After(describeCall)
 
-				az1aPublic := stubGenMockCreateSubnetWithContext(m, "test-cluster", "us-east-1a", "public", "10.0.2.0/24", false).
+				az1aPublic := stubGenMockCreateSubnet(m, "test-cluster", "us-east-1a", "public", "10.0.2.0/24", false).
 					After(az1aPrivate)
 				stubMockModifySubnetAttributeWithContext(m, "subnet-public-us-east-1a").
 					After(az1aPublic)
 
 				// Zone 1b subnets
-				az1bPrivate := stubGenMockCreateSubnetWithContext(m, "test-cluster", "us-east-1b", "private", "10.0.3.0/24", false).
+				az1bPrivate := stubGenMockCreateSubnet(m, "test-cluster", "us-east-1b", "private", "10.0.3.0/24", false).
 					After(az1aPublic)
 
-				az1bPublic := stubGenMockCreateSubnetWithContext(m, "test-cluster", "us-east-1b", "public", "10.0.4.0/24", false).
+				az1bPublic := stubGenMockCreateSubnet(m, "test-cluster", "us-east-1b", "public", "10.0.4.0/24", false).
 					After(az1bPrivate)
 				stubMockModifySubnetAttributeWithContext(m, "subnet-public-us-east-1b").
 					After(az1bPublic)
 
 				// Local zone 1-nyc-1a.
-				lz1Private := stubGenMockCreateSubnetWithContext(m, "test-cluster", "us-east-1-nyc-1a", "private", "10.0.5.0/24", true).
+				lz1Private := stubGenMockCreateSubnet(m, "test-cluster", "us-east-1-nyc-1a", "private", "10.0.5.0/24", true).
 					After(az1bPublic)
 
-				lz1Public := stubGenMockCreateSubnetWithContext(m, "test-cluster", "us-east-1-nyc-1a", "public", "10.0.6.0/24", true).After(lz1Private)
+				lz1Public := stubGenMockCreateSubnet(m, "test-cluster", "us-east-1-nyc-1a", "public", "10.0.6.0/24", true).After(lz1Private)
 				stubMockModifySubnetAttributeWithContext(m, "subnet-public-us-east-1-nyc-1a").
 					After(lz1Public)
 			},
@@ -3091,31 +3232,29 @@ func TestReconcileSubnets(t *testing.T) {
 			input: NewClusterScope().WithNetwork(stubNetworkSpecWithSubnetsEdge),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				describeCall := stubMockDescribeSubnetsWithContextManaged(m)
-				stubMockDescribeRouteTablesWithContext(m)
-				stubMockDescribeNatGatewaysPagesWithContext(m)
+				stubMockDescribeRouteTables(m)
+				stubMockDescribeNatGateways(m)
 				stubMockDescribeAvailabilityZonesWithContextAllZones(m)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).AnyTimes()
-
 				// AZone 1a subnets
-				az1Private := stubGenMockCreateSubnetWithContext(m, "test-cluster", "us-east-1a", "private", "10.0.1.0/24", false).
+				az1Private := stubGenMockCreateSubnet(m, "test-cluster", "us-east-1a", "private", "10.0.1.0/24", false).
 					After(describeCall)
 
-				az1Public := stubGenMockCreateSubnetWithContext(m, "test-cluster", "us-east-1a", "public", "10.0.2.0/24", false).After(az1Private)
+				az1Public := stubGenMockCreateSubnet(m, "test-cluster", "us-east-1a", "public", "10.0.2.0/24", false).After(az1Private)
 				stubMockModifySubnetAttributeWithContext(m, "subnet-public-us-east-1a").After(az1Public)
 
 				// Local zone 1-nyc-1a.
-				lz1Private := stubGenMockCreateSubnetWithContext(m, "test-cluster", "us-east-1-nyc-1a", "private", "10.0.5.0/24", true).
+				lz1Private := stubGenMockCreateSubnet(m, "test-cluster", "us-east-1-nyc-1a", "private", "10.0.5.0/24", true).
 					After(describeCall)
 
-				lz1Public := stubGenMockCreateSubnetWithContext(m, "test-cluster", "us-east-1-nyc-1a", "public", "10.0.6.0/24", true).After(lz1Private)
+				lz1Public := stubGenMockCreateSubnet(m, "test-cluster", "us-east-1-nyc-1a", "public", "10.0.6.0/24", true).After(lz1Private)
 				stubMockModifySubnetAttributeWithContext(m, "subnet-public-us-east-1-nyc-1a").After(lz1Public)
 
 				// Wavelength zone nyc-1.
-				wz1Private := stubGenMockCreateSubnetWithContext(m, "test-cluster", "us-east-1-wl1-nyc-wlz-1", "private", "10.0.7.0/24", true).
+				wz1Private := stubGenMockCreateSubnet(m, "test-cluster", "us-east-1-wl1-nyc-wlz-1", "private", "10.0.7.0/24", true).
 					After(describeCall)
 
-				stubGenMockCreateSubnetWithContext(m, "test-cluster", "us-east-1-wl1-nyc-wlz-1", "public", "10.0.8.0/24", true).After(wz1Private)
+				stubGenMockCreateSubnet(m, "test-cluster", "us-east-1-wl1-nyc-wlz-1", "public", "10.0.8.0/24", true).After(wz1Private)
 			},
 		},
 		{
@@ -3123,12 +3262,12 @@ func TestReconcileSubnets(t *testing.T) {
 			input: NewClusterScope().WithNetwork(stubNetworkSpecWithSubnetsEdge),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				stubMockDescribeSubnetsWithContextManaged(m)
-				stubMockDescribeRouteTablesWithContext(m)
-				stubMockDescribeNatGatewaysPagesWithContext(m)
+				stubMockDescribeRouteTables(m)
+				stubMockDescribeNatGateways(m)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{},
+						AvailabilityZones: []types.AvailabilityZone{},
 					}, nil)
 			},
 			errorExpected:        true,
@@ -3152,15 +3291,13 @@ func TestReconcileSubnets(t *testing.T) {
 			}(),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				describe := stubMockDescribeSubnetsWithContextManaged(m)
-				stubMockDescribeRouteTablesWithContext(m)
-				stubMockDescribeNatGatewaysPagesWithContext(m)
+				stubMockDescribeRouteTables(m)
+				stubMockDescribeNatGateways(m)
 				stubMockDescribeAvailabilityZonesWithContextAllZones(m)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).AnyTimes()
-
-				az1Private := stubGenMockCreateSubnetWithContext(m, "test-cluster", "us-east-1a", "private", "10.0.1.0/24", false).After(describe)
+				az1Private := stubGenMockCreateSubnet(m, "test-cluster", "us-east-1a", "private", "10.0.1.0/24", false).After(describe)
 
-				az1Public := stubGenMockCreateSubnetWithContext(m, "test-cluster", "us-east-1a", "public", "10.0.2.0/24", false).After(az1Private)
+				az1Public := stubGenMockCreateSubnet(m, "test-cluster", "us-east-1a", "public", "10.0.2.0/24", false).After(az1Private)
 				stubMockModifySubnetAttributeWithContext(m, "subnet-public-us-east-1a").After(az1Public)
 			},
 			errorExpected:        true,
@@ -3186,13 +3323,13 @@ func TestReconcileSubnets(t *testing.T) {
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
 				stubMockDescribeSubnetsWithContextUnmanaged(m)
 				stubMockDescribeAvailabilityZonesWithContextAllZones(m)
-				stubMockDescribeRouteTablesWithContextWithWavelength(m,
+				stubMockDescribeRouteTablesWithWavelength(m,
 					[]string{"subnet-az-1a-private", "subnet-lz-1a-private", "subnet-wl-1a-private"},
 					[]string{"subnet-az-1a-public", "subnet-lz-1a-public"},
 					[]string{"subnet-wl-1a-public"})
 
-				stubMockDescribeNatGatewaysPagesWithContext(m)
-				stubMockCreateTagsWithContext(m, "test-cluster", "subnet-az-1a-private", "us-east-1a", "private", false).AnyTimes()
+				stubMockDescribeNatGateways(m)
+				stubMockCreateTags(m, "test-cluster", "subnet-az-1a-private", "us-east-1a", "private", false).AnyTimes()
 			},
 		},
 		{
@@ -3209,43 +3346,41 @@ func TestReconcileSubnets(t *testing.T) {
 				Subnets: []infrav1.SubnetSpec{},
 			}),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				describeCall := m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				describeCall := m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{subnetsVPCID},
 						},
-					}),
-					gomock.Any()).Return(nil)
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
-					ZoneNames: aws.StringSlice([]string{"us-east-1c"}),
+				m.DescribeAvailabilityZones(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
+					ZoneNames: []string{"us-east-1c"},
 				}).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1c"),
 								ZoneType: aws.String("availability-zone"),
@@ -3253,14 +3388,14 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil).AnyTimes()
 
-				firstSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				firstSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.128.0/17"),
 					AvailabilityZone: aws.String("us-east-1c"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-public-us-east-1c"),
@@ -3286,7 +3421,7 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:               aws.String(subnetsVPCID),
 							SubnetId:            aws.String("subnet-1"),
 							CidrBlock:           aws.String("10.0.128.0/17"),
@@ -3296,11 +3431,21 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(describeCall)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-1"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-1"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).
 					After(firstSubnet)
 
-				m.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
-					MapPublicIpOnLaunch: &ec2.AttributeBooleanValue{
+				m.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
+					MapPublicIpOnLaunch: &types.AttributeBooleanValue{
 						Value: aws.Bool(true),
 					},
 					SubnetId: aws.String("subnet-1"),
@@ -3308,14 +3453,14 @@ func TestReconcileSubnets(t *testing.T) {
 					Return(&ec2.ModifySubnetAttributeOutput{}, nil).
 					After(firstSubnet)
 
-				secondSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				secondSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.0.0/17"),
 					AvailabilityZone: aws.String("us-east-1c"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-private-us-east-1c"),
@@ -3341,7 +3486,7 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:               aws.String(subnetsVPCID),
 							SubnetId:            aws.String("subnet-2"),
 							CidrBlock:           aws.String("10.0.0.0/17"),
@@ -3351,12 +3496,22 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(firstSubnet)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-2"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-2"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).
 					After(secondSubnet)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1c"),
 								ZoneType: aws.String("availability-zone"),
@@ -3383,43 +3538,41 @@ func TestReconcileSubnets(t *testing.T) {
 				Subnets: []infrav1.SubnetSpec{},
 			}),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				describeCall := m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				describeCall := m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{subnetsVPCID},
 						},
-					}),
-					gomock.Any()).Return(nil)
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
-					ZoneNames: aws.StringSlice([]string{"us-east-1c"}),
+				m.DescribeAvailabilityZones(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
+					ZoneNames: []string{"us-east-1c"},
 				}).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1c"),
 								ZoneType: aws.String("availability-zone"),
@@ -3427,15 +3580,15 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil).AnyTimes()
 
-				firstSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				firstSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.128.0/17"),
 					AvailabilityZone: aws.String("us-east-1c"),
 					Ipv6CidrBlock:    aws.String("2001:db8:1234:1a02::/64"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-public-us-east-1c"),
@@ -3461,17 +3614,17 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:                       aws.String(subnetsVPCID),
 							SubnetId:                    aws.String("subnet-1"),
 							CidrBlock:                   aws.String("10.0.128.0/17"),
 							AssignIpv6AddressOnCreation: aws.Bool(true),
-							Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{
+							Ipv6CidrBlockAssociationSet: []types.SubnetIpv6CidrBlockAssociation{
 								{
 									AssociationId: aws.String("amazon"),
 									Ipv6CidrBlock: aws.String("2001:db8:1234:1a02::/64"),
-									Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{
-										State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated),
+									Ipv6CidrBlockState: &types.SubnetCidrBlockState{
+										State: types.SubnetCidrBlockStateCodeAssociated,
 									},
 								},
 							},
@@ -3481,11 +3634,21 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(describeCall)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-1"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-1"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).
 					After(firstSubnet)
 
-				m.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
-					AssignIpv6AddressOnCreation: &ec2.AttributeBooleanValue{
+				m.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
+					AssignIpv6AddressOnCreation: &types.AttributeBooleanValue{
 						Value: aws.Bool(true),
 					},
 					SubnetId: aws.String("subnet-1"),
@@ -3493,8 +3656,8 @@ func TestReconcileSubnets(t *testing.T) {
 					Return(&ec2.ModifySubnetAttributeOutput{}, nil).
 					After(firstSubnet)
 
-				m.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
-					AssignIpv6AddressOnCreation: &ec2.AttributeBooleanValue{
+				m.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
+					AssignIpv6AddressOnCreation: &types.AttributeBooleanValue{
 						Value: aws.Bool(true),
 					},
 					SubnetId: aws.String("subnet-2"),
@@ -3502,8 +3665,8 @@ func TestReconcileSubnets(t *testing.T) {
 					Return(&ec2.ModifySubnetAttributeOutput{}, nil).
 					After(firstSubnet)
 
-				m.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
-					MapPublicIpOnLaunch: &ec2.AttributeBooleanValue{
+				m.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
+					MapPublicIpOnLaunch: &types.AttributeBooleanValue{
 						Value: aws.Bool(true),
 					},
 					SubnetId: aws.String("subnet-1"),
@@ -3511,15 +3674,15 @@ func TestReconcileSubnets(t *testing.T) {
 					Return(&ec2.ModifySubnetAttributeOutput{}, nil).
 					After(firstSubnet)
 
-				secondSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				secondSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.0.0/17"),
 					AvailabilityZone: aws.String("us-east-1c"),
 					Ipv6CidrBlock:    aws.String("2001:db8:1234:1a03::/64"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-private-us-east-1c"),
@@ -3545,17 +3708,17 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:                       aws.String(subnetsVPCID),
 							SubnetId:                    aws.String("subnet-2"),
 							CidrBlock:                   aws.String("10.0.0.0/17"),
 							AssignIpv6AddressOnCreation: aws.Bool(true),
-							Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{
+							Ipv6CidrBlockAssociationSet: []types.SubnetIpv6CidrBlockAssociation{
 								{
 									AssociationId: aws.String("amazon"),
 									Ipv6CidrBlock: aws.String("2001:db8:1234:1a03::/64"),
-									Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{
-										State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated),
+									Ipv6CidrBlockState: &types.SubnetCidrBlockState{
+										State: types.SubnetCidrBlockStateCodeAssociated,
 									},
 								},
 							},
@@ -3565,12 +3728,22 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(firstSubnet)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-2"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-2"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).
 					After(secondSubnet)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1c"),
 								ZoneType: aws.String("availability-zone"),
@@ -3597,41 +3770,39 @@ func TestReconcileSubnets(t *testing.T) {
 				Subnets: []infrav1.SubnetSpec{},
 			}),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				describeCall := m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				describeCall := m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
-					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
-							{
-								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
-							},
-							{
-								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
-							},
+				m.DescribeNatGateways(context.TODO(), gomock.Eq(&ec2.DescribeNatGatewaysInput{
+					Filter: []types.Filter{
+						{
+							Name:   aws.String("vpc-id"),
+							Values: []string{subnetsVPCID},
 						},
-					}),
-					gomock.Any()).Return(nil)
+						{
+							Name:   aws.String("state"),
+							Values: []string{"pending", "available"},
+						},
+					},
+				}), gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1b"),
 								ZoneType: aws.String("availability-zone"),
@@ -3644,11 +3815,11 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).AnyTimes()
 
 				// Zone1
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Eq(&ec2.DescribeAvailabilityZonesInput{
-					ZoneNames: aws.StringSlice([]string{"us-east-1b"}),
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Eq(&ec2.DescribeAvailabilityZonesInput{
+					ZoneNames: []string{"us-east-1b"},
 				})).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1b"),
 								ZoneType: aws.String("availability-zone"),
@@ -3656,15 +3827,15 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil).MaxTimes(2)
 
-				zone1PublicSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				zone1PublicSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.64.0/18"),
 					AvailabilityZone: aws.String("us-east-1b"),
 					Ipv6CidrBlock:    aws.String("2001:db8:1234:1a02::/64"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-public-us-east-1b"),
@@ -3690,17 +3861,17 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:                       aws.String(subnetsVPCID),
 							SubnetId:                    aws.String("subnet-1"),
 							CidrBlock:                   aws.String("10.0.64.0/18"),
 							AssignIpv6AddressOnCreation: aws.Bool(true),
-							Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{
+							Ipv6CidrBlockAssociationSet: []types.SubnetIpv6CidrBlockAssociation{
 								{
 									AssociationId: aws.String("amazon"),
 									Ipv6CidrBlock: aws.String("2001:db8:1234:1a02::/64"),
-									Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{
-										State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated),
+									Ipv6CidrBlockState: &types.SubnetCidrBlockState{
+										State: types.SubnetCidrBlockStateCodeAssociated,
 									},
 								},
 							},
@@ -3710,11 +3881,21 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(describeCall)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-1"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-1"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).
 					After(zone1PublicSubnet)
 
-				m.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
-					AssignIpv6AddressOnCreation: &ec2.AttributeBooleanValue{
+				m.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
+					AssignIpv6AddressOnCreation: &types.AttributeBooleanValue{
 						Value: aws.Bool(true),
 					},
 					SubnetId: aws.String("subnet-1"),
@@ -3722,8 +3903,8 @@ func TestReconcileSubnets(t *testing.T) {
 					Return(&ec2.ModifySubnetAttributeOutput{}, nil).
 					After(zone1PublicSubnet)
 
-				m.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
-					AssignIpv6AddressOnCreation: &ec2.AttributeBooleanValue{
+				m.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
+					AssignIpv6AddressOnCreation: &types.AttributeBooleanValue{
 						Value: aws.Bool(true),
 					},
 					SubnetId: aws.String("subnet-2"),
@@ -3731,8 +3912,8 @@ func TestReconcileSubnets(t *testing.T) {
 					Return(&ec2.ModifySubnetAttributeOutput{}, nil).
 					After(zone1PublicSubnet)
 
-				m.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
-					MapPublicIpOnLaunch: &ec2.AttributeBooleanValue{
+				m.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
+					MapPublicIpOnLaunch: &types.AttributeBooleanValue{
 						Value: aws.Bool(true),
 					},
 					SubnetId: aws.String("subnet-1"),
@@ -3740,15 +3921,15 @@ func TestReconcileSubnets(t *testing.T) {
 					Return(&ec2.ModifySubnetAttributeOutput{}, nil).
 					After(zone1PublicSubnet)
 
-				zone1PrivateSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				zone1PrivateSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.0.0/19"),
 					AvailabilityZone: aws.String("us-east-1b"),
 					Ipv6CidrBlock:    aws.String("2001:db8:1234:1a04::/64"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-private-us-east-1b"),
@@ -3774,17 +3955,17 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:                       aws.String(subnetsVPCID),
 							SubnetId:                    aws.String("subnet-2"),
 							CidrBlock:                   aws.String("10.0.0.0/19"),
 							AssignIpv6AddressOnCreation: aws.Bool(true),
-							Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{
+							Ipv6CidrBlockAssociationSet: []types.SubnetIpv6CidrBlockAssociation{
 								{
 									AssociationId: aws.String("amazon"),
 									Ipv6CidrBlock: aws.String("2001:db8:1234:1a04::/64"),
-									Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{
-										State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated),
+									Ipv6CidrBlockState: &types.SubnetCidrBlockState{
+										State: types.SubnetCidrBlockStateCodeAssociated,
 									},
 								},
 							},
@@ -3794,15 +3975,25 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(zone1PublicSubnet)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-2"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-2"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).
 					After(zone1PrivateSubnet)
 
 				// zone 2
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
-					ZoneNames: aws.StringSlice([]string{"us-east-1c"}),
+				m.DescribeAvailabilityZones(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
+					ZoneNames: []string{"us-east-1c"},
 				}).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1c"),
 								ZoneType: aws.String("availability-zone"),
@@ -3810,15 +4001,15 @@ func TestReconcileSubnets(t *testing.T) {
 						},
 					}, nil).AnyTimes()
 
-				zone2PublicSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				zone2PublicSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.128.0/18"),
 					AvailabilityZone: aws.String("us-east-1c"),
 					Ipv6CidrBlock:    aws.String("2001:db8:1234:1a03::/64"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-public-us-east-1c"),
@@ -3844,17 +4035,17 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:                       aws.String(subnetsVPCID),
 							SubnetId:                    aws.String("subnet-1"),
 							CidrBlock:                   aws.String("10.0.128.0/18"),
 							AssignIpv6AddressOnCreation: aws.Bool(true),
-							Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{
+							Ipv6CidrBlockAssociationSet: []types.SubnetIpv6CidrBlockAssociation{
 								{
 									AssociationId: aws.String("amazon"),
 									Ipv6CidrBlock: aws.String("2001:db8:1234:1a03::/64"),
-									Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{
-										State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated),
+									Ipv6CidrBlockState: &types.SubnetCidrBlockState{
+										State: types.SubnetCidrBlockStateCodeAssociated,
 									},
 								},
 							},
@@ -3864,11 +4055,21 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(zone1PrivateSubnet)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-1"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-1"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).
 					After(zone2PublicSubnet)
 
-				m.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
-					AssignIpv6AddressOnCreation: &ec2.AttributeBooleanValue{
+				m.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
+					AssignIpv6AddressOnCreation: &types.AttributeBooleanValue{
 						Value: aws.Bool(true),
 					},
 					SubnetId: aws.String("subnet-1"),
@@ -3876,16 +4077,16 @@ func TestReconcileSubnets(t *testing.T) {
 					Return(&ec2.ModifySubnetAttributeOutput{}, nil).
 					After(zone2PublicSubnet)
 
-				m.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
-					AssignIpv6AddressOnCreation: &ec2.AttributeBooleanValue{
+				m.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
+					AssignIpv6AddressOnCreation: &types.AttributeBooleanValue{
 						Value: aws.Bool(true),
 					},
 					SubnetId: aws.String("subnet-2"),
 				}).
 					Return(&ec2.ModifySubnetAttributeOutput{}, nil).
 					After(zone2PublicSubnet)
-				m.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
-					MapPublicIpOnLaunch: &ec2.AttributeBooleanValue{
+				m.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
+					MapPublicIpOnLaunch: &types.AttributeBooleanValue{
 						Value: aws.Bool(true),
 					},
 					SubnetId: aws.String("subnet-1"),
@@ -3893,15 +4094,15 @@ func TestReconcileSubnets(t *testing.T) {
 					Return(&ec2.ModifySubnetAttributeOutput{}, nil).
 					After(zone2PublicSubnet)
 
-				zone2PrivateSubnet := m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+				zone2PrivateSubnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 					VpcId:            aws.String(subnetsVPCID),
 					CidrBlock:        aws.String("10.0.32.0/19"),
 					AvailabilityZone: aws.String("us-east-1c"),
 					Ipv6CidrBlock:    aws.String("2001:db8:1234:1a05::/64"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("subnet"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSubnet,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-subnet-private-us-east-1c"),
@@ -3927,17 +4128,17 @@ func TestReconcileSubnets(t *testing.T) {
 					},
 				})).
 					Return(&ec2.CreateSubnetOutput{
-						Subnet: &ec2.Subnet{
+						Subnet: &types.Subnet{
 							VpcId:                       aws.String(subnetsVPCID),
 							SubnetId:                    aws.String("subnet-2"),
 							CidrBlock:                   aws.String("10.0.32.0/19"),
 							AssignIpv6AddressOnCreation: aws.Bool(true),
-							Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{
+							Ipv6CidrBlockAssociationSet: []types.SubnetIpv6CidrBlockAssociation{
 								{
 									AssociationId: aws.String("amazon"),
 									Ipv6CidrBlock: aws.String("2001:db8:1234:1a05::/64"),
-									Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{
-										State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated),
+									Ipv6CidrBlockState: &types.SubnetCidrBlockState{
+										State: types.SubnetCidrBlockStateCodeAssociated,
 									},
 								},
 							},
@@ -3947,7 +4148,17 @@ func TestReconcileSubnets(t *testing.T) {
 					}, nil).
 					After(zone2PublicSubnet)
 
-				m.WaitUntilSubnetAvailableWithContext(context.TODO(), gomock.Any()).
+				m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					SubnetIds: []string{"subnet-2"},
+				}), gomock.Any()).Return(&ec2.DescribeSubnetsOutput{
+					Subnets: []types.Subnet{
+						{
+							VpcId:    aws.String(subnetsVPCID),
+							SubnetId: aws.String("subnet-2"),
+							State:    types.SubnetStateAvailable,
+						},
+					},
+				}, nil).
 					After(zone2PrivateSubnet)
 			},
 		},
@@ -4026,26 +4237,26 @@ func TestDiscoverSubnets(t *testing.T) {
 				},
 			},
 			mocks: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{
+						Subnets: []types.Subnet{
 							{
 								VpcId:            aws.String(subnetsVPCID),
 								SubnetId:         aws.String("subnet-1"),
 								AvailabilityZone: aws.String("us-east-1a"),
 								CidrBlock:        aws.String("10.0.10.0/24"),
-								Tags: []*ec2.Tag{
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("Name"),
 										Value: aws.String("provided-subnet-public"),
@@ -4057,7 +4268,7 @@ func TestDiscoverSubnets(t *testing.T) {
 								SubnetId:         aws.String("subnet-2"),
 								AvailabilityZone: aws.String("us-east-1a"),
 								CidrBlock:        aws.String("10.0.11.0/24"),
-								Tags: []*ec2.Tag{
+								Tags: []types.Tag{
 									{
 										Key:   aws.String("Name"),
 										Value: aws.String("provided-subnet-private"),
@@ -4067,9 +4278,9 @@ func TestDiscoverSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+				m.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName: aws.String("us-east-1a"),
 								ZoneType: aws.String("availability-zone"),
@@ -4077,16 +4288,16 @@ func TestDiscoverSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+				m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 					Return(&ec2.DescribeRouteTablesOutput{
-						RouteTables: []*ec2.RouteTable{
+						RouteTables: []types.RouteTable{
 							{
-								Associations: []*ec2.RouteTableAssociation{
+								Associations: []types.RouteTableAssociation{
 									{
 										SubnetId: aws.String("subnet-1"),
 									},
 								},
-								Routes: []*ec2.Route{
+								Routes: []types.Route{
 									{
 										DestinationCidrBlock: aws.String("10.0.10.0/24"),
 										GatewayId:            aws.String("local"),
@@ -4099,12 +4310,12 @@ func TestDiscoverSubnets(t *testing.T) {
 								RouteTableId: aws.String("rtb-1"),
 							},
 							{
-								Associations: []*ec2.RouteTableAssociation{
+								Associations: []types.RouteTableAssociation{
 									{
 										SubnetId: aws.String("subnet-2"),
 									},
 								},
-								Routes: []*ec2.Route{
+								Routes: []types.Route{
 									{
 										DestinationCidrBlock: aws.String("10.0.11.0/24"),
 										GatewayId:            aws.String("local"),
@@ -4115,22 +4326,22 @@ func TestDiscoverSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.DescribeNatGatewaysPagesWithContext(context.TODO(),
+				m.DescribeNatGateways(context.TODO(),
 					gomock.Eq(&ec2.DescribeNatGatewaysInput{
-						Filter: []*ec2.Filter{
+						Filter: []types.Filter{
 							{
 								Name:   aws.String("vpc-id"),
-								Values: []*string{aws.String(subnetsVPCID)},
+								Values: []string{subnetsVPCID},
 							},
 							{
 								Name:   aws.String("state"),
-								Values: []*string{aws.String("pending"), aws.String("available")},
+								Values: []string{"pending", "available"},
 							},
 						},
 					}),
-					gomock.Any()).Return(nil)
+					gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 
-				m.CreateTagsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateTagsInput{})).
+				m.CreateTags(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateTagsInput{})).
 					Return(&ec2.CreateTagsOutput{}, nil).AnyTimes()
 			},
 			expect: []infrav1.SubnetSpec{
@@ -4247,20 +4458,20 @@ func TestDeleteSubnets(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: []*string{aws.String("pending"), aws.String("available")},
+							Values: []string{"pending", "available"},
 						},
 						{
 							Name:   aws.String("vpc-id"),
-							Values: []*string{aws.String(subnetsVPCID)},
+							Values: []string{subnetsVPCID},
 						},
 					},
 				})).
 					Return(&ec2.DescribeSubnetsOutput{
-						Subnets: []*ec2.Subnet{
+						Subnets: []types.Subnet{
 							{
 								VpcId:               aws.String(subnetsVPCID),
 								SubnetId:            aws.String("subnet-1"),
@@ -4278,12 +4489,12 @@ func TestDeleteSubnets(t *testing.T) {
 						},
 					}, nil)
 
-				m.DeleteSubnetWithContext(context.TODO(), &ec2.DeleteSubnetInput{
+				m.DeleteSubnet(context.TODO(), &ec2.DeleteSubnetInput{
 					SubnetId: aws.String("subnet-1"),
 				}).
 					Return(nil, nil)
 
-				m.DeleteSubnetWithContext(context.TODO(), &ec2.DeleteSubnetInput{
+				m.DeleteSubnet(context.TODO(), &ec2.DeleteSubnetInput{
 					SubnetId: aws.String("subnet-2"),
 				}).
 					Return(nil, nil)
@@ -4445,7 +4656,7 @@ func TestService_retrieveZoneInfo(t *testing.T) {
 		name           string
 		inputZoneNames []string
 		expect         func(m *mocks.MockEC2APIMockRecorder)
-		want           []*ec2.AvailabilityZone
+		want           []types.AvailabilityZone
 		wantErrMessage string
 	}
 
@@ -4454,24 +4665,24 @@ func TestService_retrieveZoneInfo(t *testing.T) {
 			name:           "empty zones",
 			inputZoneNames: []string{},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
-					ZoneNames: aws.StringSlice([]string{}),
+				m.DescribeAvailabilityZones(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
+					ZoneNames: []string{},
 				}).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{},
+						AvailabilityZones: []types.AvailabilityZone{},
 					}, nil)
 			},
-			want: []*ec2.AvailabilityZone{},
+			want: []types.AvailabilityZone{},
 		},
 		{
 			name:           "error describing zones",
 			inputZoneNames: []string{},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
-					ZoneNames: aws.StringSlice([]string{}),
+				m.DescribeAvailabilityZones(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
+					ZoneNames: []string{},
 				}).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{},
+						AvailabilityZones: []types.AvailabilityZone{},
 					}, nil).Return(nil, awserrors.NewNotFound("FailedDescribeAvailableZones"))
 			},
 			wantErrMessage: `failed to describe availability zones: FailedDescribeAvailableZones`,
@@ -4480,11 +4691,11 @@ func TestService_retrieveZoneInfo(t *testing.T) {
 			name:           "get type availability zones",
 			inputZoneNames: []string{"us-east-1a", "us-east-1b"},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
-					ZoneNames: aws.StringSlice([]string{"us-east-1a", "us-east-1b"}),
+				m.DescribeAvailabilityZones(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
+					ZoneNames: []string{"us-east-1a", "us-east-1b"},
 				}).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName:       aws.String("us-east-1a"),
 								ZoneType:       aws.String("availability-zone"),
@@ -4498,7 +4709,7 @@ func TestService_retrieveZoneInfo(t *testing.T) {
 						},
 					}, nil)
 			},
-			want: []*ec2.AvailabilityZone{
+			want: []types.AvailabilityZone{
 				{
 					ZoneName:       aws.String("us-east-1a"),
 					ZoneType:       aws.String("availability-zone"),
@@ -4515,11 +4726,11 @@ func TestService_retrieveZoneInfo(t *testing.T) {
 			name:           "get type local zones",
 			inputZoneNames: []string{"us-east-1-nyc-1a", "us-east-1-bos-1a"},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
-					ZoneNames: aws.StringSlice([]string{"us-east-1-nyc-1a", "us-east-1-bos-1a"}),
+				m.DescribeAvailabilityZones(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
+					ZoneNames: []string{"us-east-1-nyc-1a", "us-east-1-bos-1a"},
 				}).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName:       aws.String("us-east-1-nyc-1a"),
 								ZoneType:       aws.String("local-zone"),
@@ -4533,7 +4744,7 @@ func TestService_retrieveZoneInfo(t *testing.T) {
 						},
 					}, nil)
 			},
-			want: []*ec2.AvailabilityZone{
+			want: []types.AvailabilityZone{
 				{
 					ZoneName:       aws.String("us-east-1-nyc-1a"),
 					ZoneType:       aws.String("local-zone"),
@@ -4550,11 +4761,11 @@ func TestService_retrieveZoneInfo(t *testing.T) {
 			name:           "get type wavelength zones",
 			inputZoneNames: []string{"us-east-1-wl1-nyc-wlz-1", "us-east-1-wl1-bos-wlz-1"},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
-					ZoneNames: aws.StringSlice([]string{"us-east-1-wl1-nyc-wlz-1", "us-east-1-wl1-bos-wlz-1"}),
+				m.DescribeAvailabilityZones(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
+					ZoneNames: []string{"us-east-1-wl1-nyc-wlz-1", "us-east-1-wl1-bos-wlz-1"},
 				}).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName:       aws.String("us-east-1-wl1-nyc-wlz-1"),
 								ZoneType:       aws.String("wavelength-zone"),
@@ -4568,7 +4779,7 @@ func TestService_retrieveZoneInfo(t *testing.T) {
 						},
 					}, nil)
 			},
-			want: []*ec2.AvailabilityZone{
+			want: []types.AvailabilityZone{
 				{
 					ZoneName:       aws.String("us-east-1-wl1-nyc-wlz-1"),
 					ZoneType:       aws.String("wavelength-zone"),
@@ -4585,11 +4796,11 @@ func TestService_retrieveZoneInfo(t *testing.T) {
 			name:           "get all zone types",
 			inputZoneNames: []string{"us-east-1a", "us-east-1-nyc-1a", "us-east-1-wl1-nyc-wlz-1"},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeAvailabilityZonesWithContext(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
-					ZoneNames: aws.StringSlice([]string{"us-east-1a", "us-east-1-nyc-1a", "us-east-1-wl1-nyc-wlz-1"}),
+				m.DescribeAvailabilityZones(context.TODO(), &ec2.DescribeAvailabilityZonesInput{
+					ZoneNames: []string{"us-east-1a", "us-east-1-nyc-1a", "us-east-1-wl1-nyc-wlz-1"},
 				}).
 					Return(&ec2.DescribeAvailabilityZonesOutput{
-						AvailabilityZones: []*ec2.AvailabilityZone{
+						AvailabilityZones: []types.AvailabilityZone{
 							{
 								ZoneName:       aws.String("us-east-1a"),
 								ZoneType:       aws.String("availability-zone"),
@@ -4608,7 +4819,7 @@ func TestService_retrieveZoneInfo(t *testing.T) {
 						},
 					}, nil)
 			},
-			want: []*ec2.AvailabilityZone{
+			want: []types.AvailabilityZone{
 				{
 					ZoneName:       aws.String("us-east-1a"),
 					ZoneType:       aws.String("availability-zone"),
@@ -4674,8 +4885,8 @@ func TestService_retrieveZoneInfo(t *testing.T) {
 
 // Stub functions to generate AWS mock calls.
 
-func stubGetTags(prefix, role, zone string, isEdge bool) []*ec2.Tag {
-	tags := []*ec2.Tag{
+func stubGetTags(prefix, role, zone string, isEdge bool) []types.Tag {
+	tags := []types.Tag{
 		{Key: aws.String("Name"), Value: aws.String(fmt.Sprintf("%s-subnet-%s-%s", prefix, role, zone))},
 		{Key: aws.String("kubernetes.io/cluster/test-cluster"), Value: aws.String("owned")},
 	}
@@ -4685,13 +4896,13 @@ func stubGetTags(prefix, role, zone string, isEdge bool) []*ec2.Tag {
 		if role == "public" {
 			lbLabel = "elb"
 		}
-		tags = append(tags, &ec2.Tag{
+		tags = append(tags, types.Tag{
 			Key:   aws.String(fmt.Sprintf("kubernetes.io/role/%s", lbLabel)),
 			Value: aws.String("1"),
 		})
 	}
 	// ... then appending the rest of tags
-	tags = append(tags, []*ec2.Tag{
+	tags = append(tags, []types.Tag{
 		{Key: aws.String("sigs.k8s.io/cluster-api-provider-aws/cluster/test-cluster"), Value: aws.String("owned")},
 		{Key: aws.String("sigs.k8s.io/cluster-api-provider-aws/role"), Value: aws.String(role)},
 	}...)
@@ -4699,20 +4910,20 @@ func stubGetTags(prefix, role, zone string, isEdge bool) []*ec2.Tag {
 	return tags
 }
 
-func stubGenMockCreateSubnetWithContext(m *mocks.MockEC2APIMockRecorder, prefix, zone, role, cidr string, isEdge bool) *gomock.Call {
-	return m.CreateSubnetWithContext(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
+func stubGenMockCreateSubnet(m *mocks.MockEC2APIMockRecorder, prefix, zone, role, cidr string, isEdge bool) *gomock.Call {
+	subnet := m.CreateSubnet(context.TODO(), gomock.Eq(&ec2.CreateSubnetInput{
 		VpcId:            aws.String(subnetsVPCID),
 		CidrBlock:        aws.String(cidr),
 		AvailabilityZone: aws.String(zone),
-		TagSpecifications: []*ec2.TagSpecification{
+		TagSpecifications: []types.TagSpecification{
 			{
-				ResourceType: aws.String("subnet"),
+				ResourceType: types.ResourceTypeSubnet,
 				Tags:         stubGetTags(prefix, role, zone, isEdge),
 			},
 		},
 	})).
 		Return(&ec2.CreateSubnetOutput{
-			Subnet: &ec2.Subnet{
+			Subnet: &types.Subnet{
 				VpcId:               aws.String(subnetsVPCID),
 				SubnetId:            aws.String(fmt.Sprintf("subnet-%s-%s", role, zone)),
 				CidrBlock:           aws.String(cidr),
@@ -4720,27 +4931,41 @@ func stubGenMockCreateSubnetWithContext(m *mocks.MockEC2APIMockRecorder, prefix,
 				MapPublicIpOnLaunch: aws.Bool(false),
 			},
 		}, nil)
+
+	// Wait for the subnet to become available
+	return m.DescribeSubnets(gomock.Any(), gomock.Eq(&ec2.DescribeSubnetsInput{SubnetIds: []string{fmt.Sprintf("subnet-%s-%s", role, zone)}}), gomock.Any()).
+		Return(&ec2.DescribeSubnetsOutput{
+			Subnets: []types.Subnet{
+				{
+					VpcId:            aws.String(subnetsVPCID),
+					SubnetId:         aws.String(fmt.Sprintf("subnet-%s-%s", role, zone)),
+					CidrBlock:        aws.String(cidr),
+					AvailabilityZone: aws.String(zone),
+					State:            types.SubnetStateAvailable,
+				},
+			},
+		}, nil).After(subnet)
 }
 
-func stubMockCreateTagsWithContext(m *mocks.MockEC2APIMockRecorder, prefix, name, zone, role string, isEdge bool) *gomock.Call {
-	return m.CreateTagsWithContext(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
-		Resources: aws.StringSlice([]string{name}),
+func stubMockCreateTags(m *mocks.MockEC2APIMockRecorder, prefix, name, zone, role string, isEdge bool) *gomock.Call {
+	return m.CreateTags(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
+		Resources: []string{name},
 		Tags:      stubGetTags(prefix, role, zone, isEdge),
 	})).
 		Return(&ec2.CreateTagsOutput{}, nil)
 }
 
-func stubMockDescribeRouteTablesWithContext(m *mocks.MockEC2APIMockRecorder) {
-	m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+func stubMockDescribeRouteTables(m *mocks.MockEC2APIMockRecorder) {
+	m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 		Return(&ec2.DescribeRouteTablesOutput{}, nil)
 }
 
-func stubMockDescribeRouteTablesWithContextWithWavelength(m *mocks.MockEC2APIMockRecorder, privSubnets, pubSubnetsIGW, pubSubnetsCarrier []string) *gomock.Call {
-	routes := []*ec2.RouteTable{}
+func stubMockDescribeRouteTablesWithWavelength(m *mocks.MockEC2APIMockRecorder, privSubnets, pubSubnetsIGW, pubSubnetsCarrier []string) *gomock.Call {
+	routes := []types.RouteTable{}
 
 	// create public route table
-	pubTable := &ec2.RouteTable{
-		Routes: []*ec2.Route{
+	pubTable := types.RouteTable{
+		Routes: []types.Route{
 			{
 				DestinationCidrBlock: aws.String("0.0.0.0/0"),
 				GatewayId:            aws.String("igw-0"),
@@ -4749,15 +4974,15 @@ func stubMockDescribeRouteTablesWithContextWithWavelength(m *mocks.MockEC2APIMoc
 		RouteTableId: aws.String("rtb-public"),
 	}
 	for _, sub := range pubSubnetsIGW {
-		pubTable.Associations = append(pubTable.Associations, &ec2.RouteTableAssociation{
+		pubTable.Associations = append(pubTable.Associations, types.RouteTableAssociation{
 			SubnetId: aws.String(sub),
 		})
 	}
 	routes = append(routes, pubTable)
 
 	// create public carrier route table
-	pubCarrierTable := &ec2.RouteTable{
-		Routes: []*ec2.Route{
+	pubCarrierTable := types.RouteTable{
+		Routes: []types.Route{
 			{
 				DestinationCidrBlock: aws.String("0.0.0.0/0"),
 				CarrierGatewayId:     aws.String("cagw-0"),
@@ -4766,15 +4991,15 @@ func stubMockDescribeRouteTablesWithContextWithWavelength(m *mocks.MockEC2APIMoc
 		RouteTableId: aws.String("rtb-carrier"),
 	}
 	for _, sub := range pubSubnetsCarrier {
-		pubCarrierTable.Associations = append(pubCarrierTable.Associations, &ec2.RouteTableAssociation{
+		pubCarrierTable.Associations = append(pubCarrierTable.Associations, types.RouteTableAssociation{
 			SubnetId: aws.String(sub),
 		})
 	}
 	routes = append(routes, pubCarrierTable)
 
 	// create private route table
-	privTable := &ec2.RouteTable{
-		Routes: []*ec2.Route{
+	privTable := types.RouteTable{
+		Routes: []types.Route{
 			{
 				DestinationCidrBlock: aws.String("10.0.11.0/24"),
 				GatewayId:            aws.String("vpc-natgw-1a"),
@@ -4783,28 +5008,28 @@ func stubMockDescribeRouteTablesWithContextWithWavelength(m *mocks.MockEC2APIMoc
 		RouteTableId: aws.String("rtb-private"),
 	}
 	for _, sub := range privSubnets {
-		privTable.Associations = append(privTable.Associations, &ec2.RouteTableAssociation{
+		privTable.Associations = append(privTable.Associations, types.RouteTableAssociation{
 			SubnetId: aws.String(sub),
 		})
 	}
 	routes = append(routes, privTable)
 
-	return m.DescribeRouteTablesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
+	return m.DescribeRouteTables(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeRouteTablesInput{})).
 		Return(&ec2.DescribeRouteTablesOutput{
 			RouteTables: routes,
 		}, nil)
 }
 
-func stubMockDescribeSubnetsWithContext(m *mocks.MockEC2APIMockRecorder, out *ec2.DescribeSubnetsOutput, filterKey, filterValue string) *gomock.Call {
-	return m.DescribeSubnetsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
-		Filters: []*ec2.Filter{
+func stubMockDescribeSubnets(m *mocks.MockEC2APIMockRecorder, out *ec2.DescribeSubnetsOutput, filterKey, filterValue string) *gomock.Call {
+	return m.DescribeSubnets(context.TODO(), gomock.Eq(&ec2.DescribeSubnetsInput{
+		Filters: []types.Filter{
 			{
 				Name:   aws.String("state"),
-				Values: []*string{aws.String("pending"), aws.String("available")},
+				Values: []string{"pending", "available"},
 			},
 			{
 				Name:   aws.String(filterKey),
-				Values: []*string{aws.String(filterValue)},
+				Values: []string{filterValue},
 			},
 		},
 	})).
@@ -4812,8 +5037,8 @@ func stubMockDescribeSubnetsWithContext(m *mocks.MockEC2APIMockRecorder, out *ec
 }
 
 func stubMockDescribeSubnetsWithContextUnmanaged(m *mocks.MockEC2APIMockRecorder) *gomock.Call {
-	return stubMockDescribeSubnetsWithContext(m, &ec2.DescribeSubnetsOutput{
-		Subnets: []*ec2.Subnet{
+	return stubMockDescribeSubnets(m, &ec2.DescribeSubnetsOutput{
+		Subnets: []types.Subnet{
 			{SubnetId: aws.String("subnet-az-1a-private"), AvailabilityZone: aws.String("us-east-1a")},
 			{SubnetId: aws.String("subnet-az-1a-public"), AvailabilityZone: aws.String("us-east-1a")},
 			{SubnetId: aws.String("subnet-lz-1a-private"), AvailabilityZone: aws.String("us-east-1-nyc-1a")},
@@ -4825,32 +5050,32 @@ func stubMockDescribeSubnetsWithContextUnmanaged(m *mocks.MockEC2APIMockRecorder
 }
 
 func stubMockDescribeSubnetsWithContextManaged(m *mocks.MockEC2APIMockRecorder) *gomock.Call {
-	return stubMockDescribeSubnetsWithContext(m, &ec2.DescribeSubnetsOutput{}, "vpc-id", subnetsVPCID)
+	return stubMockDescribeSubnets(m, &ec2.DescribeSubnetsOutput{}, "vpc-id", subnetsVPCID)
 }
 
-func stubMockDescribeNatGatewaysPagesWithContext(m *mocks.MockEC2APIMockRecorder) {
-	m.DescribeNatGatewaysPagesWithContext(context.TODO(),
+func stubMockDescribeNatGateways(m *mocks.MockEC2APIMockRecorder) {
+	m.DescribeNatGateways(context.TODO(),
 		gomock.Eq(&ec2.DescribeNatGatewaysInput{
-			Filter: []*ec2.Filter{
-				{Name: aws.String("vpc-id"), Values: []*string{aws.String(subnetsVPCID)}},
-				{Name: aws.String("state"), Values: []*string{aws.String("pending"), aws.String("available")}},
+			Filter: []types.Filter{
+				{Name: aws.String("vpc-id"), Values: []string{subnetsVPCID}},
+				{Name: aws.String("state"), Values: []string{"pending", "available"}},
 			},
 		}),
-		gomock.Any()).Return(nil)
+		gomock.Any()).Return(&ec2.DescribeNatGatewaysOutput{}, nil)
 }
 
 func stubMockModifySubnetAttributeWithContext(m *mocks.MockEC2APIMockRecorder, name string) *gomock.Call {
-	return m.ModifySubnetAttributeWithContext(context.TODO(), &ec2.ModifySubnetAttributeInput{
-		MapPublicIpOnLaunch: &ec2.AttributeBooleanValue{Value: aws.Bool(true)},
+	return m.ModifySubnetAttribute(context.TODO(), &ec2.ModifySubnetAttributeInput{
+		MapPublicIpOnLaunch: &types.AttributeBooleanValue{Value: aws.Bool(true)},
 		SubnetId:            aws.String(name),
 	}).
 		Return(&ec2.ModifySubnetAttributeOutput{}, nil)
 }
 
 func stubMockDescribeAvailabilityZonesWithContextAllZones(m *mocks.MockEC2APIMockRecorder) {
-	m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+	m.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 		Return(&ec2.DescribeAvailabilityZonesOutput{
-			AvailabilityZones: []*ec2.AvailabilityZone{
+			AvailabilityZones: []types.AvailabilityZone{
 				{
 					ZoneName:       aws.String("us-east-1a"),
 					ZoneType:       aws.String("availability-zone"),
@@ -4870,8 +5095,8 @@ func stubMockDescribeAvailabilityZonesWithContextAllZones(m *mocks.MockEC2APIMoc
 		}, nil).AnyTimes()
 }
 
-func stubMockDescribeAvailabilityZonesWithContextCustomZones(m *mocks.MockEC2APIMockRecorder, zones []*ec2.AvailabilityZone) *gomock.Call {
-	return m.DescribeAvailabilityZonesWithContext(context.TODO(), gomock.Any()).
+func stubMockDescribeAvailabilityZonesWithContextCustomZones(m *mocks.MockEC2APIMockRecorder, zones []types.AvailabilityZone) *gomock.Call {
+	return m.DescribeAvailabilityZones(context.TODO(), gomock.Any()).
 		Return(&ec2.DescribeAvailabilityZonesOutput{
 			AvailabilityZones: zones,
 		}, nil).AnyTimes()
diff --git a/pkg/cloud/services/network/vpc_test.go b/pkg/cloud/services/network/vpc_test.go
index 403707b8e..70be9c414 100644
--- a/pkg/cloud/services/network/vpc_test.go
+++ b/pkg/cloud/services/network/vpc_test.go
@@ -20,10 +20,11 @@ import (
 	"context"
 	"testing"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/golang/mock/gomock"
 	. "github.com/onsi/gomega"
 	"github.com/pkg/errors"
@@ -42,11 +43,11 @@ func describeVpcAttributeTrue(_ context.Context, input *ec2.DescribeVpcAttribute
 	result := &ec2.DescribeVpcAttributeOutput{
 		VpcId: input.VpcId,
 	}
-	switch aws.StringValue(input.Attribute) {
-	case "enableDnsHostnames":
-		result.EnableDnsHostnames = &ec2.AttributeBooleanValue{Value: aws.Bool(true)}
-	case "enableDnsSupport":
-		result.EnableDnsSupport = &ec2.AttributeBooleanValue{Value: aws.Bool(true)}
+	switch input.Attribute {
+	case types.VpcAttributeNameEnableDnsHostnames:
+		result.EnableDnsHostnames = &types.AttributeBooleanValue{Value: aws.Bool(true)}
+	case types.VpcAttributeNameEnableDnsSupport:
+		result.EnableDnsSupport = &types.AttributeBooleanValue{Value: aws.Bool(true)}
 	}
 	return result, nil
 }
@@ -55,11 +56,11 @@ func describeVpcAttributeFalse(_ context.Context, input *ec2.DescribeVpcAttribut
 	result := &ec2.DescribeVpcAttributeOutput{
 		VpcId: input.VpcId,
 	}
-	switch aws.StringValue(input.Attribute) {
-	case "enableDnsHostnames":
-		result.EnableDnsHostnames = &ec2.AttributeBooleanValue{Value: aws.Bool(false)}
-	case "enableDnsSupport":
-		result.EnableDnsSupport = &ec2.AttributeBooleanValue{Value: aws.Bool(false)}
+	switch input.Attribute {
+	case types.VpcAttributeNameEnableDnsHostnames:
+		result.EnableDnsHostnames = &types.AttributeBooleanValue{Value: aws.Bool(false)}
+	case types.VpcAttributeNameEnableDnsSupport:
+		result.EnableDnsSupport = &types.AttributeBooleanValue{Value: aws.Bool(false)}
 	}
 	return result, nil
 }
@@ -67,7 +68,7 @@ func describeVpcAttributeFalse(_ context.Context, input *ec2.DescribeVpcAttribut
 func TestReconcileVPC(t *testing.T) {
 	usageLimit := 3
 	selection := infrav1.AZSelectionSchemeOrdered
-	managedVPCTags := []*ec2.Tag{
+	managedVPCTags := []types.Tag{
 		{
 			Key:   aws.String("sigs.k8s.io/cluster-api-provider-aws/role"),
 			Value: aws.String("common"),
@@ -106,20 +107,20 @@ func TestReconcileVPC(t *testing.T) {
 			},
 			wantErrContaining: nil,
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeVpcsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeVpcsInput{
-					VpcIds: []*string{
-						aws.String("vpc-exists"),
+				m.DescribeVpcs(context.TODO(), gomock.Eq(&ec2.DescribeVpcsInput{
+					VpcIds: []string{
+						"vpc-exists",
 					},
-					Filters: []*ec2.Filter{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: aws.StringSlice([]string{ec2.VpcStatePending, ec2.VpcStateAvailable}),
+							Values: []string{string(types.VpcStatePending), string(types.VpcStateAvailable)},
 						},
 					},
 				})).Return(&ec2.DescribeVpcsOutput{
-					Vpcs: []*ec2.Vpc{
+					Vpcs: []types.Vpc{
 						{
-							State:     aws.String("available"),
+							State:     types.VpcStateAvailable,
 							VpcId:     aws.String("vpc-exists"),
 							CidrBlock: aws.String("10.0.0.0/8"),
 							Tags:      managedVPCTags,
@@ -127,7 +128,7 @@ func TestReconcileVPC(t *testing.T) {
 					},
 				}, nil)
 
-				m.DescribeVpcAttributeWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcAttributeInput{})).
+				m.DescribeVpcAttribute(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcAttributeInput{})).
 					DoAndReturn(describeVpcAttributeTrue).AnyTimes()
 			},
 		},
@@ -151,29 +152,29 @@ func TestReconcileVPC(t *testing.T) {
 			},
 			wantErrContaining: nil,
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeVpcsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeVpcsInput{
-					VpcIds: []*string{
-						aws.String("vpc-exists"),
+				m.DescribeVpcs(context.TODO(), gomock.Eq(&ec2.DescribeVpcsInput{
+					VpcIds: []string{
+						"vpc-exists",
 					},
-					Filters: []*ec2.Filter{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: aws.StringSlice([]string{ec2.VpcStatePending, ec2.VpcStateAvailable}),
+							Values: []string{string(types.VpcStatePending), string(types.VpcStateAvailable)},
 						},
 					},
 				})).Return(&ec2.DescribeVpcsOutput{
-					Vpcs: []*ec2.Vpc{
+					Vpcs: []types.Vpc{
 						{
-							State:     aws.String("available"),
+							State:     types.VpcStateAvailable,
 							VpcId:     aws.String("vpc-exists"),
 							CidrBlock: aws.String("10.0.0.0/8"),
 							Tags:      managedVPCTags,
 						},
 					},
 				}, nil)
-				m.CreateTagsWithContext(context.TODO(), &ec2.CreateTagsInput{
-					Resources: aws.StringSlice([]string{"vpc-exists"}),
-					Tags: []*ec2.Tag{
+				m.CreateTags(context.TODO(), &ec2.CreateTagsInput{
+					Resources: []string{"vpc-exists"},
+					Tags: []types.Tag{
 						{
 							Key:   aws.String("Name"),
 							Value: aws.String("test-cluster-vpc"),
@@ -192,7 +193,7 @@ func TestReconcileVPC(t *testing.T) {
 						},
 					},
 				})
-				m.DescribeVpcAttributeWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcAttributeInput{})).
+				m.DescribeVpcAttribute(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcAttributeInput{})).
 					DoAndReturn(describeVpcAttributeTrue).AnyTimes()
 			},
 		},
@@ -212,27 +213,27 @@ func TestReconcileVPC(t *testing.T) {
 				AvailabilityZoneSelection:  &selection,
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				describeVPCByNameCall := m.DescribeVpcsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeVpcsInput{
-					Filters: []*ec2.Filter{
+				describeVPCByNameCall := m.DescribeVpcs(context.TODO(), gomock.Eq(&ec2.DescribeVpcsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("tag:Name"),
-							Values: aws.StringSlice([]string{"test-cluster-vpc"}),
+							Values: []string{"test-cluster-vpc"},
 						},
 					},
-				})).Return(&ec2.DescribeVpcsOutput{Vpcs: []*ec2.Vpc{}}, nil)
-				m.CreateVpcWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateVpcInput{})).After(describeVPCByNameCall).Return(&ec2.CreateVpcOutput{
-					Vpc: &ec2.Vpc{
-						State:     aws.String("available"),
+				})).Return(&ec2.DescribeVpcsOutput{Vpcs: []types.Vpc{}}, nil)
+				m.CreateVpc(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateVpcInput{})).After(describeVPCByNameCall).Return(&ec2.CreateVpcOutput{
+					Vpc: &types.Vpc{
+						State:     types.VpcStateAvailable,
 						VpcId:     aws.String("vpc-new"),
 						CidrBlock: aws.String("10.1.0.0/16"),
 						Tags:      managedVPCTags,
 					},
 				}, nil)
 
-				m.DescribeVpcAttributeWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcAttributeInput{})).
+				m.DescribeVpcAttribute(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcAttributeInput{})).
 					DoAndReturn(describeVpcAttributeFalse).MinTimes(1)
 
-				m.ModifyVpcAttributeWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.ModifyVpcAttributeInput{})).Return(&ec2.ModifyVpcAttributeOutput{}, nil).Times(2)
+				m.ModifyVpcAttribute(context.TODO(), gomock.AssignableToTypeOf(&ec2.ModifyVpcAttributeInput{})).Return(&ec2.ModifyVpcAttributeOutput{}, nil).Times(2)
 			},
 		},
 		{
@@ -259,33 +260,33 @@ func TestReconcileVPC(t *testing.T) {
 				AvailabilityZoneSelection:  &selection,
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeVpcsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{
-					VpcIds: aws.StringSlice([]string{"vpc-new"}),
+				m.DescribeVpcs(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{
+					VpcIds: []string{"vpc-new"},
 				})).Return(&ec2.DescribeVpcsOutput{
-					Vpcs: []*ec2.Vpc{
+					Vpcs: []types.Vpc{
 						{
 							CidrBlock: aws.String("10.1.0.0/16"),
-							Ipv6CidrBlockAssociationSet: []*ec2.VpcIpv6CidrBlockAssociation{
+							Ipv6CidrBlockAssociationSet: []types.VpcIpv6CidrBlockAssociation{
 								{
 									AssociationId: aws.String("amazon"),
 									Ipv6CidrBlock: aws.String("2001:db8:1234:1a03::/56"),
-									Ipv6CidrBlockState: &ec2.VpcCidrBlockState{
-										State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated),
+									Ipv6CidrBlockState: &types.VpcCidrBlockState{
+										State: types.VpcCidrBlockStateCodeAssociated,
 									},
 									Ipv6Pool: aws.String("amazon"),
 								},
 							},
-							State: aws.String("available"),
+							State: types.VpcStateAvailable,
 							Tags:  managedVPCTags,
 							VpcId: aws.String("vpc-new"),
 						},
 					},
 				}, nil)
 
-				m.DescribeVpcAttributeWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcAttributeInput{})).
+				m.DescribeVpcAttribute(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcAttributeInput{})).
 					DoAndReturn(describeVpcAttributeFalse).MinTimes(1)
 
-				m.ModifyVpcAttributeWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.ModifyVpcAttributeInput{})).Return(&ec2.ModifyVpcAttributeOutput{}, nil).Times(2)
+				m.ModifyVpcAttribute(context.TODO(), gomock.AssignableToTypeOf(&ec2.ModifyVpcAttributeInput{})).Return(&ec2.ModifyVpcAttributeOutput{}, nil).Times(2)
 			},
 		},
 		{
@@ -315,31 +316,31 @@ func TestReconcileVPC(t *testing.T) {
 				AvailabilityZoneSelection:  &selection,
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				describeVPCByNameCall := m.DescribeVpcsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeVpcsInput{
-					Filters: []*ec2.Filter{
+				describeVPCByNameCall := m.DescribeVpcs(context.TODO(), gomock.Eq(&ec2.DescribeVpcsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("tag:Name"),
-							Values: aws.StringSlice([]string{"test-cluster-vpc"}),
+							Values: []string{"test-cluster-vpc"},
 						},
 					},
-				})).Return(&ec2.DescribeVpcsOutput{Vpcs: []*ec2.Vpc{}}, nil)
-				m.CreateVpcWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateVpcInput{
+				})).Return(&ec2.DescribeVpcsOutput{Vpcs: []types.Vpc{}}, nil)
+				m.CreateVpc(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateVpcInput{
 					AmazonProvidedIpv6CidrBlock: aws.Bool(false),
 					Ipv6Pool:                    aws.String("my-pool"),
 					Ipv6CidrBlock:               aws.String("2001:db8:1234:1a03::/56"),
 				})).After(describeVPCByNameCall).Return(&ec2.CreateVpcOutput{
-					Vpc: &ec2.Vpc{
-						State:     aws.String("available"),
+					Vpc: &types.Vpc{
+						State:     types.VpcStateAvailable,
 						VpcId:     aws.String("vpc-new"),
 						CidrBlock: aws.String("10.1.0.0/16"),
 						Tags:      managedVPCTags,
 					},
 				}, nil)
 
-				m.DescribeVpcAttributeWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcAttributeInput{})).
+				m.DescribeVpcAttribute(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcAttributeInput{})).
 					DoAndReturn(describeVpcAttributeFalse).MinTimes(1)
 
-				m.ModifyVpcAttributeWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.ModifyVpcAttributeInput{})).Return(&ec2.ModifyVpcAttributeOutput{}, nil).Times(2)
+				m.ModifyVpcAttribute(context.TODO(), gomock.AssignableToTypeOf(&ec2.ModifyVpcAttributeInput{})).Return(&ec2.ModifyVpcAttributeOutput{}, nil).Times(2)
 			},
 		},
 		{
@@ -352,8 +353,8 @@ func TestReconcileVPC(t *testing.T) {
 			wantErrContaining: aws.String("nope"),
 			want:              nil,
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeVpcsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{
-					VpcIds: aws.StringSlice([]string{"vpc-new"}),
+				m.DescribeVpcs(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{
+					VpcIds: []string{"vpc-new"},
 				})).Return(nil, errors.New("nope"))
 			},
 		},
@@ -377,18 +378,18 @@ func TestReconcileVPC(t *testing.T) {
 				AvailabilityZoneSelection:  &selection,
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeVpcsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
-					Vpcs: []*ec2.Vpc{
+				m.DescribeVpcs(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
+					Vpcs: []types.Vpc{
 						{
-							State:     aws.String("available"),
+							State:     types.VpcStateAvailable,
 							VpcId:     aws.String("unmanaged-vpc-exists"),
 							CidrBlock: aws.String("10.0.0.0/8"),
-							Ipv6CidrBlockAssociationSet: []*ec2.VpcIpv6CidrBlockAssociation{
+							Ipv6CidrBlockAssociationSet: []types.VpcIpv6CidrBlockAssociation{
 								{
 									AssociationId: aws.String("amazon"),
 									Ipv6CidrBlock: aws.String("2001:db8:1234:1a03::/56"),
-									Ipv6CidrBlockState: &ec2.VpcCidrBlockState{
-										State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated),
+									Ipv6CidrBlockState: &types.VpcCidrBlockState{
+										State: types.VpcCidrBlockStateCodeAssociated,
 									},
 									Ipv6Pool: aws.String("my-pool"),
 								},
@@ -403,14 +404,14 @@ func TestReconcileVPC(t *testing.T) {
 			input:             &infrav1.VPCSpec{ID: "vpc-exists", AvailabilityZoneUsageLimit: &usageLimit, AvailabilityZoneSelection: &selection},
 			wantErrContaining: aws.String("VPC resource is missing in AWS"),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeVpcsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeVpcsInput{
-					VpcIds: []*string{
-						aws.String("vpc-exists"),
+				m.DescribeVpcs(context.TODO(), gomock.Eq(&ec2.DescribeVpcsInput{
+					VpcIds: []string{
+						"vpc-exists",
 					},
-					Filters: []*ec2.Filter{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: aws.StringSlice([]string{ec2.VpcStatePending, ec2.VpcStateAvailable}),
+							Values: []string{string(types.VpcStatePending), string(types.VpcStateAvailable)},
 						},
 					},
 				})).Return(nil, awserr.New("404", "http not found err", errors.New("err")))
@@ -427,10 +428,10 @@ func TestReconcileVPC(t *testing.T) {
 				AvailabilityZoneSelection:  &selection,
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeVpcsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
-					Vpcs: []*ec2.Vpc{
+				m.DescribeVpcs(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
+					Vpcs: []types.Vpc{
 						{
-							State:     aws.String("available"),
+							State:     types.VpcStateAvailable,
 							VpcId:     aws.String("unmanaged-vpc-exists"),
 							CidrBlock: aws.String("10.0.0.0/8"),
 						},
@@ -453,18 +454,18 @@ func TestReconcileVPC(t *testing.T) {
 				AvailabilityZoneSelection:  &selection,
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeVpcsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
-					Vpcs: []*ec2.Vpc{
+				m.DescribeVpcs(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
+					Vpcs: []types.Vpc{
 						{
-							State:     aws.String("available"),
+							State:     types.VpcStateAvailable,
 							VpcId:     aws.String("unmanaged-vpc-exists"),
 							CidrBlock: aws.String("10.0.0.0/8"),
 							Tags:      managedVPCTags,
 						},
 					},
 				}, nil)
-				m.DescribeVpcAttributeWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcAttributeInput{})).Return(nil, awserr.New("InvalidVpcID.NotFound", "not found", nil))
-				m.DescribeVpcAttributeWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcAttributeInput{})).
+				m.DescribeVpcAttribute(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcAttributeInput{})).Return(nil, awserr.New("InvalidVpcID.NotFound", "not found", nil))
+				m.DescribeVpcAttribute(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcAttributeInput{})).
 					DoAndReturn(describeVpcAttributeTrue).AnyTimes()
 			},
 		},
@@ -473,27 +474,27 @@ func TestReconcileVPC(t *testing.T) {
 			input:             &infrav1.VPCSpec{ID: "managed-vpc-exists", AvailabilityZoneUsageLimit: &usageLimit, AvailabilityZoneSelection: &selection},
 			wantErrContaining: aws.String("failed to set vpc attributes"),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeVpcsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeVpcsInput{
-					VpcIds: []*string{
-						aws.String("managed-vpc-exists"),
+				m.DescribeVpcs(context.TODO(), gomock.Eq(&ec2.DescribeVpcsInput{
+					VpcIds: []string{
+						"managed-vpc-exists",
 					},
-					Filters: []*ec2.Filter{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("state"),
-							Values: aws.StringSlice([]string{ec2.VpcStatePending, ec2.VpcStateAvailable}),
+							Values: []string{string(types.VpcStatePending), string(types.VpcStateAvailable)},
 						},
 					},
 				})).Return(&ec2.DescribeVpcsOutput{
-					Vpcs: []*ec2.Vpc{
+					Vpcs: []types.Vpc{
 						{
-							State:     aws.String("available"),
+							State:     types.VpcStateAvailable,
 							VpcId:     aws.String("unmanaged-vpc-exists"),
 							CidrBlock: aws.String("10.0.0.0/8"),
 							Tags:      managedVPCTags,
 						},
 					},
 				}, nil)
-				m.DescribeVpcAttributeWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcAttributeInput{})).AnyTimes().Return(nil, awserrors.NewFailedDependency("failed dependency"))
+				m.DescribeVpcAttribute(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcAttributeInput{})).AnyTimes().Return(nil, awserrors.NewFailedDependency("failed dependency"))
 			},
 		},
 		{
@@ -501,15 +502,15 @@ func TestReconcileVPC(t *testing.T) {
 			input:             &infrav1.VPCSpec{AvailabilityZoneUsageLimit: &usageLimit, AvailabilityZoneSelection: &selection},
 			wantErrContaining: aws.String("failed to create new managed VPC"),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				describeVPCByNameCall := m.DescribeVpcsWithContext(context.TODO(), gomock.Eq(&ec2.DescribeVpcsInput{
-					Filters: []*ec2.Filter{
+				describeVPCByNameCall := m.DescribeVpcs(context.TODO(), gomock.Eq(&ec2.DescribeVpcsInput{
+					Filters: []types.Filter{
 						{
 							Name:   aws.String("tag:Name"),
-							Values: aws.StringSlice([]string{"test-cluster-vpc"}),
+							Values: []string{"test-cluster-vpc"},
 						},
 					},
-				})).Return(&ec2.DescribeVpcsOutput{Vpcs: []*ec2.Vpc{}}, nil)
-				m.CreateVpcWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateVpcInput{})).After(describeVPCByNameCall).Return(nil, awserrors.NewFailedDependency("failed dependency"))
+				})).Return(&ec2.DescribeVpcsOutput{Vpcs: []types.Vpc{}}, nil)
+				m.CreateVpc(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateVpcInput{})).After(describeVPCByNameCall).Return(nil, awserrors.NewFailedDependency("failed dependency"))
 			},
 		},
 		{
@@ -517,8 +518,8 @@ func TestReconcileVPC(t *testing.T) {
 			input:             &infrav1.VPCSpec{ID: "managed-vpc-exists", AvailabilityZoneUsageLimit: &usageLimit, AvailabilityZoneSelection: &selection},
 			wantErrContaining: aws.String("VPC resource is missing in AWS"),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeVpcsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
-					Vpcs: []*ec2.Vpc{},
+				m.DescribeVpcs(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
+					Vpcs: []types.Vpc{},
 				}, nil)
 			},
 		},
@@ -527,8 +528,8 @@ func TestReconcileVPC(t *testing.T) {
 			input:             &infrav1.VPCSpec{ID: "managed-vpc-exists", AvailabilityZoneUsageLimit: &usageLimit, AvailabilityZoneSelection: &selection},
 			wantErrContaining: aws.String("Only one VPC per cluster name is supported"),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeVpcsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
-					Vpcs: []*ec2.Vpc{
+				m.DescribeVpcs(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
+					Vpcs: []types.Vpc{
 						{
 							VpcId: aws.String("vpc_1"),
 						},
@@ -544,11 +545,11 @@ func TestReconcileVPC(t *testing.T) {
 			input:             &infrav1.VPCSpec{ID: "managed-vpc-exists", AvailabilityZoneUsageLimit: &usageLimit, AvailabilityZoneSelection: &selection},
 			wantErrContaining: aws.String("could not find available or pending vpc"),
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeVpcsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
-					Vpcs: []*ec2.Vpc{
+				m.DescribeVpcs(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcsInput{})).Return(&ec2.DescribeVpcsOutput{
+					Vpcs: []types.Vpc{
 						{
 							VpcId: aws.String("vpc"),
-							State: aws.String("deleting"),
+							State: types.VpcState("deleting"),
 						},
 					},
 				}, nil)
@@ -607,7 +608,7 @@ func TestDeleteVPC(t *testing.T) {
 			},
 			wantErr: true,
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DeleteVpcWithContext(context.TODO(), gomock.Eq(&ec2.DeleteVpcInput{
+				m.DeleteVpc(context.TODO(), gomock.Eq(&ec2.DeleteVpcInput{
 					VpcId: aws.String("managed-vpc"),
 				})).Return(nil, awserrors.NewFailedDependency("failed dependency"))
 			},
@@ -620,7 +621,7 @@ func TestDeleteVPC(t *testing.T) {
 			},
 			wantErr: false,
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DeleteVpcWithContext(context.TODO(), gomock.Eq(&ec2.DeleteVpcInput{
+				m.DeleteVpc(context.TODO(), gomock.Eq(&ec2.DeleteVpcInput{
 					VpcId: aws.String("managed-vpc"),
 				})).Return(&ec2.DeleteVpcOutput{}, nil)
 			},
@@ -633,7 +634,7 @@ func TestDeleteVPC(t *testing.T) {
 			},
 			wantErr: false,
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DeleteVpcWithContext(context.TODO(), gomock.Eq(&ec2.DeleteVpcInput{
+				m.DeleteVpc(context.TODO(), gomock.Eq(&ec2.DeleteVpcInput{
 					VpcId: aws.String("managed-vpc"),
 				})).Return(nil, awserr.New("InvalidVpcID.NotFound", "not found", nil))
 			},
diff --git a/pkg/cloud/services/securitygroup/securitygroups_test.go b/pkg/cloud/services/securitygroup/securitygroups_test.go
index 4f39ac262..d0c161d33 100644
--- a/pkg/cloud/services/securitygroup/securitygroups_test.go
+++ b/pkg/cloud/services/securitygroup/securitygroups_test.go
@@ -22,10 +22,10 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/golang/mock/gomock"
 	. "github.com/onsi/gomega"
 	"github.com/pkg/errors"
@@ -94,14 +94,14 @@ func TestReconcileSecurityGroups(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSecurityGroupsWithContext(context.TODO(), &ec2.DescribeSecurityGroupsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSecurityGroups(context.TODO(), &ec2.DescribeSecurityGroupsInput{
+					Filters: []types.Filter{
 						filter.EC2.VPC("vpc-securitygroups"),
 						filter.EC2.SecurityGroupName("default"),
 					},
 				}).
 					Return(&ec2.DescribeSecurityGroupsOutput{
-						SecurityGroups: []*ec2.SecurityGroup{
+						SecurityGroups: []types.SecurityGroup{
 							{
 								Description: aws.String("default VPC security group"),
 								GroupName:   aws.String("default"),
@@ -109,25 +109,25 @@ func TestReconcileSecurityGroups(t *testing.T) {
 							},
 						},
 					}, nil)
-				m.RevokeSecurityGroupIngressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.RevokeSecurityGroupIngressInput{
+				m.RevokeSecurityGroupIngress(context.TODO(), gomock.AssignableToTypeOf(&ec2.RevokeSecurityGroupIngressInput{
 					GroupId: aws.String("sg-default"),
 				}))
 
-				m.RevokeSecurityGroupEgressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.RevokeSecurityGroupEgressInput{
+				m.RevokeSecurityGroupEgress(context.TODO(), gomock.AssignableToTypeOf(&ec2.RevokeSecurityGroupEgressInput{
 					GroupId: aws.String("sg-default"),
 				}))
 
-				m.DescribeSecurityGroupsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{})).
+				m.DescribeSecurityGroups(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{})).
 					Return(&ec2.DescribeSecurityGroupsOutput{}, nil)
 
-				securityGroupBastion := m.CreateSecurityGroupWithContext(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
+				securityGroupBastion := m.CreateSecurityGroup(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
 					VpcId:       aws.String("vpc-securitygroups"),
 					GroupName:   aws.String("test-cluster-bastion"),
 					Description: aws.String("Kubernetes cluster test-cluster: bastion"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("security-group"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSecurityGroup,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-bastion"),
@@ -146,20 +146,20 @@ func TestReconcileSecurityGroups(t *testing.T) {
 				})).
 					Return(&ec2.CreateSecurityGroupOutput{GroupId: aws.String("sg-bastion")}, nil)
 
-				m.AuthorizeSecurityGroupIngressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
+				m.AuthorizeSecurityGroupIngress(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
 					GroupId: aws.String("sg-bastion"),
 				})).
 					Return(&ec2.AuthorizeSecurityGroupIngressOutput{}, nil).
 					After(securityGroupBastion)
 
-				securityGroupAPIServerLb := m.CreateSecurityGroupWithContext(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
+				securityGroupAPIServerLb := m.CreateSecurityGroup(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
 					VpcId:       aws.String("vpc-securitygroups"),
 					GroupName:   aws.String("test-cluster-apiserver-lb"),
 					Description: aws.String("Kubernetes cluster test-cluster: apiserver-lb"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("security-group"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSecurityGroup,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-apiserver-lb"),
@@ -178,20 +178,20 @@ func TestReconcileSecurityGroups(t *testing.T) {
 				})).
 					Return(&ec2.CreateSecurityGroupOutput{GroupId: aws.String("sg-apiserver-lb")}, nil)
 
-				m.AuthorizeSecurityGroupIngressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
+				m.AuthorizeSecurityGroupIngress(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
 					GroupId: aws.String("sg-apiserver-lb"),
 				})).
 					Return(&ec2.AuthorizeSecurityGroupIngressOutput{}, nil).
 					After(securityGroupAPIServerLb)
 
-				m.CreateSecurityGroupWithContext(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
+				m.CreateSecurityGroup(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
 					VpcId:       aws.String("vpc-securitygroups"),
 					GroupName:   aws.String("test-cluster-lb"),
 					Description: aws.String("Kubernetes cluster test-cluster: lb"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("security-group"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSecurityGroup,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-lb"),
@@ -214,14 +214,14 @@ func TestReconcileSecurityGroups(t *testing.T) {
 				})).
 					Return(&ec2.CreateSecurityGroupOutput{GroupId: aws.String("sg-lb")}, nil)
 
-				securityGroupControl := m.CreateSecurityGroupWithContext(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
+				securityGroupControl := m.CreateSecurityGroup(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
 					VpcId:       aws.String("vpc-securitygroups"),
 					GroupName:   aws.String("test-cluster-controlplane"),
 					Description: aws.String("Kubernetes cluster test-cluster: controlplane"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("security-group"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSecurityGroup,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-controlplane"),
@@ -240,20 +240,20 @@ func TestReconcileSecurityGroups(t *testing.T) {
 				})).
 					Return(&ec2.CreateSecurityGroupOutput{GroupId: aws.String("sg-control")}, nil)
 
-				m.AuthorizeSecurityGroupIngressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
+				m.AuthorizeSecurityGroupIngress(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
 					GroupId: aws.String("sg-control"),
 				})).
 					Return(&ec2.AuthorizeSecurityGroupIngressOutput{}, nil).
 					After(securityGroupControl)
 
-				securityGroupNode := m.CreateSecurityGroupWithContext(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
+				securityGroupNode := m.CreateSecurityGroup(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
 					VpcId:       aws.String("vpc-securitygroups"),
 					GroupName:   aws.String("test-cluster-node"),
 					Description: aws.String("Kubernetes cluster test-cluster: node"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("security-group"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSecurityGroup,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-node"),
@@ -272,7 +272,7 @@ func TestReconcileSecurityGroups(t *testing.T) {
 				})).
 					Return(&ec2.CreateSecurityGroupOutput{GroupId: aws.String("sg-node")}, nil)
 
-				m.AuthorizeSecurityGroupIngressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
+				m.AuthorizeSecurityGroupIngress(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
 					GroupId: aws.String("sg-node"),
 				})).
 					Return(&ec2.AuthorizeSecurityGroupIngressOutput{}, nil).
@@ -311,17 +311,17 @@ func TestReconcileSecurityGroups(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSecurityGroupsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{})).
+				m.DescribeSecurityGroups(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{})).
 					Return(&ec2.DescribeSecurityGroupsOutput{}, nil)
 
-				securityGroupBastion := m.CreateSecurityGroupWithContext(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
+				securityGroupBastion := m.CreateSecurityGroup(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
 					VpcId:       aws.String("vpc-securitygroups"),
 					GroupName:   aws.String("test-cluster-bastion"),
 					Description: aws.String("Kubernetes cluster test-cluster: bastion"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("security-group"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSecurityGroup,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-bastion"),
@@ -340,20 +340,20 @@ func TestReconcileSecurityGroups(t *testing.T) {
 				})).
 					Return(&ec2.CreateSecurityGroupOutput{GroupId: aws.String("sg-bastion")}, nil)
 
-				m.AuthorizeSecurityGroupIngressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
+				m.AuthorizeSecurityGroupIngress(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
 					GroupId: aws.String("sg-bastion"),
 				})).
 					Return(&ec2.AuthorizeSecurityGroupIngressOutput{}, nil).
 					After(securityGroupBastion)
 
-				securityGroupAPIServerLb := m.CreateSecurityGroupWithContext(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
+				securityGroupAPIServerLb := m.CreateSecurityGroup(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
 					VpcId:       aws.String("vpc-securitygroups"),
 					GroupName:   aws.String("test-cluster-apiserver-lb"),
 					Description: aws.String("Kubernetes cluster test-cluster: apiserver-lb"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("security-group"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSecurityGroup,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-apiserver-lb"),
@@ -372,20 +372,20 @@ func TestReconcileSecurityGroups(t *testing.T) {
 				})).
 					Return(&ec2.CreateSecurityGroupOutput{GroupId: aws.String("sg-apiserver-lb")}, nil)
 
-				m.AuthorizeSecurityGroupIngressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
+				m.AuthorizeSecurityGroupIngress(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
 					GroupId: aws.String("sg-apiserver-lb"),
 				})).
 					Return(&ec2.AuthorizeSecurityGroupIngressOutput{}, nil).
 					After(securityGroupAPIServerLb)
 
-				lbSecurityGroup := m.CreateSecurityGroupWithContext(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
+				lbSecurityGroup := m.CreateSecurityGroup(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
 					VpcId:       aws.String("vpc-securitygroups"),
 					GroupName:   aws.String("test-cluster-lb"),
 					Description: aws.String("Kubernetes cluster test-cluster: lb"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("security-group"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSecurityGroup,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-lb"),
@@ -407,20 +407,20 @@ func TestReconcileSecurityGroups(t *testing.T) {
 					},
 				})).Return(&ec2.CreateSecurityGroupOutput{GroupId: aws.String("sg-lb")}, nil)
 
-				m.AuthorizeSecurityGroupIngressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
+				m.AuthorizeSecurityGroupIngress(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
 					GroupId: aws.String("sg-lb"),
 				})).
 					Return(&ec2.AuthorizeSecurityGroupIngressOutput{}, nil).
 					After(lbSecurityGroup)
 
-				securityGroupControl := m.CreateSecurityGroupWithContext(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
+				securityGroupControl := m.CreateSecurityGroup(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
 					VpcId:       aws.String("vpc-securitygroups"),
 					GroupName:   aws.String("test-cluster-controlplane"),
 					Description: aws.String("Kubernetes cluster test-cluster: controlplane"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("security-group"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSecurityGroup,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-controlplane"),
@@ -439,20 +439,20 @@ func TestReconcileSecurityGroups(t *testing.T) {
 				})).
 					Return(&ec2.CreateSecurityGroupOutput{GroupId: aws.String("sg-control")}, nil)
 
-				m.AuthorizeSecurityGroupIngressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
+				m.AuthorizeSecurityGroupIngress(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
 					GroupId: aws.String("sg-control"),
 				})).
 					Return(&ec2.AuthorizeSecurityGroupIngressOutput{}, nil).
 					After(securityGroupControl)
 
-				securityGroupNode := m.CreateSecurityGroupWithContext(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
+				securityGroupNode := m.CreateSecurityGroup(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
 					VpcId:       aws.String("vpc-securitygroups"),
 					GroupName:   aws.String("test-cluster-node"),
 					Description: aws.String("Kubernetes cluster test-cluster: node"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("security-group"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSecurityGroup,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-node"),
@@ -471,7 +471,7 @@ func TestReconcileSecurityGroups(t *testing.T) {
 				})).
 					Return(&ec2.CreateSecurityGroupOutput{GroupId: aws.String("sg-node")}, nil)
 
-				m.AuthorizeSecurityGroupIngressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
+				m.AuthorizeSecurityGroupIngress(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
 					GroupId: aws.String("sg-node"),
 				})).
 					Return(&ec2.AuthorizeSecurityGroupIngressOutput{}, nil).
@@ -510,9 +510,9 @@ func TestReconcileSecurityGroups(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSecurityGroupsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{})).
+				m.DescribeSecurityGroups(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{})).
 					Return(&ec2.DescribeSecurityGroupsOutput{
-						SecurityGroups: []*ec2.SecurityGroup{
+						SecurityGroups: []types.SecurityGroup{
 							{GroupId: aws.String("sg-bastion"), GroupName: aws.String("Bastion Security Group")},
 							{GroupId: aws.String("sg-apiserver-lb"), GroupName: aws.String("API load balancer Security Group")},
 							{GroupId: aws.String("sg-lb"), GroupName: aws.String("Load balancer Security Group")},
@@ -553,17 +553,17 @@ func TestReconcileSecurityGroups(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSecurityGroupsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{})).
+				m.DescribeSecurityGroups(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{})).
 					Return(&ec2.DescribeSecurityGroupsOutput{}, nil)
 
-				securityGroupBastion := m.CreateSecurityGroupWithContext(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
+				securityGroupBastion := m.CreateSecurityGroup(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
 					VpcId:       aws.String("vpc-securitygroups"),
 					GroupName:   aws.String("test-cluster-bastion"),
 					Description: aws.String("Kubernetes cluster test-cluster: bastion"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("security-group"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSecurityGroup,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-bastion"),
@@ -582,20 +582,20 @@ func TestReconcileSecurityGroups(t *testing.T) {
 				})).
 					Return(&ec2.CreateSecurityGroupOutput{GroupId: aws.String("sg-bastion")}, nil)
 
-				m.AuthorizeSecurityGroupIngressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
+				m.AuthorizeSecurityGroupIngress(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
 					GroupId: aws.String("sg-bastion"),
 				})).
 					Return(&ec2.AuthorizeSecurityGroupIngressOutput{}, nil).
 					After(securityGroupBastion)
 
-				securityGroupAPIServerLb := m.CreateSecurityGroupWithContext(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
+				securityGroupAPIServerLb := m.CreateSecurityGroup(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
 					VpcId:       aws.String("vpc-securitygroups"),
 					GroupName:   aws.String("test-cluster-apiserver-lb"),
 					Description: aws.String("Kubernetes cluster test-cluster: apiserver-lb"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("security-group"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSecurityGroup,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-apiserver-lb"),
@@ -614,20 +614,20 @@ func TestReconcileSecurityGroups(t *testing.T) {
 				})).
 					Return(&ec2.CreateSecurityGroupOutput{GroupId: aws.String("sg-apiserver-lb")}, nil)
 
-				m.AuthorizeSecurityGroupIngressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
+				m.AuthorizeSecurityGroupIngress(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
 					GroupId: aws.String("sg-apiserver-lb"),
 				})).
 					Return(&ec2.AuthorizeSecurityGroupIngressOutput{}, nil).
 					After(securityGroupAPIServerLb)
 
-				lbSecurityGroup := m.CreateSecurityGroupWithContext(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
+				lbSecurityGroup := m.CreateSecurityGroup(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
 					VpcId:       aws.String("vpc-securitygroups"),
 					GroupName:   aws.String("test-cluster-lb"),
 					Description: aws.String("Kubernetes cluster test-cluster: lb"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("security-group"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSecurityGroup,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-lb"),
@@ -649,20 +649,20 @@ func TestReconcileSecurityGroups(t *testing.T) {
 					},
 				})).Return(&ec2.CreateSecurityGroupOutput{GroupId: aws.String("sg-lb")}, nil)
 
-				m.AuthorizeSecurityGroupIngressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
+				m.AuthorizeSecurityGroupIngress(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
 					GroupId: aws.String("sg-lb"),
 				})).
 					Return(&ec2.AuthorizeSecurityGroupIngressOutput{}, nil).
 					After(lbSecurityGroup)
 
-				securityGroupControl := m.CreateSecurityGroupWithContext(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
+				securityGroupControl := m.CreateSecurityGroup(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
 					VpcId:       aws.String("vpc-securitygroups"),
 					GroupName:   aws.String("test-cluster-controlplane"),
 					Description: aws.String("Kubernetes cluster test-cluster: controlplane"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("security-group"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSecurityGroup,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-controlplane"),
@@ -681,20 +681,20 @@ func TestReconcileSecurityGroups(t *testing.T) {
 				})).
 					Return(&ec2.CreateSecurityGroupOutput{GroupId: aws.String("sg-control")}, nil)
 
-				m.AuthorizeSecurityGroupIngressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
+				m.AuthorizeSecurityGroupIngress(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
 					GroupId: aws.String("sg-control"),
 				})).
 					Return(&ec2.AuthorizeSecurityGroupIngressOutput{}, nil).
 					After(securityGroupControl)
 
-				m.CreateSecurityGroupWithContext(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
+				m.CreateSecurityGroup(context.TODO(), gomock.Eq(&ec2.CreateSecurityGroupInput{
 					VpcId:       aws.String("vpc-securitygroups"),
 					GroupName:   aws.String("test-cluster-node"),
 					Description: aws.String("Kubernetes cluster test-cluster: node"),
-					TagSpecifications: []*ec2.TagSpecification{
+					TagSpecifications: []types.TagSpecification{
 						{
-							ResourceType: aws.String("security-group"),
-							Tags: []*ec2.Tag{
+							ResourceType: types.ResourceTypeSecurityGroup,
+							Tags: []types.Tag{
 								{
 									Key:   aws.String("Name"),
 									Value: aws.String("test-cluster-node"),
@@ -749,9 +749,9 @@ func TestReconcileSecurityGroups(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSecurityGroupsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{})).
+				m.DescribeSecurityGroups(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{})).
 					Return(&ec2.DescribeSecurityGroupsOutput{
-						SecurityGroups: []*ec2.SecurityGroup{
+						SecurityGroups: []types.SecurityGroup{
 							{GroupId: aws.String("sg-bastion"), GroupName: aws.String("Bastion Security Group")},
 							{GroupId: aws.String("sg-apiserver-lb"), GroupName: aws.String("API load balancer Security Group")},
 							{GroupId: aws.String("sg-lb"), GroupName: aws.String("Load balancer Security Group")},
@@ -791,14 +791,14 @@ func TestReconcileSecurityGroups(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSecurityGroupsWithContext(context.TODO(), &ec2.DescribeSecurityGroupsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSecurityGroups(context.TODO(), &ec2.DescribeSecurityGroupsInput{
+					Filters: []types.Filter{
 						filter.EC2.VPC("vpc-securitygroups"),
 						filter.EC2.SecurityGroupName("default"),
 					},
 				}).
 					Return(&ec2.DescribeSecurityGroupsOutput{
-						SecurityGroups: []*ec2.SecurityGroup{
+						SecurityGroups: []types.SecurityGroup{
 							{
 								Description: aws.String("default VPC security group"),
 								GroupName:   aws.String("default"),
@@ -807,25 +807,25 @@ func TestReconcileSecurityGroups(t *testing.T) {
 						},
 					}, nil)
 
-				m.RevokeSecurityGroupIngressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.RevokeSecurityGroupIngressInput{
+				m.RevokeSecurityGroupIngress(context.TODO(), gomock.AssignableToTypeOf(&ec2.RevokeSecurityGroupIngressInput{
 					GroupId: aws.String("sg-default"),
 				})).Return(&ec2.RevokeSecurityGroupIngressOutput{}, awserr.New("InvalidPermission.NotFound", "rules not found in security group", nil))
 
-				m.RevokeSecurityGroupEgressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.RevokeSecurityGroupEgressInput{
+				m.RevokeSecurityGroupEgress(context.TODO(), gomock.AssignableToTypeOf(&ec2.RevokeSecurityGroupEgressInput{
 					GroupId: aws.String("sg-default"),
 				})).Return(&ec2.RevokeSecurityGroupEgressOutput{}, awserr.New("InvalidPermission.NotFound", "rules not found in security group", nil))
 
-				m.DescribeSecurityGroupsWithContext(context.TODO(), &ec2.DescribeSecurityGroupsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSecurityGroups(context.TODO(), &ec2.DescribeSecurityGroupsInput{
+					Filters: []types.Filter{
 						filter.EC2.VPC("vpc-securitygroups"),
 						filter.EC2.Cluster("test-cluster"),
 					},
 				}).Return(&ec2.DescribeSecurityGroupsOutput{}, nil)
 
-				m.CreateSecurityGroupWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateSecurityGroupInput{})).
+				m.CreateSecurityGroup(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateSecurityGroupInput{})).
 					Return(&ec2.CreateSecurityGroupOutput{GroupId: aws.String("sg-node")}, nil).AnyTimes()
 
-				m.AuthorizeSecurityGroupIngressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{})).
+				m.AuthorizeSecurityGroupIngress(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{})).
 					Return(&ec2.AuthorizeSecurityGroupIngressOutput{}, nil).AnyTimes()
 			},
 		},
@@ -858,14 +858,14 @@ func TestReconcileSecurityGroups(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSecurityGroupsWithContext(context.TODO(), &ec2.DescribeSecurityGroupsInput{
-					Filters: []*ec2.Filter{
+				m.DescribeSecurityGroups(context.TODO(), &ec2.DescribeSecurityGroupsInput{
+					Filters: []types.Filter{
 						filter.EC2.VPC("vpc-securitygroups"),
 						filter.EC2.SecurityGroupName("default"),
 					},
 				}).
 					Return(&ec2.DescribeSecurityGroupsOutput{
-						SecurityGroups: []*ec2.SecurityGroup{
+						SecurityGroups: []types.SecurityGroup{
 							{
 								Description: aws.String("default VPC security group"),
 								GroupName:   aws.String("default"),
@@ -874,12 +874,12 @@ func TestReconcileSecurityGroups(t *testing.T) {
 						},
 					}, nil)
 
-				m.RevokeSecurityGroupIngressWithContext(context.TODO(), gomock.Eq(&ec2.RevokeSecurityGroupIngressInput{
+				m.RevokeSecurityGroupIngress(context.TODO(), gomock.Eq(&ec2.RevokeSecurityGroupIngressInput{
 					GroupId: aws.String("sg-default"),
-					IpPermissions: []*ec2.IpPermission{
+					IpPermissions: []types.IpPermission{
 						{
 							IpProtocol: aws.String("-1"),
-							UserIdGroupPairs: []*ec2.UserIdGroupPair{
+							UserIdGroupPairs: []types.UserIdGroupPair{
 								{
 									GroupId: aws.String("sg-default"),
 								},
@@ -888,15 +888,15 @@ func TestReconcileSecurityGroups(t *testing.T) {
 					},
 				})).Times(1)
 
-				m.RevokeSecurityGroupEgressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.RevokeSecurityGroupEgressInput{
+				m.RevokeSecurityGroupEgress(context.TODO(), gomock.AssignableToTypeOf(&ec2.RevokeSecurityGroupEgressInput{
 					GroupId: aws.String("sg-default"),
 				}))
 
-				securityGroupBastion := &ec2.SecurityGroup{
+				securityGroupBastion := types.SecurityGroup{
 					Description: aws.String("Kubernetes cluster test-cluster: bastion"),
 					GroupName:   aws.String("test-cluster-bastion"),
 					GroupId:     aws.String("sg-bastion"),
-					Tags: []*ec2.Tag{
+					Tags: []types.Tag{
 						{
 							Key:   aws.String("Name"),
 							Value: aws.String("test-cluster-bastion"),
@@ -910,11 +910,11 @@ func TestReconcileSecurityGroups(t *testing.T) {
 					},
 				}
 
-				securityGroupLB := &ec2.SecurityGroup{
+				securityGroupLB := types.SecurityGroup{
 					Description: aws.String("Kubernetes cluster test-cluster: lb"),
 					GroupName:   aws.String("test-cluster-lb"),
 					GroupId:     aws.String("sg-lb"),
-					Tags: []*ec2.Tag{
+					Tags: []types.Tag{
 						{
 							Key:   aws.String("Name"),
 							Value: aws.String("test-cluster-lb"),
@@ -931,11 +931,11 @@ func TestReconcileSecurityGroups(t *testing.T) {
 					},
 				}
 
-				securityGroupAPIServerLB := &ec2.SecurityGroup{
+				securityGroupAPIServerLB := types.SecurityGroup{
 					Description: aws.String("Kubernetes cluster test-cluster: apiserver-lb"),
 					GroupName:   aws.String("test-cluster-apiserver-lb"),
 					GroupId:     aws.String("sg-apiserver-lb"),
-					Tags: []*ec2.Tag{
+					Tags: []types.Tag{
 						{
 							Key:   aws.String("Name"),
 							Value: aws.String("test-cluster-apiserver-lb"),
@@ -947,24 +947,24 @@ func TestReconcileSecurityGroups(t *testing.T) {
 							Value: aws.String("apiserver-lb"),
 						},
 					},
-					IpPermissions: []*ec2.IpPermission{
+					IpPermissions: []types.IpPermission{
 						{
-							FromPort:   aws.Int64(6443),
+							FromPort:   aws.Int32(6443),
 							IpProtocol: aws.String("tcp"),
-							IpRanges: []*ec2.IpRange{
+							IpRanges: []types.IpRange{
 								{
 									CidrIp:      aws.String("0.0.0.0/0"),
 									Description: aws.String("Kubernetes API"),
 								},
 							},
-							ToPort: aws.Int64(6443),
+							ToPort: aws.Int32(6443),
 						},
 						// Extra rule to be revoked
 						{
-							FromPort:   aws.Int64(22),
+							FromPort:   aws.Int32(22),
 							IpProtocol: aws.String("tcp"),
-							ToPort:     aws.Int64(22),
-							IpRanges: []*ec2.IpRange{
+							ToPort:     aws.Int32(22),
+							IpRanges: []types.IpRange{
 								{
 									CidrIp:      aws.String("0.0.0.0/0"),
 									Description: aws.String("SSH"),
@@ -974,11 +974,11 @@ func TestReconcileSecurityGroups(t *testing.T) {
 					},
 				}
 
-				securityGroupControl := &ec2.SecurityGroup{
+				securityGroupControl := types.SecurityGroup{
 					Description: aws.String("Kubernetes cluster test-cluster: controlplane"),
 					GroupName:   aws.String("test-cluster-controlplane"),
 					GroupId:     aws.String("sg-control"),
-					Tags: []*ec2.Tag{
+					Tags: []types.Tag{
 						{
 							Key:   aws.String("Name"),
 							Value: aws.String("test-cluster-controlplane"),
@@ -990,12 +990,12 @@ func TestReconcileSecurityGroups(t *testing.T) {
 							Value: aws.String("controlplane"),
 						},
 					},
-					IpPermissions: []*ec2.IpPermission{
+					IpPermissions: []types.IpPermission{
 						{
-							FromPort:   aws.Int64(6443),
+							FromPort:   aws.Int32(6443),
 							IpProtocol: aws.String("tcp"),
-							ToPort:     aws.Int64(6443),
-							UserIdGroupPairs: []*ec2.UserIdGroupPair{
+							ToPort:     aws.Int32(6443),
+							UserIdGroupPairs: []types.UserIdGroupPair{
 								{
 									Description: aws.String("Kubernetes API"),
 									GroupId:     aws.String("sg-apiserver-lb"),
@@ -1009,10 +1009,10 @@ func TestReconcileSecurityGroups(t *testing.T) {
 							},
 						},
 						{
-							FromPort:   aws.Int64(2379),
+							FromPort:   aws.Int32(2379),
 							IpProtocol: aws.String("tcp"),
-							ToPort:     aws.Int64(2379),
-							UserIdGroupPairs: []*ec2.UserIdGroupPair{
+							ToPort:     aws.Int32(2379),
+							UserIdGroupPairs: []types.UserIdGroupPair{
 								{
 									Description: aws.String("etcd"),
 									GroupId:     aws.String("sg-control"),
@@ -1020,10 +1020,10 @@ func TestReconcileSecurityGroups(t *testing.T) {
 							},
 						},
 						{
-							FromPort:   aws.Int64(2380),
+							FromPort:   aws.Int32(2380),
 							IpProtocol: aws.String("tcp"),
-							ToPort:     aws.Int64(2380),
-							UserIdGroupPairs: []*ec2.UserIdGroupPair{
+							ToPort:     aws.Int32(2380),
+							UserIdGroupPairs: []types.UserIdGroupPair{
 								{
 									Description: aws.String("etcd peer"),
 									GroupId:     aws.String("sg-control"),
@@ -1033,11 +1033,11 @@ func TestReconcileSecurityGroups(t *testing.T) {
 					},
 				}
 
-				securityGroupNode := &ec2.SecurityGroup{
+				securityGroupNode := types.SecurityGroup{
 					Description: aws.String("Kubernetes cluster test-cluster: node"),
 					GroupName:   aws.String("test-cluster-node"),
 					GroupId:     aws.String("sg-node"),
-					Tags: []*ec2.Tag{
+					Tags: []types.Tag{
 						{
 							Key:   aws.String("Name"),
 							Value: aws.String("test-cluster-node"),
@@ -1049,22 +1049,22 @@ func TestReconcileSecurityGroups(t *testing.T) {
 							Value: aws.String("node"),
 						},
 					},
-					IpPermissions: []*ec2.IpPermission{
+					IpPermissions: []types.IpPermission{
 						{
-							FromPort:   aws.Int64(30000),
-							ToPort:     aws.Int64(32767),
+							FromPort:   aws.Int32(30000),
+							ToPort:     aws.Int32(32767),
 							IpProtocol: aws.String("tcp"),
-							IpRanges: []*ec2.IpRange{
+							IpRanges: []types.IpRange{
 								{
 									CidrIp:      aws.String("0.0.0.0/0"),
 									Description: aws.String("Node Port Services"),
 								},
 							},
 						}, {
-							FromPort:   aws.Int64(10250),
+							FromPort:   aws.Int32(10250),
 							IpProtocol: aws.String("tcp"),
-							ToPort:     aws.Int64(10250),
-							UserIdGroupPairs: []*ec2.UserIdGroupPair{
+							ToPort:     aws.Int32(10250),
+							UserIdGroupPairs: []types.UserIdGroupPair{
 								{
 									Description: aws.String("Kubelet API"),
 									GroupId:     aws.String("sg-control"),
@@ -1077,9 +1077,9 @@ func TestReconcileSecurityGroups(t *testing.T) {
 					},
 				}
 
-				m.DescribeSecurityGroupsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{})).
+				m.DescribeSecurityGroups(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{})).
 					Return(&ec2.DescribeSecurityGroupsOutput{
-						SecurityGroups: []*ec2.SecurityGroup{
+						SecurityGroups: []types.SecurityGroup{
 							securityGroupBastion,
 							securityGroupLB,
 							securityGroupAPIServerLB,
@@ -1088,14 +1088,14 @@ func TestReconcileSecurityGroups(t *testing.T) {
 						},
 					}, nil)
 
-				m.RevokeSecurityGroupIngressWithContext(context.TODO(), gomock.Eq(&ec2.RevokeSecurityGroupIngressInput{
+				m.RevokeSecurityGroupIngress(context.TODO(), gomock.Eq(&ec2.RevokeSecurityGroupIngressInput{
 					GroupId: aws.String("sg-apiserver-lb"),
-					IpPermissions: []*ec2.IpPermission{
+					IpPermissions: []types.IpPermission{
 						{
-							FromPort:   aws.Int64(22),
-							ToPort:     aws.Int64(22),
+							FromPort:   aws.Int32(22),
+							ToPort:     aws.Int32(22),
 							IpProtocol: aws.String("tcp"),
-							IpRanges: []*ec2.IpRange{
+							IpRanges: []types.IpRange{
 								{
 									CidrIp:      aws.String("0.0.0.0/0"),
 									Description: aws.String("SSH"),
@@ -1105,12 +1105,12 @@ func TestReconcileSecurityGroups(t *testing.T) {
 					},
 				})).Times(1)
 
-				m.AuthorizeSecurityGroupIngressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
+				m.AuthorizeSecurityGroupIngress(context.TODO(), gomock.AssignableToTypeOf(&ec2.AuthorizeSecurityGroupIngressInput{
 					GroupId: aws.String("sg-bastion"),
-					IpPermissions: []*ec2.IpPermission{
+					IpPermissions: []types.IpPermission{
 						{
-							ToPort:     aws.Int64(22),
-							FromPort:   aws.Int64(22),
+							ToPort:     aws.Int32(22),
+							FromPort:   aws.Int32(22),
 							IpProtocol: aws.String("tcp"),
 						},
 					},
@@ -1930,7 +1930,7 @@ func TestDeleteSecurityGroups(t *testing.T) {
 				},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSecurityGroupsPagesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{}), gomock.Any()).Return(nil)
+				m.DescribeSecurityGroups(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{}), gomock.Any()).Return(&ec2.DescribeSecurityGroupsOutput{}, nil)
 			},
 		},
 		{
@@ -1945,7 +1945,7 @@ func TestDeleteSecurityGroups(t *testing.T) {
 				VPC: infrav1.VPCSpec{ID: "vpc-id"},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSecurityGroupsPagesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{}), gomock.Any()).Return(awserrors.NewFailedDependency("dependency-failure"))
+				m.DescribeSecurityGroups(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{}), gomock.Any()).Return(&ec2.DescribeSecurityGroupsOutput{}, awserrors.NewFailedDependency("dependency-failure"))
 			},
 			wantErr: true,
 		},
@@ -1955,9 +1955,7 @@ func TestDeleteSecurityGroups(t *testing.T) {
 				VPC: infrav1.VPCSpec{ID: "vpc-id"},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSecurityGroupsPagesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{}), gomock.Any()).
-					Do(processSecurityGroupsPage).Return(nil)
-				m.DescribeSecurityGroupsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{})).Return(nil, awserr.New("dependency-failure", "dependency-failure", errors.Errorf("dependency-failure")))
+				m.DescribeSecurityGroups(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{}), gomock.Any()).Return(nil, awserr.New("dependency-failure", "dependency-failure", errors.Errorf("dependency-failure")))
 			},
 			wantErr: true,
 		},
@@ -1967,17 +1965,16 @@ func TestDeleteSecurityGroups(t *testing.T) {
 				VPC: infrav1.VPCSpec{ID: "vpc-id"},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSecurityGroupsPagesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{}), gomock.Any()).
-					Do(processSecurityGroupsPage).Return(nil)
-				m.DescribeSecurityGroupsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{})).Return(&ec2.DescribeSecurityGroupsOutput{
-					SecurityGroups: []*ec2.SecurityGroup{
+				m.DescribeSecurityGroups(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{}), gomock.Any()).Return(&ec2.DescribeSecurityGroupsOutput{
+					SecurityGroups: []types.SecurityGroup{
 						{
 							GroupId:   aws.String("group-id"),
 							GroupName: aws.String("group-name"),
 						},
 					},
-				}, nil)
-				m.DeleteSecurityGroupWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DeleteSecurityGroupInput{})).Return(nil, nil)
+				}, nil).Times(2)
+
+				m.DeleteSecurityGroup(context.TODO(), gomock.AssignableToTypeOf(&ec2.DeleteSecurityGroupInput{}), gomock.Any()).Return(nil, nil)
 			},
 		},
 		{
@@ -1986,22 +1983,20 @@ func TestDeleteSecurityGroups(t *testing.T) {
 				VPC: infrav1.VPCSpec{ID: "vpc-id"},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSecurityGroupsPagesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{}), gomock.Any()).
-					Do(processSecurityGroupsPage).Return(nil)
-				m.DescribeSecurityGroupsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{})).Return(&ec2.DescribeSecurityGroupsOutput{
-					SecurityGroups: []*ec2.SecurityGroup{
+				m.DescribeSecurityGroups(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{}), gomock.Any()).Return(&ec2.DescribeSecurityGroupsOutput{
+					SecurityGroups: []types.SecurityGroup{
 						{
 							GroupId:   aws.String("group-id"),
 							GroupName: aws.String("group-name"),
-							IpPermissions: []*ec2.IpPermission{
+							IpPermissions: []types.IpPermission{
 								{
-									ToPort: aws.Int64(4),
+									ToPort: aws.Int32(4),
 								},
 							},
 						},
 					},
-				}, nil)
-				m.RevokeSecurityGroupIngressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.RevokeSecurityGroupIngressInput{})).Return(nil, awserr.New("failure", "failure", errors.Errorf("failure")))
+				}, nil).Times(2)
+				m.RevokeSecurityGroupIngress(context.TODO(), gomock.AssignableToTypeOf(&ec2.RevokeSecurityGroupIngressInput{}), gomock.Any()).Return(nil, awserr.New("failure", "failure", errors.Errorf("failure")))
 			},
 			wantErr: true,
 		},
@@ -2011,23 +2006,21 @@ func TestDeleteSecurityGroups(t *testing.T) {
 				VPC: infrav1.VPCSpec{ID: "vpc-id"},
 			},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.DescribeSecurityGroupsPagesWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{}), gomock.Any()).
-					Do(processSecurityGroupsPage).Return(nil)
-				m.DescribeSecurityGroupsWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{})).Return(&ec2.DescribeSecurityGroupsOutput{
-					SecurityGroups: []*ec2.SecurityGroup{
+				m.DescribeSecurityGroups(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeSecurityGroupsInput{}), gomock.Any()).Return(&ec2.DescribeSecurityGroupsOutput{
+					SecurityGroups: []types.SecurityGroup{
 						{
 							GroupId:   aws.String("group-id"),
 							GroupName: aws.String("group-name"),
-							IpPermissions: []*ec2.IpPermission{
+							IpPermissions: []types.IpPermission{
 								{
-									ToPort: aws.Int64(4),
+									ToPort: aws.Int32(4),
 								},
 							},
 						},
 					},
-				}, nil)
-				m.RevokeSecurityGroupIngressWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.RevokeSecurityGroupIngressInput{})).Return(nil, nil)
-				m.DeleteSecurityGroupWithContext(context.TODO(), gomock.AssignableToTypeOf(&ec2.DeleteSecurityGroupInput{})).Return(nil, nil)
+				}, nil).Times(2)
+				m.RevokeSecurityGroupIngress(context.TODO(), gomock.AssignableToTypeOf(&ec2.RevokeSecurityGroupIngressInput{})).Return(nil, nil)
+				m.DeleteSecurityGroup(context.TODO(), gomock.AssignableToTypeOf(&ec2.DeleteSecurityGroupInput{})).Return(nil, nil)
 			},
 		},
 	}
@@ -2077,16 +2070,16 @@ func TestDeleteSecurityGroups(t *testing.T) {
 func TestIngressRulesFromSDKType(t *testing.T) {
 	tests := []struct {
 		name     string
-		input    *ec2.IpPermission
+		input    types.IpPermission
 		expected infrav1.IngressRules
 	}{
 		{
 			name: "two ingress rules",
-			input: &ec2.IpPermission{
+			input: types.IpPermission{
 				IpProtocol: aws.String("tcp"),
-				FromPort:   aws.Int64(6443),
-				ToPort:     aws.Int64(6443),
-				IpRanges: []*ec2.IpRange{
+				FromPort:   aws.Int32(6443),
+				ToPort:     aws.Int32(6443),
+				IpRanges: []types.IpRange{
 					{
 						CidrIp:      aws.String("0.0.0.0/0"),
 						Description: aws.String("Kubernetes API"),
@@ -2116,11 +2109,11 @@ func TestIngressRulesFromSDKType(t *testing.T) {
 		},
 		{
 			name: "Two group pairs",
-			input: &ec2.IpPermission{
+			input: types.IpPermission{
 				IpProtocol: aws.String("tcp"),
-				FromPort:   aws.Int64(10250),
-				ToPort:     aws.Int64(10250),
-				UserIdGroupPairs: []*ec2.UserIdGroupPair{
+				FromPort:   aws.Int32(10250),
+				ToPort:     aws.Int32(10250),
+				UserIdGroupPairs: []types.UserIdGroupPair{
 					{
 						Description: aws.String("Kubelet API"),
 						UserId:      aws.String("aws-user-id-1"),
@@ -2152,17 +2145,17 @@ func TestIngressRulesFromSDKType(t *testing.T) {
 		},
 		{
 			name: "Mix of group pairs and cidr blocks",
-			input: &ec2.IpPermission{
+			input: types.IpPermission{
 				IpProtocol: aws.String("tcp"),
-				FromPort:   aws.Int64(22),
-				ToPort:     aws.Int64(22),
-				IpRanges: []*ec2.IpRange{
+				FromPort:   aws.Int32(22),
+				ToPort:     aws.Int32(22),
+				IpRanges: []types.IpRange{
 					{
 						CidrIp:      aws.String("0.0.0.0/0"),
 						Description: aws.String("MY-SSH"),
 					},
 				},
-				UserIdGroupPairs: []*ec2.UserIdGroupPair{
+				UserIdGroupPairs: []types.UserIdGroupPair{
 					{
 						UserId:      aws.String("aws-user-id-1"),
 						GroupId:     aws.String("sg-source-1"),
@@ -2199,18 +2192,6 @@ func TestIngressRulesFromSDKType(t *testing.T) {
 	}
 }
 
-var processSecurityGroupsPage = func(ctx context.Context, _, y interface{}, requestOptions ...request.Option) {
-	funcType := y.(func(out *ec2.DescribeSecurityGroupsOutput, last bool) bool)
-	funcType(&ec2.DescribeSecurityGroupsOutput{
-		SecurityGroups: []*ec2.SecurityGroup{
-			{
-				GroupId:   aws.String("group-id"),
-				GroupName: aws.String("group-name"),
-			},
-		},
-	}, true)
-}
-
 func TestExpandIngressRules(t *testing.T) {
 	tests := []struct {
 		name     string
diff --git a/pkg/cloud/tags/tags_test.go b/pkg/cloud/tags/tags_test.go
index 204b34394..3b84e79a9 100644
--- a/pkg/cloud/tags/tags_test.go
+++ b/pkg/cloud/tags/tags_test.go
@@ -21,8 +21,9 @@ import (
 	"testing"
 
 	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go-v2/service/eks"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/golang/mock/gomock"
 	"github.com/google/go-cmp/cmp"
 	. "github.com/onsi/gomega"
@@ -34,7 +35,7 @@ import (
 )
 
 var (
-	expectedTags = []*ec2.Tag{
+	expectedTags = []ec2types.Tag{
 		{
 			Key:   aws.String("Name"),
 			Value: aws.String("test"),
@@ -142,8 +143,8 @@ func TestTagsEnsureWithEC2(t *testing.T) {
 				Additional:  map[string]string{"k1": "v1"},
 			}},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.CreateTagsWithContext(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
-					Resources: aws.StringSlice([]string{""}),
+				m.CreateTags(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
+					Resources: []string{""},
 					Tags:      expectedTags,
 				})).Return(nil, errors.New("failed to create tag"))
 			},
@@ -172,8 +173,8 @@ func TestTagsEnsureWithEC2(t *testing.T) {
 				Additional:  map[string]string{"k1": "v1"},
 			}},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.CreateTagsWithContext(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
-					Resources: aws.StringSlice([]string{""}),
+				m.CreateTags(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
+					Resources: []string{""},
 					Tags:      expectedTags,
 				})).Return(nil, nil)
 			},
@@ -188,8 +189,8 @@ func TestTagsEnsureWithEC2(t *testing.T) {
 				Additional:  map[string]string{"k1": "v1", "aws:cloudformation:stack-name": "cloudformation-stack-name"},
 			}},
 			expect: func(m *mocks.MockEC2APIMockRecorder) {
-				m.CreateTagsWithContext(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
-					Resources: aws.StringSlice([]string{""}),
+				m.CreateTags(context.TODO(), gomock.Eq(&ec2.CreateTagsInput{
+					Resources: []string{""},
 					Tags:      expectedTags,
 				})).Return(nil, nil)
 			},
@@ -289,8 +290,8 @@ func TestTagsBuildParamsToTagSpecification(t *testing.T) {
 		Role:        aws.String("testrole"),
 		Additional:  map[string]string{"k1": "v1"},
 	})
-	expectedTagSpec := &ec2.TagSpecification{
-		ResourceType: aws.String("test-resource"),
+	expectedTagSpec := ec2types.TagSpecification{
+		ResourceType: "test-resource",
 		Tags:         expectedTags,
 	}
 	g.Expect(expectedTagSpec).To(Equal(tagSpec))
diff --git a/test/e2e/shared/aws.go b/test/e2e/shared/aws.go
index a385ce0db..7e7d9131b 100644
--- a/test/e2e/shared/aws.go
+++ b/test/e2e/shared/aws.go
@@ -35,6 +35,8 @@ import (
 	awsv2 "github.com/aws/aws-sdk-go-v2/aws"
 	"github.com/aws/aws-sdk-go-v2/config"
 	awscredsv2 "github.com/aws/aws-sdk-go-v2/credentials"
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"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"
@@ -48,11 +50,11 @@ import (
 	cfn "github.com/aws/aws-sdk-go/service/cloudformation"
 	"github.com/aws/aws-sdk-go/service/cloudtrail"
 	"github.com/aws/aws-sdk-go/service/configservice"
-	"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/servicequotas"
 	"github.com/aws/aws-sdk-go/service/sts"
+	"github.com/aws/smithy-go"
 	cfn_iam "github.com/awslabs/goformation/v4/cloudformation/iam"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
@@ -89,14 +91,14 @@ type AWSInfrastructureState struct {
 type AWSInfrastructure struct {
 	Spec            AWSInfrastructureSpec `json:"spec"`
 	Context         *E2EContext
-	VPC             *ec2.Vpc
-	Subnets         []*ec2.Subnet
-	RouteTables     []*ec2.RouteTable
-	InternetGateway *ec2.InternetGateway
-	ElasticIP       *ec2.Address
-	NatGateway      *ec2.NatGateway
+	VPC             *ec2types.Vpc
+	Subnets         []*ec2types.Subnet
+	RouteTables     []*ec2types.RouteTable
+	InternetGateway *ec2types.InternetGateway
+	ElasticIP       *ec2types.Address
+	NatGateway      *ec2types.NatGateway
 	State           AWSInfrastructureState `json:"state"`
-	Peering         *ec2.VpcPeeringConnection
+	Peering         *ec2types.VpcPeeringConnection
 }
 
 func (i *AWSInfrastructure) New(ais AWSInfrastructureSpec, e2eCtx *E2EContext) AWSInfrastructure {
@@ -113,7 +115,7 @@ func (i *AWSInfrastructure) CreateVPC() AWSInfrastructure {
 	}
 
 	i.VPC = cv
-	i.State.VpcState = cv.State
+	i.State.VpcState = aws.String(string(cv.State))
 	return *i
 }
 
@@ -127,7 +129,7 @@ func (i *AWSInfrastructure) RefreshVPCState() AWSInfrastructure {
 	}
 	if vpc != nil {
 		i.VPC = vpc
-		i.State.VpcState = vpc.State
+		i.State.VpcState = aws.String(string(vpc.State))
 	}
 	return *i
 }
@@ -139,7 +141,7 @@ func (i *AWSInfrastructure) CreatePublicSubnet() AWSInfrastructure {
 		return *i
 	}
 	i.State.PublicSubnetID = subnet.SubnetId
-	i.State.PublicSubnetState = subnet.State
+	i.State.PublicSubnetState = aws.String(string(subnet.State))
 	i.Subnets = append(i.Subnets, subnet)
 	return *i
 }
@@ -151,7 +153,7 @@ func (i *AWSInfrastructure) CreatePrivateSubnet() AWSInfrastructure {
 		return *i
 	}
 	i.State.PrivateSubnetID = subnet.SubnetId
-	i.State.PrivateSubnetState = subnet.State
+	i.State.PrivateSubnetState = aws.String(string(subnet.State))
 	i.Subnets = append(i.Subnets, subnet)
 	return *i
 }
@@ -176,7 +178,7 @@ func (i *AWSInfrastructure) AllocateAddress() AWSInfrastructure {
 		return *i
 	}
 
-	var addr *ec2.Address
+	var addr *ec2types.Address
 	Eventually(func(gomega Gomega) {
 		addr, _ = GetAddress(i.Context, *aa.AllocationId)
 	}, 2*time.Minute, 5*time.Second).Should(Succeed())
@@ -185,7 +187,7 @@ func (i *AWSInfrastructure) AllocateAddress() AWSInfrastructure {
 }
 
 func (i *AWSInfrastructure) CreateNatGateway(ct string) AWSInfrastructure {
-	var s *ec2.Subnet
+	var s *ec2types.Subnet
 	Eventually(func(gomega Gomega) {
 		s, _ = GetSubnetByName(i.Context, i.Spec.ClusterName+"-subnet-"+ct)
 	}, 2*time.Minute, 5*time.Second).Should(Succeed())
@@ -199,7 +201,7 @@ func (i *AWSInfrastructure) CreateNatGateway(ct string) AWSInfrastructure {
 	if WaitForNatGatewayState(i.Context, *ngwC.NatGatewayId, "available") {
 		ngw, _ := GetNatGateway(i.Context, *ngwC.NatGatewayId)
 		i.NatGateway = ngw
-		i.State.NatGatewayState = ngw.State
+		i.State.NatGatewayState = aws.String(string(ngw.State))
 		return *i
 	}
 	i.NatGateway = ngwC
@@ -300,7 +302,7 @@ func (i *AWSInfrastructure) CreateInfrastructure() AWSInfrastructure {
 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) {
+		if instance.State.Code != aws.Int32(48) {
 			By(fmt.Sprintf("Deleting orphaned instance: %s - %v", *instance.InstanceId, TerminateInstance(i.Context, *instance.InstanceId)))
 		}
 	}
@@ -874,11 +876,12 @@ func ensureNoServiceLinkedRoles(ctx context.Context, cfg *awsv2.Config) {
 }
 
 // ensureSSHKeyPair ensures A SSH key is present under the name.
-func ensureSSHKeyPair(prov client.ConfigProvider, keyPairName string) {
+func ensureSSHKeyPair(config awsv2.Config, keyPairName string) {
 	By(fmt.Sprintf("Ensuring presence of SSH key in EC2: key-name=%s", keyPairName))
-	ec2c := ec2.New(prov)
-	_, err := ec2c.CreateKeyPair(&ec2.CreateKeyPairInput{KeyName: aws.String(keyPairName)})
-	if code, _ := awserrors.Code(err); code != "InvalidKeyPair.Duplicate" {
+	ec2c := ec2.NewFromConfig(config)
+	_, err := ec2c.CreateKeyPair(context.TODO(), &ec2.CreateKeyPairInput{KeyName: aws.String(keyPairName)})
+	var oe *smithy.OperationError
+	if errors.As(err, &oe) && !strings.Contains(oe.Unwrap().Error(), "InvalidKeyPair.Duplicate") {
 		Expect(err).NotTo(HaveOccurred())
 	}
 }
@@ -977,18 +980,18 @@ func conformanceImageID(e2eCtx *E2EContext) string {
 	amiName := AMIPrefix + ver + "*"
 
 	By(fmt.Sprintf("Searching for AMI: name=%s", amiName))
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
-	filters := []*ec2.Filter{
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
+	filters := []ec2types.Filter{
 		{
 			Name:   aws.String("name"),
-			Values: []*string{aws.String(amiName)},
+			Values: []string{amiName},
 		},
 	}
-	filters = append(filters, &ec2.Filter{
+	filters = append(filters, ec2types.Filter{
 		Name:   aws.String("owner-id"),
-		Values: []*string{aws.String(DefaultImageLookupOrg)},
+		Values: []string{DefaultImageLookupOrg},
 	})
-	resp, err := ec2Svc.DescribeImages(&ec2.DescribeImagesInput{
+	resp, err := ec2Svc.DescribeImages(context.TODO(), &ec2.DescribeImagesInput{
 		Filters: filters,
 	})
 	Expect(err).NotTo(HaveOccurred())
@@ -998,9 +1001,9 @@ func conformanceImageID(e2eCtx *E2EContext) string {
 	return imageID
 }
 
-func GetAvailabilityZones(sess client.ConfigProvider) []*ec2.AvailabilityZone {
-	ec2Client := ec2.New(sess)
-	azs, err := ec2Client.DescribeAvailabilityZonesWithContext(context.TODO(), nil)
+func GetAvailabilityZones(config awsv2.Config) []ec2types.AvailabilityZone {
+	ec2Client := ec2.NewFromConfig(config)
+	azs, err := ec2Client.DescribeAvailabilityZones(context.TODO(), nil)
 	Expect(err).NotTo(HaveOccurred())
 	return azs.AvailabilityZones
 }
@@ -1147,10 +1150,10 @@ func dumpEKSCluster(cluster *ekstypes.Cluster, logPath string) {
 // To calculate how much resources a test consumes, these helper functions below can be used.
 // ListVpcInternetGateways, ListNATGateways, ListRunningEC2, ListVPC.
 
-func ListVpcInternetGateways(e2eCtx *E2EContext) ([]*ec2.InternetGateway, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func ListVpcInternetGateways(e2eCtx *E2EContext) ([]ec2types.InternetGateway, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
-	out, err := ec2Svc.DescribeInternetGateways(&ec2.DescribeInternetGatewaysInput{})
+	out, err := ec2Svc.DescribeInternetGateways(context.TODO(), &ec2.DescribeInternetGatewaysInput{})
 	if err != nil {
 		return nil, err
 	}
@@ -1158,26 +1161,26 @@ func ListVpcInternetGateways(e2eCtx *E2EContext) ([]*ec2.InternetGateway, error)
 	return out.InternetGateways, nil
 }
 
-func ListNATGateways(e2eCtx *E2EContext) (map[string]*ec2.NatGateway, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func ListNATGateways(e2eCtx *E2EContext) (map[string]ec2types.NatGateway, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	describeNatGatewayInput := &ec2.DescribeNatGatewaysInput{
-		Filter: []*ec2.Filter{
-			filter.EC2.NATGatewayStates(ec2.NatGatewayStateAvailable),
+		Filter: []ec2types.Filter{
+			filter.EC2.NATGatewayStates(ec2types.NatGatewayStateAvailable),
 		},
 	}
 
-	gateways := make(map[string]*ec2.NatGateway)
+	gateways := make(map[string]ec2types.NatGateway)
 
-	err := ec2Svc.DescribeNatGatewaysPages(describeNatGatewayInput,
-		func(page *ec2.DescribeNatGatewaysOutput, lastPage bool) bool {
-			for _, r := range page.NatGateways {
-				gateways[*r.SubnetId] = r
-			}
-			return !lastPage
-		})
-	if err != nil {
-		return nil, err
+	paginator := ec2.NewDescribeNatGatewaysPaginator(ec2Svc, describeNatGatewayInput)
+	for paginator.HasMorePages() {
+		page, err := paginator.NextPage(context.TODO())
+		if err != nil {
+			return nil, fmt.Errorf("failed to describe NAT gateways: %w", err)
+		}
+		for _, r := range page.NatGateways {
+			gateways[aws.StringValue(r.SubnetId)] = r
+		}
 	}
 
 	return gateways, nil
@@ -1185,10 +1188,10 @@ func ListNATGateways(e2eCtx *E2EContext) (map[string]*ec2.NatGateway, error) {
 
 // listRunningEC2 returns a list of running EC2 instances.
 func listRunningEC2(e2eCtx *E2EContext) ([]instance, error) { //nolint:unused
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
-	resp, err := ec2Svc.DescribeInstancesWithContext(context.TODO(), &ec2.DescribeInstancesInput{
-		Filters: []*ec2.Filter{filter.EC2.InstanceStates(ec2.InstanceStateNameRunning)},
+	resp, err := ec2Svc.DescribeInstances(context.TODO(), &ec2.DescribeInstancesInput{
+		Filters: []ec2types.Filter{filter.EC2.InstanceStates(ec2types.InstanceStateNameRunning)},
 	})
 	if err != nil {
 		return nil, err
@@ -1220,23 +1223,23 @@ func listRunningEC2(e2eCtx *E2EContext) ([]instance, error) { //nolint:unused
 	return instances, nil
 }
 
-func ListClusterEC2Instances(e2eCtx *E2EContext, clusterName string) ([]*ec2.Instance, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
-	filter := &ec2.Filter{
+func ListClusterEC2Instances(e2eCtx *E2EContext, clusterName string) ([]ec2types.Instance, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
+	filter := ec2types.Filter{
 		Name:   aws.String("tag-key"),
-		Values: aws.StringSlice([]string{"sigs.k8s.io/cluster-api-provider-aws/cluster/" + clusterName}),
+		Values: []string{"sigs.k8s.io/cluster-api-provider-aws/cluster/" + clusterName},
 	}
 	input := &ec2.DescribeInstancesInput{
-		Filters: []*ec2.Filter{
+		Filters: []ec2types.Filter{
 			filter,
 		},
 	}
 
-	result, err := ec2Svc.DescribeInstances(input)
+	result, err := ec2Svc.DescribeInstances(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
-	instances := []*ec2.Instance{}
+	instances := []ec2types.Instance{}
 	for _, r := range result.Reservations {
 		instances = append(instances, r.Instances...)
 	}
@@ -1253,8 +1256,8 @@ func WaitForInstanceState(e2eCtx *E2EContext, clusterName string, state string)
 		}
 		instances, _ := ListClusterEC2Instances(e2eCtx, clusterName)
 		for _, i := range instances {
-			iState := *i.State.Name
-			st[iState]++
+			iState := i.State.Name
+			st[string(iState)]++
 		}
 		if st[state] == len(instances) || len(instances) == 0 {
 			return true
@@ -1266,28 +1269,28 @@ func WaitForInstanceState(e2eCtx *E2EContext, clusterName string, state string)
 }
 
 func TerminateInstance(e2eCtx *E2EContext, instanceID string) bool {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.TerminateInstancesInput{
-		InstanceIds: aws.StringSlice([]string{instanceID}),
+		InstanceIds: []string{instanceID},
 	}
 
-	if _, err := ec2Svc.TerminateInstances(input); err != nil {
+	if _, err := ec2Svc.TerminateInstances(context.TODO(), input); err != nil {
 		return false
 	}
 	return true
 }
 
 func ListVPC(e2eCtx *E2EContext) int {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.DescribeVpcsInput{
-		Filters: []*ec2.Filter{
-			filter.EC2.VPCStates(ec2.VpcStateAvailable),
+		Filters: []ec2types.Filter{
+			filter.EC2.VPCStates(ec2types.VpcStateAvailable),
 		},
 	}
 
-	out, err := ec2Svc.DescribeVpcs(input)
+	out, err := ec2Svc.DescribeVpcs(context.TODO(), input)
 	if err != nil {
 		return 0
 	}
@@ -1295,86 +1298,88 @@ func ListVPC(e2eCtx *E2EContext) int {
 	return len(out.Vpcs)
 }
 
-func GetVPC(e2eCtx *E2EContext, vpcID string) (*ec2.Vpc, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func GetVPC(e2eCtx *E2EContext, vpcID string) (*ec2types.Vpc, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
-	filter := &ec2.Filter{
+	filter := ec2types.Filter{
 		Name:   aws.String("vpc-id"),
-		Values: aws.StringSlice([]string{vpcID}),
+		Values: []string{vpcID},
 	}
 
 	input := &ec2.DescribeVpcsInput{
-		Filters: []*ec2.Filter{
+		Filters: []ec2types.Filter{
 			filter,
 		},
 	}
 
-	result, err := ec2Svc.DescribeVpcs(input)
+	result, err := ec2Svc.DescribeVpcs(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
 	if result.Vpcs == nil {
 		return nil, nil
 	}
-	return result.Vpcs[0], nil
+	return &result.Vpcs[0], nil
 }
 
-func GetVPCByName(e2eCtx *E2EContext, vpcName string) (*ec2.Vpc, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func GetVPCByName(e2eCtx *E2EContext, vpcName string) (*ec2types.Vpc, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
-	filter := &ec2.Filter{
+	filter := ec2types.Filter{
 		Name:   aws.String("tag:Name"),
-		Values: aws.StringSlice([]string{vpcName}),
+		Values: []string{vpcName},
 	}
 
 	input := &ec2.DescribeVpcsInput{
-		Filters: []*ec2.Filter{
+		Filters: []ec2types.Filter{
 			filter,
 		},
 	}
 
-	result, err := ec2Svc.DescribeVpcs(input)
+	result, err := ec2Svc.DescribeVpcs(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
 	if len(result.Vpcs) == 0 {
 		return nil, awserrors.NewNotFound("Vpc not found")
 	}
-	return result.Vpcs[0], nil
+	return &result.Vpcs[0], nil
 }
 
-func GetVPCEndpointsByID(e2eCtx *E2EContext, vpcID string) ([]*ec2.VpcEndpoint, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func GetVPCEndpointsByID(e2eCtx *E2EContext, vpcID string) ([]ec2types.VpcEndpoint, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.DescribeVpcEndpointsInput{
-		Filters: []*ec2.Filter{
+		Filters: []ec2types.Filter{
 			{
 				Name:   aws.String("vpc-id"),
-				Values: aws.StringSlice([]string{vpcID}),
+				Values: []string{vpcID},
 			},
 		},
 	}
 
-	res := []*ec2.VpcEndpoint{}
-	if err := ec2Svc.DescribeVpcEndpointsPages(input, func(dveo *ec2.DescribeVpcEndpointsOutput, lastPage bool) bool {
-		res = append(res, dveo.VpcEndpoints...)
-		return true
-	}); err != nil {
-		return nil, err
+	res := []ec2types.VpcEndpoint{}
+	paginator := ec2.NewDescribeVpcEndpointsPaginator(ec2Svc, input)
+	for paginator.HasMorePages() {
+		page, err := paginator.NextPage(context.TODO())
+		if err != nil {
+			return nil, fmt.Errorf("failed to describe VPC endpoints: %w", err)
+		}
+		res = append(res, page.VpcEndpoints...)
 	}
 
 	return res, nil
 }
 
-func CreateVPC(e2eCtx *E2EContext, vpcName string, cidrBlock string) (*ec2.Vpc, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func CreateVPC(e2eCtx *E2EContext, vpcName string, cidrBlock string) (*ec2types.Vpc, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.CreateVpcInput{
 		CidrBlock: aws.String(cidrBlock),
-		TagSpecifications: []*ec2.TagSpecification{
+		TagSpecifications: []ec2types.TagSpecification{
 			{
-				ResourceType: aws.String("vpc"),
-				Tags: []*ec2.Tag{
+				ResourceType: ec2types.ResourceTypeVpc,
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String(vpcName),
@@ -1383,7 +1388,7 @@ func CreateVPC(e2eCtx *E2EContext, vpcName string, cidrBlock string) (*ec2.Vpc,
 			},
 		},
 	}
-	result, err := ec2Svc.CreateVpc(input)
+	result, err := ec2Svc.CreateVpc(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
@@ -1391,109 +1396,109 @@ func CreateVPC(e2eCtx *E2EContext, vpcName string, cidrBlock string) (*ec2.Vpc,
 }
 
 func DisassociateVpcCidrBlock(e2eCtx *E2EContext, assocID string) bool {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.DisassociateVpcCidrBlockInput{
 		AssociationId: aws.String(assocID),
 	}
 
-	if _, err := ec2Svc.DisassociateVpcCidrBlock(input); err != nil {
+	if _, err := ec2Svc.DisassociateVpcCidrBlock(context.TODO(), input); err != nil {
 		return false
 	}
 	return true
 }
 
 func DeleteVPC(e2eCtx *E2EContext, vpcID string) bool {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.DeleteVpcInput{
 		VpcId: aws.String(vpcID),
 	}
-	if _, err := ec2Svc.DeleteVpc(input); err != nil {
+	if _, err := ec2Svc.DeleteVpc(context.TODO(), input); err != nil {
 		return false
 	}
 	return true
 }
 
-func ListVpcSubnets(e2eCtx *E2EContext, vpcID string) ([]*ec2.Subnet, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func ListVpcSubnets(e2eCtx *E2EContext, vpcID string) ([]ec2types.Subnet, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
-	filter := &ec2.Filter{
+	filter := ec2types.Filter{
 		Name:   aws.String("vpc-id"),
-		Values: aws.StringSlice([]string{vpcID}),
+		Values: []string{vpcID},
 	}
 
 	input := &ec2.DescribeSubnetsInput{
-		Filters: []*ec2.Filter{
+		Filters: []ec2types.Filter{
 			filter,
 		},
 	}
 
-	result, err := ec2Svc.DescribeSubnets(input)
+	result, err := ec2Svc.DescribeSubnets(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
 	return result.Subnets, nil
 }
 
-func GetSubnet(e2eCtx *E2EContext, subnetID string) (*ec2.Subnet, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func GetSubnet(e2eCtx *E2EContext, subnetID string) (*ec2types.Subnet, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
-	filter := &ec2.Filter{
+	filter := ec2types.Filter{
 		Name:   aws.String("subnet-id"),
-		Values: aws.StringSlice([]string{subnetID}),
+		Values: []string{subnetID},
 	}
 
 	input := &ec2.DescribeSubnetsInput{
-		Filters: []*ec2.Filter{
+		Filters: []ec2types.Filter{
 			filter,
 		},
 	}
 
-	result, err := ec2Svc.DescribeSubnets(input)
+	result, err := ec2Svc.DescribeSubnets(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
 	if result.Subnets == nil {
 		return nil, nil
 	}
-	return result.Subnets[0], nil
+	return &result.Subnets[0], nil
 }
 
-func GetSubnetByName(e2eCtx *E2EContext, name string) (*ec2.Subnet, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func GetSubnetByName(e2eCtx *E2EContext, name string) (*ec2types.Subnet, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
-	filter := &ec2.Filter{
+	filter := ec2types.Filter{
 		Name:   aws.String("tag:Name"),
-		Values: aws.StringSlice([]string{name}),
+		Values: []string{name},
 	}
 
 	input := &ec2.DescribeSubnetsInput{
-		Filters: []*ec2.Filter{
+		Filters: []ec2types.Filter{
 			filter,
 		},
 	}
 
-	result, err := ec2Svc.DescribeSubnets(input)
+	result, err := ec2Svc.DescribeSubnets(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
 	if result.Subnets == nil {
 		return nil, nil
 	}
-	return result.Subnets[0], nil
+	return &result.Subnets[0], nil
 }
 
-func CreateSubnet(e2eCtx *E2EContext, clusterName string, cidrBlock string, az string, vpcID string, st string) (*ec2.Subnet, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func CreateSubnet(e2eCtx *E2EContext, clusterName string, cidrBlock string, az string, vpcID string, st string) (*ec2types.Subnet, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.CreateSubnetInput{
 		CidrBlock: aws.String(cidrBlock),
 		VpcId:     aws.String(vpcID),
-		TagSpecifications: []*ec2.TagSpecification{
+		TagSpecifications: []ec2types.TagSpecification{
 			{
-				ResourceType: aws.String("subnet"),
-				Tags: []*ec2.Tag{
+				ResourceType: ec2types.ResourceTypeSubnet,
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String(clusterName + "-subnet-" + st),
@@ -1507,7 +1512,7 @@ func CreateSubnet(e2eCtx *E2EContext, clusterName string, cidrBlock string, az s
 		input.AvailabilityZone = aws.String(az)
 	}
 
-	result, err := ec2Svc.CreateSubnet(input)
+	result, err := ec2Svc.CreateSubnet(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
@@ -1515,51 +1520,51 @@ func CreateSubnet(e2eCtx *E2EContext, clusterName string, cidrBlock string, az s
 }
 
 func DeleteSubnet(e2eCtx *E2EContext, subnetID string) bool {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.DeleteSubnetInput{
 		SubnetId: aws.String(subnetID),
 	}
 
-	if _, err := ec2Svc.DeleteSubnet(input); err != nil {
+	if _, err := ec2Svc.DeleteSubnet(context.TODO(), input); err != nil {
 		return false
 	}
 	return true
 }
 
-func GetAddress(e2eCtx *E2EContext, allocationID string) (*ec2.Address, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func GetAddress(e2eCtx *E2EContext, allocationID string) (*ec2types.Address, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
-	filter := &ec2.Filter{
+	filter := ec2types.Filter{
 		Name:   aws.String("allocation-id"),
-		Values: aws.StringSlice([]string{allocationID}),
+		Values: []string{allocationID},
 	}
 
 	input := &ec2.DescribeAddressesInput{
-		Filters: []*ec2.Filter{
+		Filters: []ec2types.Filter{
 			filter,
 		},
 	}
 
-	result, err := ec2Svc.DescribeAddresses(input)
+	result, err := ec2Svc.DescribeAddresses(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
 	if result.Addresses == nil {
 		return nil, nil
 	}
-	return result.Addresses[0], nil
+	return &result.Addresses[0], nil
 }
 
 func AllocateAddress(e2eCtx *E2EContext, eipName string) (*ec2.AllocateAddressOutput, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.AllocateAddressInput{
-		Domain: aws.String("vpc"),
-		TagSpecifications: []*ec2.TagSpecification{
+		Domain: ec2types.DomainTypeVpc,
+		TagSpecifications: []ec2types.TagSpecification{
 			{
-				ResourceType: aws.String("elastic-ip"),
-				Tags: []*ec2.Tag{
+				ResourceType: ec2types.ResourceTypeElasticIp,
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String(eipName),
@@ -1569,7 +1574,7 @@ func AllocateAddress(e2eCtx *E2EContext, eipName string) (*ec2.AllocateAddressOu
 		},
 	}
 
-	result, err := ec2Svc.AllocateAddress(input)
+	result, err := ec2Svc.AllocateAddress(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
@@ -1577,40 +1582,40 @@ func AllocateAddress(e2eCtx *E2EContext, eipName string) (*ec2.AllocateAddressOu
 }
 
 func DisassociateAddress(e2eCtx *E2EContext, assocID string) bool {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.DisassociateAddressInput{
 		AssociationId: aws.String(assocID),
 	}
 
-	if _, err := ec2Svc.DisassociateAddress(input); err != nil {
+	if _, err := ec2Svc.DisassociateAddress(context.TODO(), input); err != nil {
 		return false
 	}
 	return true
 }
 
 func ReleaseAddress(e2eCtx *E2EContext, allocationID string) bool {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.ReleaseAddressInput{
 		AllocationId: aws.String(allocationID),
 	}
 
-	if _, err := ec2Svc.ReleaseAddress(input); err != nil {
+	if _, err := ec2Svc.ReleaseAddress(context.TODO(), input); err != nil {
 		return false
 	}
 	return true
 }
 
-func CreateNatGateway(e2eCtx *E2EContext, gatewayName string, connectType string, allocationID string, subnetID string) (*ec2.NatGateway, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func CreateNatGateway(e2eCtx *E2EContext, gatewayName string, connectType string, allocationID string, subnetID string) (*ec2types.NatGateway, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.CreateNatGatewayInput{
 		SubnetId: aws.String(subnetID),
-		TagSpecifications: []*ec2.TagSpecification{
+		TagSpecifications: []ec2types.TagSpecification{
 			{
-				ResourceType: aws.String("natgateway"),
-				Tags: []*ec2.Tag{
+				ResourceType: ec2types.ResourceTypeNatgateway,
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String(gatewayName),
@@ -1621,52 +1626,52 @@ func CreateNatGateway(e2eCtx *E2EContext, gatewayName string, connectType string
 	}
 
 	if connectType != "" {
-		input.ConnectivityType = aws.String(connectType)
+		input.ConnectivityType = ec2types.ConnectivityType(connectType)
 	}
 
 	if allocationID != "" {
 		input.AllocationId = aws.String(allocationID)
 	}
 
-	result, err := ec2Svc.CreateNatGateway(input)
+	result, err := ec2Svc.CreateNatGateway(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
 	return result.NatGateway, nil
 }
 
-func GetNatGateway(e2eCtx *E2EContext, gatewayID string) (*ec2.NatGateway, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func GetNatGateway(e2eCtx *E2EContext, gatewayID string) (*ec2types.NatGateway, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
-	filter := &ec2.Filter{
+	filter := ec2types.Filter{
 		Name:   aws.String("nat-gateway-id"),
-		Values: aws.StringSlice([]string{gatewayID}),
+		Values: []string{gatewayID},
 	}
 
 	input := &ec2.DescribeNatGatewaysInput{
-		Filter: []*ec2.Filter{
+		Filter: []ec2types.Filter{
 			filter,
 		},
 	}
 
-	result, err := ec2Svc.DescribeNatGateways(input)
+	result, err := ec2Svc.DescribeNatGateways(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
 	if result.NatGateways == nil {
 		return nil, nil
 	}
-	return result.NatGateways[0], nil
+	return &result.NatGateways[0], nil
 }
 
 func DeleteNatGateway(e2eCtx *E2EContext, gatewayID string) bool {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.DeleteNatGatewayInput{
 		NatGatewayId: aws.String(gatewayID),
 	}
 
-	if _, err := ec2Svc.DeleteNatGateway(input); err != nil {
+	if _, err := ec2Svc.DeleteNatGateway(context.TODO(), input); err != nil {
 		return false
 	}
 	return true
@@ -1675,20 +1680,20 @@ func DeleteNatGateway(e2eCtx *E2EContext, gatewayID string) bool {
 func WaitForNatGatewayState(e2eCtx *E2EContext, gatewayID string, state string) bool {
 	Eventually(func(gomega Gomega) bool {
 		gw, _ := GetNatGateway(e2eCtx, gatewayID)
-		gwState := *gw.State
-		return gwState == state
+		gwState := gw.State
+		return gwState == ec2types.NatGatewayState(state)
 	}, 3*time.Minute, 5*time.Second).Should(BeTrue(), fmt.Sprintf("Eventually failed waiting for NAT Gateway to be in %q state", state))
 	return false
 }
 
-func CreateInternetGateway(e2eCtx *E2EContext, gatewayName string) (*ec2.InternetGateway, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func CreateInternetGateway(e2eCtx *E2EContext, gatewayName string) (*ec2types.InternetGateway, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.CreateInternetGatewayInput{
-		TagSpecifications: []*ec2.TagSpecification{
+		TagSpecifications: []ec2types.TagSpecification{
 			{
-				ResourceType: aws.String("internet-gateway"),
-				Tags: []*ec2.Tag{
+				ResourceType: ec2types.ResourceTypeInternetGateway,
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String(gatewayName),
@@ -1698,88 +1703,88 @@ func CreateInternetGateway(e2eCtx *E2EContext, gatewayName string) (*ec2.Interne
 		},
 	}
 
-	result, err := ec2Svc.CreateInternetGateway(input)
+	result, err := ec2Svc.CreateInternetGateway(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
 	return result.InternetGateway, nil
 }
 
-func GetInternetGateway(e2eCtx *E2EContext, gatewayID string) (*ec2.InternetGateway, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func GetInternetGateway(e2eCtx *E2EContext, gatewayID string) (*ec2types.InternetGateway, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
-	filter := &ec2.Filter{
+	filter := ec2types.Filter{
 		Name:   aws.String("internet-gateway-id"),
-		Values: aws.StringSlice([]string{gatewayID}),
+		Values: []string{gatewayID},
 	}
 
 	input := &ec2.DescribeInternetGatewaysInput{
-		Filters: []*ec2.Filter{
+		Filters: []ec2types.Filter{
 			filter,
 		},
 	}
 
-	result, err := ec2Svc.DescribeInternetGateways(input)
+	result, err := ec2Svc.DescribeInternetGateways(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
 	if result.InternetGateways == nil {
 		return nil, nil
 	}
-	return result.InternetGateways[0], nil
+	return &result.InternetGateways[0], nil
 }
 
 func DeleteInternetGateway(e2eCtx *E2EContext, gatewayID string) bool {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.DeleteInternetGatewayInput{
 		InternetGatewayId: aws.String(gatewayID),
 	}
 
-	if _, err := ec2Svc.DeleteInternetGateway(input); err != nil {
+	if _, err := ec2Svc.DeleteInternetGateway(context.TODO(), input); err != nil {
 		return false
 	}
 	return true
 }
 
 func AttachInternetGateway(e2eCtx *E2EContext, gatewayID string, vpcID string) (bool, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.AttachInternetGatewayInput{
 		InternetGatewayId: aws.String(gatewayID),
 		VpcId:             aws.String(vpcID),
 	}
 
-	if _, err := ec2Svc.AttachInternetGateway(input); err != nil {
+	if _, err := ec2Svc.AttachInternetGateway(context.TODO(), input); err != nil {
 		return false, err
 	}
 	return true, nil
 }
 
 func DetachInternetGateway(e2eCtx *E2EContext, gatewayID string, vpcID string) bool {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.DetachInternetGatewayInput{
 		InternetGatewayId: aws.String(gatewayID),
 		VpcId:             aws.String(vpcID),
 	}
 
-	if _, err := ec2Svc.DetachInternetGateway(input); err != nil {
+	if _, err := ec2Svc.DetachInternetGateway(context.TODO(), input); err != nil {
 		return false
 	}
 	return true
 }
 
-func CreatePeering(e2eCtx *E2EContext, peerName string, vpcID string, peerVpcID string) (*ec2.VpcPeeringConnection, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func CreatePeering(e2eCtx *E2EContext, peerName string, vpcID string, peerVpcID string) (*ec2types.VpcPeeringConnection, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.CreateVpcPeeringConnectionInput{
 		VpcId:     aws.String(vpcID),
 		PeerVpcId: aws.String(peerVpcID),
-		TagSpecifications: []*ec2.TagSpecification{
+		TagSpecifications: []ec2types.TagSpecification{
 			{
-				ResourceType: aws.String("vpc-peering-connection"),
-				Tags: []*ec2.Tag{
+				ResourceType: ec2types.ResourceTypeVpcPeeringConnection,
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String(peerName),
@@ -1789,73 +1794,73 @@ func CreatePeering(e2eCtx *E2EContext, peerName string, vpcID string, peerVpcID
 		},
 	}
 
-	result, err := ec2Svc.CreateVpcPeeringConnection(input)
+	result, err := ec2Svc.CreateVpcPeeringConnection(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
 	return result.VpcPeeringConnection, nil
 }
 
-func GetPeering(e2eCtx *E2EContext, peeringID string) (*ec2.VpcPeeringConnection, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func GetPeering(e2eCtx *E2EContext, peeringID string) (*ec2types.VpcPeeringConnection, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
-	filter := &ec2.Filter{
+	filter := ec2types.Filter{
 		Name:   aws.String("vpc-peering-connection-id"),
-		Values: aws.StringSlice([]string{peeringID}),
+		Values: []string{peeringID},
 	}
 
 	input := &ec2.DescribeVpcPeeringConnectionsInput{
-		Filters: []*ec2.Filter{
+		Filters: []ec2types.Filter{
 			filter,
 		},
 	}
 
-	result, err := ec2Svc.DescribeVpcPeeringConnections(input)
+	result, err := ec2Svc.DescribeVpcPeeringConnections(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
 	if result.VpcPeeringConnections == nil {
 		return nil, nil
 	}
-	return result.VpcPeeringConnections[0], nil
+	return &result.VpcPeeringConnections[0], nil
 }
 
 func DeletePeering(e2eCtx *E2EContext, peeringID string) bool {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.DeleteVpcPeeringConnectionInput{
 		VpcPeeringConnectionId: aws.String(peeringID),
 	}
 
-	if _, err := ec2Svc.DeleteVpcPeeringConnection(input); err != nil {
+	if _, err := ec2Svc.DeleteVpcPeeringConnection(context.TODO(), input); err != nil {
 		return false
 	}
 	return true
 }
 
-func AcceptPeering(e2eCtx *E2EContext, peeringID string) (*ec2.VpcPeeringConnection, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func AcceptPeering(e2eCtx *E2EContext, peeringID string) (*ec2types.VpcPeeringConnection, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.AcceptVpcPeeringConnectionInput{
 		VpcPeeringConnectionId: aws.String(peeringID),
 	}
 
-	result, err := ec2Svc.AcceptVpcPeeringConnection(input)
+	result, err := ec2Svc.AcceptVpcPeeringConnection(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
 	return result.VpcPeeringConnection, nil
 }
 
-func CreateRouteTable(e2eCtx *E2EContext, rtName string, vpcID string) (*ec2.RouteTable, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func CreateRouteTable(e2eCtx *E2EContext, rtName string, vpcID string) (*ec2types.RouteTable, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.CreateRouteTableInput{
 		VpcId: aws.String(vpcID),
-		TagSpecifications: []*ec2.TagSpecification{
+		TagSpecifications: []ec2types.TagSpecification{
 			{
-				ResourceType: aws.String("route-table"),
-				Tags: []*ec2.Tag{
+				ResourceType: ec2types.ResourceTypeRouteTable,
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String(rtName),
@@ -1865,94 +1870,94 @@ func CreateRouteTable(e2eCtx *E2EContext, rtName string, vpcID string) (*ec2.Rou
 		},
 	}
 
-	result, err := ec2Svc.CreateRouteTable(input)
+	result, err := ec2Svc.CreateRouteTable(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
 	return result.RouteTable, nil
 }
 
-func ListVpcRouteTables(e2eCtx *E2EContext, vpcID string) ([]*ec2.RouteTable, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func ListVpcRouteTables(e2eCtx *E2EContext, vpcID string) ([]ec2types.RouteTable, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
-	filter := &ec2.Filter{
+	filter := ec2types.Filter{
 		Name:   aws.String("vpc-id"),
-		Values: aws.StringSlice([]string{vpcID}),
+		Values: []string{vpcID},
 	}
 
 	input := &ec2.DescribeRouteTablesInput{
-		Filters: []*ec2.Filter{
+		Filters: []ec2types.Filter{
 			filter,
 		},
 	}
 
-	result, err := ec2Svc.DescribeRouteTables(input)
+	result, err := ec2Svc.DescribeRouteTables(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
 	return result.RouteTables, nil
 }
 
-func ListSubnetRouteTables(e2eCtx *E2EContext, subnetID string) ([]*ec2.RouteTable, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func ListSubnetRouteTables(e2eCtx *E2EContext, subnetID string) ([]ec2types.RouteTable, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
-	filter := &ec2.Filter{
+	filter := ec2types.Filter{
 		Name:   aws.String("association.subnet-id"),
-		Values: aws.StringSlice([]string{subnetID}),
+		Values: []string{subnetID},
 	}
 
 	input := &ec2.DescribeRouteTablesInput{
-		Filters: []*ec2.Filter{
+		Filters: []ec2types.Filter{
 			filter,
 		},
 	}
 
-	result, err := ec2Svc.DescribeRouteTables(input)
+	result, err := ec2Svc.DescribeRouteTables(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
 	return result.RouteTables, nil
 }
 
-func GetRouteTable(e2eCtx *E2EContext, rtID string) (*ec2.RouteTable, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func GetRouteTable(e2eCtx *E2EContext, rtID string) (*ec2types.RouteTable, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
-	filter := &ec2.Filter{
+	filter := ec2types.Filter{
 		Name:   aws.String("route-table-id"),
-		Values: aws.StringSlice([]string{rtID}),
+		Values: []string{rtID},
 	}
 
 	input := &ec2.DescribeRouteTablesInput{
-		Filters: []*ec2.Filter{
+		Filters: []ec2types.Filter{
 			filter,
 		},
 	}
 
-	result, err := ec2Svc.DescribeRouteTables(input)
+	result, err := ec2Svc.DescribeRouteTables(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
 	if result.RouteTables == nil {
 		return nil, nil
 	}
-	return result.RouteTables[0], nil
+	return &result.RouteTables[0], nil
 }
 
 func DeleteRouteTable(e2eCtx *E2EContext, rtID string) bool {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.DeleteRouteTableInput{
 		RouteTableId: aws.String(rtID),
 	}
 
-	if _, err := ec2Svc.DeleteRouteTable(input); err != nil {
+	if _, err := ec2Svc.DeleteRouteTable(context.TODO(), input); err != nil {
 		return false
 	}
 	return true
 }
 
 func CreateRoute(e2eCtx *E2EContext, rtID string, destinationCidr string, natID *string, igwID *string, pcxID *string) bool {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.CreateRouteInput{
 		RouteTableId:         &rtID,
@@ -1971,33 +1976,33 @@ func CreateRoute(e2eCtx *E2EContext, rtID string, destinationCidr string, natID
 		input.VpcPeeringConnectionId = pcxID
 	}
 
-	_, err := ec2Svc.CreateRoute(input)
+	_, err := ec2Svc.CreateRoute(context.TODO(), input)
 	return err == nil
 }
 
 func DeleteRoute(e2eCtx *E2EContext, rtID string, destinationCidr string) bool {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.DeleteRouteInput{
 		RouteTableId:         aws.String(rtID),
 		DestinationCidrBlock: aws.String(destinationCidr),
 	}
 
-	if _, err := ec2Svc.DeleteRoute(input); err != nil {
+	if _, err := ec2Svc.DeleteRoute(context.TODO(), input); err != nil {
 		return false
 	}
 	return true
 }
 
 func AssociateRouteTable(e2eCtx *E2EContext, rtID string, subnetID string) (*ec2.AssociateRouteTableOutput, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.AssociateRouteTableInput{
 		RouteTableId: aws.String(rtID),
 		SubnetId:     aws.String(subnetID),
 	}
 
-	result, err := ec2Svc.AssociateRouteTable(input)
+	result, err := ec2Svc.AssociateRouteTable(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
@@ -2005,29 +2010,29 @@ func AssociateRouteTable(e2eCtx *E2EContext, rtID string, subnetID string) (*ec2
 }
 
 func DisassociateRouteTable(e2eCtx *E2EContext, assocID string) bool {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.DisassociateRouteTableInput{
 		AssociationId: aws.String(assocID),
 	}
 
-	if _, err := ec2Svc.DisassociateRouteTable(input); err != nil {
+	if _, err := ec2Svc.DisassociateRouteTable(context.TODO(), input); err != nil {
 		return false
 	}
 	return true
 }
 
 func CreateSecurityGroup(e2eCtx *E2EContext, sgName string, sgDescription string, vpcID string) (*ec2.CreateSecurityGroupOutput, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.CreateSecurityGroupInput{
 		VpcId:       aws.String(vpcID),
 		GroupName:   aws.String(sgName),
 		Description: aws.String(sgDescription),
-		TagSpecifications: []*ec2.TagSpecification{
+		TagSpecifications: []ec2types.TagSpecification{
 			{
-				ResourceType: aws.String("security-group"),
-				Tags: []*ec2.Tag{
+				ResourceType: ec2types.ResourceTypeSecurityGroup,
+				Tags: []ec2types.Tag{
 					{
 						Key:   aws.String("Name"),
 						Value: aws.String(sgName),
@@ -2037,66 +2042,66 @@ func CreateSecurityGroup(e2eCtx *E2EContext, sgName string, sgDescription string
 		},
 	}
 
-	result, err := ec2Svc.CreateSecurityGroup(input)
+	result, err := ec2Svc.CreateSecurityGroup(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
 	return result, nil
 }
 
-func GetSecurityGroupByFilters(e2eCtx *E2EContext, filters []*ec2.Filter) ([]*ec2.SecurityGroup, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func GetSecurityGroupByFilters(e2eCtx *E2EContext, filters []ec2types.Filter) ([]ec2types.SecurityGroup, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 	input := &ec2.DescribeSecurityGroupsInput{
 		Filters: filters,
 	}
-	result, err := ec2Svc.DescribeSecurityGroups(input)
+	result, err := ec2Svc.DescribeSecurityGroups(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
 	return result.SecurityGroups, nil
 }
 
-func GetSecurityGroup(e2eCtx *E2EContext, sgID string) (*ec2.SecurityGroup, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func GetSecurityGroup(e2eCtx *E2EContext, sgID string) (*ec2types.SecurityGroup, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
-	filter := &ec2.Filter{
+	filter := ec2types.Filter{
 		Name:   aws.String("group-id"),
-		Values: aws.StringSlice([]string{sgID}),
+		Values: []string{sgID},
 	}
 
 	input := &ec2.DescribeSecurityGroupsInput{
-		Filters: []*ec2.Filter{
+		Filters: []ec2types.Filter{
 			filter,
 		},
 	}
 
-	result, err := ec2Svc.DescribeSecurityGroups(input)
+	result, err := ec2Svc.DescribeSecurityGroups(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
 	if result.SecurityGroups == nil {
 		return nil, nil
 	}
-	return result.SecurityGroups[0], nil
+	return &result.SecurityGroups[0], nil
 }
 
-func GetSecurityGroupsByVPC(e2eCtx *E2EContext, vpcID string) ([]*ec2.SecurityGroup, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func GetSecurityGroupsByVPC(e2eCtx *E2EContext, vpcID string) ([]ec2types.SecurityGroup, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
-	filter := &ec2.Filter{
+	filter := ec2types.Filter{
 		Name: aws.String("vpc-id"),
-		Values: []*string{
-			aws.String(vpcID),
+		Values: []string{
+			vpcID,
 		},
 	}
 
 	input := &ec2.DescribeSecurityGroupsInput{
-		Filters: []*ec2.Filter{
+		Filters: []ec2types.Filter{
 			filter,
 		},
 	}
 
-	result, err := ec2Svc.DescribeSecurityGroups(input)
+	result, err := ec2Svc.DescribeSecurityGroups(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
@@ -2107,71 +2112,71 @@ func GetSecurityGroupsByVPC(e2eCtx *E2EContext, vpcID string) ([]*ec2.SecurityGr
 }
 
 func DeleteSecurityGroup(e2eCtx *E2EContext, sgID string) bool {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.DeleteSecurityGroupInput{
 		GroupId: aws.String(sgID),
 	}
 
-	if _, err := ec2Svc.DeleteSecurityGroup(input); err != nil {
+	if _, err := ec2Svc.DeleteSecurityGroup(context.TODO(), input); err != nil {
 		return false
 	}
 	return true
 }
 
-func ListSecurityGroupRules(e2eCtx *E2EContext, sgID string) ([]*ec2.SecurityGroupRule, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func ListSecurityGroupRules(e2eCtx *E2EContext, sgID string) ([]ec2types.SecurityGroupRule, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
-	filter := &ec2.Filter{
+	filter := ec2types.Filter{
 		Name:   aws.String("group-id"),
-		Values: aws.StringSlice([]string{sgID}),
+		Values: []string{sgID},
 	}
 
 	input := &ec2.DescribeSecurityGroupRulesInput{
-		Filters: []*ec2.Filter{
+		Filters: []ec2types.Filter{
 			filter,
 		},
 	}
 
-	result, err := ec2Svc.DescribeSecurityGroupRules(input)
+	result, err := ec2Svc.DescribeSecurityGroupRules(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
 	return result.SecurityGroupRules, nil
 }
 
-func GetSecurityGroupRule(e2eCtx *E2EContext, sgrID string) (*ec2.SecurityGroupRule, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func GetSecurityGroupRule(e2eCtx *E2EContext, sgrID string) (*ec2types.SecurityGroupRule, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
-	filter := &ec2.Filter{
+	filter := ec2types.Filter{
 		Name:   aws.String("security-group-rule-id"),
-		Values: aws.StringSlice([]string{sgrID}),
+		Values: []string{sgrID},
 	}
 
 	input := &ec2.DescribeSecurityGroupRulesInput{
-		Filters: []*ec2.Filter{
+		Filters: []ec2types.Filter{
 			filter,
 		},
 	}
 
-	result, err := ec2Svc.DescribeSecurityGroupRules(input)
+	result, err := ec2Svc.DescribeSecurityGroupRules(context.TODO(), input)
 	if err != nil {
 		return nil, err
 	}
 	if result.SecurityGroupRules == nil {
 		return nil, nil
 	}
-	return result.SecurityGroupRules[0], nil
+	return &result.SecurityGroupRules[0], nil
 }
 
-func CreateSecurityGroupIngressRule(e2eCtx *E2EContext, sgID string, sgrDescription string, cidr string, protocol string, fromPort int64, toPort int64) (bool, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func CreateSecurityGroupIngressRule(e2eCtx *E2EContext, sgID string, sgrDescription string, cidr string, protocol string, fromPort int32, toPort int32) (bool, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
-	ipPerm := &ec2.IpPermission{
-		FromPort:   aws.Int64(fromPort),
-		ToPort:     aws.Int64(toPort),
+	ipPerm := ec2types.IpPermission{
+		FromPort:   aws.Int32(fromPort),
+		ToPort:     aws.Int32(toPort),
 		IpProtocol: aws.String(protocol),
-		IpRanges: []*ec2.IpRange{
+		IpRanges: []ec2types.IpRange{
 			{
 				CidrIp:      aws.String(cidr),
 				Description: aws.String(sgrDescription),
@@ -2181,26 +2186,26 @@ func CreateSecurityGroupIngressRule(e2eCtx *E2EContext, sgID string, sgrDescript
 
 	input := &ec2.AuthorizeSecurityGroupIngressInput{
 		GroupId: aws.String(sgID),
-		IpPermissions: []*ec2.IpPermission{
+		IpPermissions: []ec2types.IpPermission{
 			ipPerm,
 		},
 	}
 
-	result, err := ec2Svc.AuthorizeSecurityGroupIngress(input)
+	result, err := ec2Svc.AuthorizeSecurityGroupIngress(context.TODO(), input)
 	if err != nil {
 		return false, err
 	}
 	return *result.Return, nil
 }
 
-func CreateSecurityGroupEgressRule(e2eCtx *E2EContext, sgID string, sgrDescription string, cidr string, protocol string, fromPort int64, toPort int64) (bool, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func CreateSecurityGroupEgressRule(e2eCtx *E2EContext, sgID string, sgrDescription string, cidr string, protocol string, fromPort int32, toPort int32) (bool, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
-	ipPerm := &ec2.IpPermission{
-		FromPort:   aws.Int64(fromPort),
-		ToPort:     aws.Int64(toPort),
+	ipPerm := ec2types.IpPermission{
+		FromPort:   aws.Int32(fromPort),
+		ToPort:     aws.Int32(toPort),
 		IpProtocol: aws.String(protocol),
-		IpRanges: []*ec2.IpRange{
+		IpRanges: []ec2types.IpRange{
 			{
 				CidrIp:      aws.String(cidr),
 				Description: aws.String(sgrDescription),
@@ -2210,18 +2215,18 @@ func CreateSecurityGroupEgressRule(e2eCtx *E2EContext, sgID string, sgrDescripti
 
 	input := &ec2.AuthorizeSecurityGroupEgressInput{
 		GroupId: aws.String(sgID),
-		IpPermissions: []*ec2.IpPermission{
+		IpPermissions: []ec2types.IpPermission{
 			ipPerm,
 		},
 	}
-	result, err := ec2Svc.AuthorizeSecurityGroupEgress(input)
+	result, err := ec2Svc.AuthorizeSecurityGroupEgress(context.TODO(), input)
 	if err != nil {
 		return false, err
 	}
 	return *result.Return, nil
 }
 
-func CreateSecurityGroupRule(e2eCtx *E2EContext, sgID string, sgrDescription string, cidr string, protocol string, fromPort int64, toPort int64, rt string) (bool, error) {
+func CreateSecurityGroupRule(e2eCtx *E2EContext, sgID string, sgrDescription string, cidr string, protocol string, fromPort int32, toPort int32, rt string) (bool, error) {
 	switch rt {
 	case "ingress":
 		return CreateSecurityGroupIngressRule(e2eCtx, sgID, sgrDescription, cidr, protocol, fromPort, toPort)
@@ -2231,14 +2236,14 @@ func CreateSecurityGroupRule(e2eCtx *E2EContext, sgID string, sgrDescription str
 	return false, nil
 }
 
-func CreateSecurityGroupIngressRuleWithSourceSG(e2eCtx *E2EContext, sgID string, protocol string, toPort int64, sourceSecurityGroupID string) (bool, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+func CreateSecurityGroupIngressRuleWithSourceSG(e2eCtx *E2EContext, sgID string, protocol string, toPort int32, sourceSecurityGroupID string) (bool, error) {
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
-	ipPerm := &ec2.IpPermission{
-		FromPort:   aws.Int64(toPort),
-		ToPort:     aws.Int64(toPort),
+	ipPerm := ec2types.IpPermission{
+		FromPort:   aws.Int32(toPort),
+		ToPort:     aws.Int32(toPort),
 		IpProtocol: aws.String(protocol),
-		UserIdGroupPairs: []*ec2.UserIdGroupPair{
+		UserIdGroupPairs: []ec2types.UserIdGroupPair{
 			{
 				GroupId: aws.String(sourceSecurityGroupID),
 			},
@@ -2246,12 +2251,12 @@ func CreateSecurityGroupIngressRuleWithSourceSG(e2eCtx *E2EContext, sgID string,
 	}
 	input := &ec2.AuthorizeSecurityGroupIngressInput{
 		GroupId: aws.String(sgID),
-		IpPermissions: []*ec2.IpPermission{
+		IpPermissions: []ec2types.IpPermission{
 			ipPerm,
 		},
 	}
 
-	result, err := ec2Svc.AuthorizeSecurityGroupIngress(input)
+	result, err := ec2Svc.AuthorizeSecurityGroupIngress(context.TODO(), input)
 	if err != nil {
 		return false, err
 	}
@@ -2259,28 +2264,28 @@ func CreateSecurityGroupIngressRuleWithSourceSG(e2eCtx *E2EContext, sgID string,
 }
 
 func DeleteSecurityGroupIngressRule(e2eCtx *E2EContext, sgID, sgrID string) bool {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.RevokeSecurityGroupIngressInput{
-		SecurityGroupRuleIds: aws.StringSlice([]string{sgrID}),
+		SecurityGroupRuleIds: []string{sgrID},
 		GroupId:              aws.String(sgID),
 	}
 
-	if _, err := ec2Svc.RevokeSecurityGroupIngress(input); err != nil {
+	if _, err := ec2Svc.RevokeSecurityGroupIngress(context.TODO(), input); err != nil {
 		return false
 	}
 	return true
 }
 
 func DeleteSecurityGroupEgressRule(e2eCtx *E2EContext, sgID, sgrID string) bool {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 
 	input := &ec2.RevokeSecurityGroupEgressInput{
-		SecurityGroupRuleIds: aws.StringSlice([]string{sgrID}),
+		SecurityGroupRuleIds: []string{sgrID},
 		GroupId:              aws.String(sgID),
 	}
 
-	if _, err := ec2Svc.RevokeSecurityGroupEgress(input); err != nil {
+	if _, err := ec2Svc.RevokeSecurityGroupEgress(context.TODO(), input); err != nil {
 		return false
 	}
 	return true
diff --git a/test/e2e/shared/exec.go b/test/e2e/shared/exec.go
index 56047a6bb..e02bea706 100644
--- a/test/e2e/shared/exec.go
+++ b/test/e2e/shared/exec.go
@@ -29,8 +29,8 @@ import (
 	"regexp"
 	"time"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
 	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/aws/aws-sdk-go/service/ssm"
 	expect "github.com/google/goexpect"
 )
@@ -42,8 +42,8 @@ type instance struct {
 
 // allMachines gets all EC2 instances at once, to save on DescribeInstances calls.
 func allMachines(ctx context.Context, e2eCtx *E2EContext) ([]instance, error) {
-	ec2Svc := ec2.New(e2eCtx.AWSSession)
-	resp, err := ec2Svc.DescribeInstancesWithContext(ctx, &ec2.DescribeInstancesInput{})
+	ec2Svc := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
+	resp, err := ec2Svc.DescribeInstances(ctx, &ec2.DescribeInstancesInput{})
 	if err != nil {
 		return nil, err
 	}
diff --git a/test/e2e/shared/suite.go b/test/e2e/shared/suite.go
index 65e51a03e..027bfe367 100644
--- a/test/e2e/shared/suite.go
+++ b/test/e2e/shared/suite.go
@@ -154,7 +154,7 @@ func Node1BeforeSuite(e2eCtx *E2EContext) []byte {
 
 	ensureStackTags(e2eCtx.AWSSession, bootstrapTemplate.Spec.StackName, bootstrapTags)
 	ensureNoServiceLinkedRoles(context.TODO(), e2eCtx.AWSSessionV2)
-	ensureSSHKeyPair(e2eCtx.AWSSession, DefaultSSHKeyPairName)
+	ensureSSHKeyPair(*e2eCtx.AWSSessionV2, DefaultSSHKeyPairName)
 	e2eCtx.Environment.BootstrapAccessKey = newUserAccessKey(context.TODO(), e2eCtx.AWSSessionV2, bootstrapTemplate.Spec.BootstrapUser.UserName)
 	e2eCtx.BootstrapUserAWSSession = NewAWSSessionWithKey(e2eCtx.Environment.BootstrapAccessKey)
 	e2eCtx.BootstrapUserAWSSessionV2 = NewAWSSessionWithKeyV2(e2eCtx.Environment.BootstrapAccessKey)
@@ -234,7 +234,7 @@ func AllNodesBeforeSuite(e2eCtx *E2EContext, data []byte) {
 	e2eCtx.Settings.GinkgoSlowSpecThreshold = conf.GinkgoSlowSpecThreshold
 	e2eCtx.AWSSession = NewAWSSession()
 	e2eCtx.AWSSessionV2 = NewAWSSessionV2()
-	azs := GetAvailabilityZones(e2eCtx.AWSSession)
+	azs := GetAvailabilityZones(*e2eCtx.AWSSessionV2)
 	SetEnvVar(AwsAvailabilityZone1, *azs[0].ZoneName, false)
 	SetEnvVar(AwsAvailabilityZone2, *azs[1].ZoneName, false)
 	SetEnvVar("AWS_REGION", conf.Region, false)
diff --git a/test/e2e/suites/unmanaged/helpers_test.go b/test/e2e/suites/unmanaged/helpers_test.go
index 4c4959dfe..e5a822429 100644
--- a/test/e2e/suites/unmanaged/helpers_test.go
+++ b/test/e2e/suites/unmanaged/helpers_test.go
@@ -30,9 +30,10 @@ import (
 	"strings"
 	"time"
 
+	"github.com/aws/aws-sdk-go-v2/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/aws/aws-sdk-go/service/efs"
 	"github.com/blang/semver"
 	"github.com/onsi/ginkgo/v2"
@@ -47,6 +48,7 @@ import (
 	crclient "sigs.k8s.io/controller-runtime/pkg/client"
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
+	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/utils"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/test/e2e/shared"
 	clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
 	bootstrapv1 "sigs.k8s.io/cluster-api/bootstrap/kubeadm/api/v1beta1"
@@ -149,24 +151,24 @@ func getSubnetID(filterKey, filterValue, clusterName string) *string {
 	var subnetOutput *ec2.DescribeSubnetsOutput
 	var err error
 
-	ec2Client := ec2.New(e2eCtx.AWSSession)
+	ec2Client := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 	subnetInput := &ec2.DescribeSubnetsInput{
-		Filters: []*ec2.Filter{
+		Filters: []types.Filter{
 			{
 				Name: aws.String(filterKey),
-				Values: []*string{
-					aws.String(filterValue),
+				Values: []string{
+					filterValue,
 				},
 			},
 			{
 				Name:   aws.String("tag-key"),
-				Values: aws.StringSlice([]string{"sigs.k8s.io/cluster-api-provider-aws/cluster/" + clusterName}),
+				Values: []string{"sigs.k8s.io/cluster-api-provider-aws/cluster/" + clusterName},
 			},
 		},
 	}
 
 	Eventually(func() int {
-		subnetOutput, err = ec2Client.DescribeSubnets(subnetInput)
+		subnetOutput, err = ec2Client.DescribeSubnets(context.TODO(), subnetInput)
 		Expect(err).NotTo(HaveOccurred())
 		return len(subnetOutput.Subnets)
 	}, e2eCtx.E2EConfig.GetIntervals("", "wait-infra-subnets")...).Should(Equal(1))
@@ -318,15 +320,15 @@ func makeMachineDeployment(namespace, mdName, clusterName string, az *string, re
 
 func assertSpotInstanceType(instanceID string) {
 	ginkgo.By(fmt.Sprintf("Finding EC2 spot instance with ID: %s", instanceID))
-	ec2Client := ec2.New(e2eCtx.AWSSession)
+	ec2Client := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 	input := &ec2.DescribeInstancesInput{
-		InstanceIds: []*string{
-			aws.String(instanceID[strings.LastIndex(instanceID, "/")+1:]),
+		InstanceIds: []string{
+			instanceID[strings.LastIndex(instanceID, "/")+1:],
 		},
-		Filters: []*ec2.Filter{{Name: aws.String("instance-lifecycle"), Values: aws.StringSlice([]string{"spot"})}},
+		Filters: []types.Filter{{Name: aws.String("instance-lifecycle"), Values: []string{"spot"}}},
 	}
 
-	result, err := ec2Client.DescribeInstances(input)
+	result, err := ec2Client.DescribeInstances(context.TODO(), input)
 	Expect(err).To(BeNil())
 	Expect(len(result.Reservations)).To(Equal(1))
 	Expect(len(result.Reservations[0].Instances)).To(Equal(1))
@@ -334,14 +336,14 @@ func assertSpotInstanceType(instanceID string) {
 
 func assertInstanceMetadataOptions(instanceID string, expected infrav1.InstanceMetadataOptions) {
 	ginkgo.By(fmt.Sprintf("Finding EC2 instance with ID: %s", instanceID))
-	ec2Client := ec2.New(e2eCtx.AWSSession)
+	ec2Client := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 	input := &ec2.DescribeInstancesInput{
-		InstanceIds: []*string{
-			aws.String(instanceID[strings.LastIndex(instanceID, "/")+1:]),
+		InstanceIds: []string{
+			instanceID[strings.LastIndex(instanceID, "/")+1:],
 		},
 	}
 
-	result, err := ec2Client.DescribeInstances(input)
+	result, err := ec2Client.DescribeInstances(context.TODO(), input)
 	Expect(err).To(BeNil())
 	Expect(len(result.Reservations)).To(Equal(1))
 	Expect(len(result.Reservations[0].Instances)).To(Equal(1))
@@ -349,21 +351,21 @@ func assertInstanceMetadataOptions(instanceID string, expected infrav1.InstanceM
 	metadataOptions := result.Reservations[0].Instances[0].MetadataOptions
 	Expect(metadataOptions).ToNot(BeNil())
 
-	Expect(metadataOptions.HttpTokens).To(HaveValue(Equal(string(expected.HTTPTokens))))
-	Expect(metadataOptions.HttpEndpoint).To(HaveValue(Equal(string(expected.HTTPEndpoint))))
-	Expect(metadataOptions.InstanceMetadataTags).To(HaveValue(Equal(string(expected.InstanceMetadataTags))))
-	Expect(metadataOptions.HttpPutResponseHopLimit).To(HaveValue(Equal(expected.HTTPPutResponseHopLimit)))
+	Expect(string(metadataOptions.HttpTokens)).To(HaveValue(Equal(string(expected.HTTPTokens))))
+	Expect(string(metadataOptions.HttpEndpoint)).To(HaveValue(Equal(string(expected.HTTPEndpoint))))
+	Expect(string(metadataOptions.InstanceMetadataTags)).To(HaveValue(Equal(string(expected.InstanceMetadataTags))))
+	Expect(utils.ToInt64Value(metadataOptions.HttpPutResponseHopLimit)).To(HaveValue(Equal(expected.HTTPPutResponseHopLimit)))
 }
 
 func assertUnencryptedUserDataIgnition(instanceID string, expected string) {
 	ginkgo.By(fmt.Sprintf("Finding EC2 instance with ID: %s", instanceID))
-	ec2Client := ec2.New(e2eCtx.AWSSession)
+	ec2Client := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 	input := &ec2.DescribeInstanceAttributeInput{
-		Attribute:  aws.String(ec2.InstanceAttributeNameUserData),
+		Attribute:  types.InstanceAttributeNameUserData,
 		InstanceId: aws.String(instanceID[strings.LastIndex(instanceID, "/")+1:]),
 	}
 
-	result, err := ec2Client.DescribeInstanceAttribute(input)
+	result, err := ec2Client.DescribeInstanceAttribute(context.TODO(), input)
 	Expect(err).ToNot(HaveOccurred(), "expected DescribeInstanceAttribute call to succeed")
 
 	userData, err := base64.StdEncoding.DecodeString(*result.UserData.Value)
@@ -373,18 +375,18 @@ func assertUnencryptedUserDataIgnition(instanceID string, expected string) {
 
 func terminateInstance(instanceID string) {
 	ginkgo.By(fmt.Sprintf("Terminating EC2 instance with ID: %s", instanceID))
-	ec2Client := ec2.New(e2eCtx.AWSSession)
+	ec2Client := ec2.NewFromConfig(*e2eCtx.AWSSessionV2)
 	input := &ec2.TerminateInstancesInput{
-		InstanceIds: []*string{
-			aws.String(instanceID[strings.LastIndex(instanceID, "/")+1:]),
+		InstanceIds: []string{
+			instanceID[strings.LastIndex(instanceID, "/")+1:],
 		},
 	}
 
-	result, err := ec2Client.TerminateInstances(input)
+	result, err := ec2Client.TerminateInstances(context.TODO(), input)
 	Expect(err).To(BeNil())
 	Expect(len(result.TerminatingInstances)).To(Equal(1))
 	termCode := int64(32)
-	Expect(*result.TerminatingInstances[0].CurrentState.Code).To(Equal(termCode))
+	Expect(utils.ToInt64Value(result.TerminatingInstances[0].CurrentState.Code)).To(Equal(termCode))
 }
 
 // LatestCIReleaseForVersion returns the latest ci release of a specific version.
@@ -453,14 +455,14 @@ func createEFS() *efs.FileSystemDescription {
 	return efs
 }
 
-func createSecurityGroupForEFS(clusterName string, vpc *ec2.Vpc) *ec2.CreateSecurityGroupOutput {
+func createSecurityGroupForEFS(clusterName string, vpc *types.Vpc) *ec2.CreateSecurityGroupOutput {
 	securityGroup, err := shared.CreateSecurityGroup(e2eCtx, clusterName+"-efs-sg", "security group for EFS Access", *(vpc.VpcId))
 	Expect(err).NotTo(HaveOccurred())
-	nameFilter := &ec2.Filter{
+	nameFilter := types.Filter{
 		Name:   aws.String("tag:Name"),
-		Values: aws.StringSlice([]string{clusterName + "-node"}),
+		Values: []string{clusterName + "-node"},
 	}
-	nodeSecurityGroups, err := shared.GetSecurityGroupByFilters(e2eCtx, []*ec2.Filter{
+	nodeSecurityGroups, err := shared.GetSecurityGroupByFilters(e2eCtx, []types.Filter{
 		nameFilter,
 	})
 	Expect(err).NotTo(HaveOccurred())
@@ -470,7 +472,7 @@ func createSecurityGroupForEFS(clusterName string, vpc *ec2.Vpc) *ec2.CreateSecu
 	return securityGroup
 }
 
-func createMountTarget(efs *efs.FileSystemDescription, securityGroup *ec2.CreateSecurityGroupOutput, vpc *ec2.Vpc) *efs.MountTargetDescription {
+func createMountTarget(efs *efs.FileSystemDescription, securityGroup *ec2.CreateSecurityGroupOutput, vpc *types.Vpc) *efs.MountTargetDescription {
 	mt, err := shared.CreateMountTargetOnEFS(e2eCtx, aws.StringValue(efs.FileSystemId), aws.StringValue(vpc.VpcId), aws.StringValue(securityGroup.GroupId))
 	Expect(err).NotTo(HaveOccurred())
 	Eventually(func() (string, error) {
diff --git a/test/e2e/suites/unmanaged/unmanaged_functional_test.go b/test/e2e/suites/unmanaged/unmanaged_functional_test.go
index 611361439..77de9a9dd 100644
--- a/test/e2e/suites/unmanaged/unmanaged_functional_test.go
+++ b/test/e2e/suites/unmanaged/unmanaged_functional_test.go
@@ -27,7 +27,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/aws/aws-sdk-go-v2/service/ec2/types"
 	"github.com/blang/semver"
 	"github.com/gofrs/flock"
 	"github.com/onsi/ginkgo/v2"
@@ -391,7 +391,7 @@ var _ = ginkgo.Context("[unmanaged] [functional]", func() {
 			ginkgo.By("Creating Machine Deployment in non-configured Availability Zone")
 			md2Name := clusterName + "-md-2"
 			// By default, first availability zone will be used for cluster resources. This step attempts to create a machine deployment in the second availability zone
-			invalidAz := shared.GetAvailabilityZones(e2eCtx.AWSSession)[1].ZoneName
+			invalidAz := shared.GetAvailabilityZones(*e2eCtx.AWSSessionV2)[1].ZoneName
 			framework.CreateMachineDeployment(ctx, framework.CreateMachineDeploymentInput{
 				Creator:                 e2eCtx.Environment.BootstrapClusterProxy.GetClient(),
 				MachineDeployment:       makeMachineDeployment(namespace.Name, md2Name, clusterName, invalidAz, 1),
@@ -630,7 +630,7 @@ var _ = ginkgo.Context("[unmanaged] [functional]", func() {
 		wlClusterName := fmt.Sprintf("%s-%s", specName, util.RandomString(6))
 		wlClusterInfra := new(shared.AWSInfrastructure)
 
-		var cPeering *ec2.VpcPeeringConnection
+		var cPeering *types.VpcPeeringConnection
 
 		// Some infrastructure creation was moved to a setup node to better organize the test.
 		ginkgo.JustBeforeEach(func() {
@@ -952,7 +952,7 @@ var _ = ginkgo.Context("[unmanaged] [functional]", func() {
 			Expect(err).NotTo(HaveOccurred())
 			Expect(endpoints).NotTo(BeNil())
 			Expect(len(endpoints)).To(Equal(1))
-			Expect(*endpoints[0].VpcEndpointType).To(Equal("Gateway"))
+			Expect(string(endpoints[0].VpcEndpointType)).To(Equal("Gateway"))
 			Expect(*endpoints[0].ServiceName).To(Equal("com.amazonaws." + awsCluster.Spec.Region + ".s3"))
 			Expect(*endpoints[0].VpcId).To(Equal(*vpc.VpcId))
 
diff --git a/test/mocks/aws_ec2api_mock.go b/test/mocks/aws_ec2api_mock.go
index 09c20793d..835e1f166 100644
--- a/test/mocks/aws_ec2api_mock.go
+++ b/test/mocks/aws_ec2api_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/ec2/ec2iface (interfaces: EC2API)
+// Source: sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/common (interfaces: EC2API)
 
 // 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"
-	ec2 "github.com/aws/aws-sdk-go/service/ec2"
+	ec2 "github.com/aws/aws-sdk-go-v2/service/ec2"
 	gomock "github.com/golang/mock/gomock"
 )
 
@@ -52,37060 +51,1342 @@ func (m *MockEC2API) EXPECT() *MockEC2APIMockRecorder {
 	return m.recorder
 }
 
-// AcceptAddressTransfer mocks base method.
-func (m *MockEC2API) AcceptAddressTransfer(arg0 *ec2.AcceptAddressTransferInput) (*ec2.AcceptAddressTransferOutput, error) {
+// AllocateAddress mocks base method.
+func (m *MockEC2API) AllocateAddress(arg0 context.Context, arg1 *ec2.AllocateAddressInput, arg2 ...func(*ec2.Options)) (*ec2.AllocateAddressOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AcceptAddressTransfer", arg0)
-	ret0, _ := ret[0].(*ec2.AcceptAddressTransferOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AllocateAddress", varargs...)
+	ret0, _ := ret[0].(*ec2.AllocateAddressOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AcceptAddressTransfer indicates an expected call of AcceptAddressTransfer.
-func (mr *MockEC2APIMockRecorder) AcceptAddressTransfer(arg0 interface{}) *gomock.Call {
+// AllocateAddress indicates an expected call of AllocateAddress.
+func (mr *MockEC2APIMockRecorder) AllocateAddress(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptAddressTransfer", reflect.TypeOf((*MockEC2API)(nil).AcceptAddressTransfer), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateAddress", reflect.TypeOf((*MockEC2API)(nil).AllocateAddress), varargs...)
 }
 
-// AcceptAddressTransferRequest mocks base method.
-func (m *MockEC2API) AcceptAddressTransferRequest(arg0 *ec2.AcceptAddressTransferInput) (*request.Request, *ec2.AcceptAddressTransferOutput) {
+// AssociateAddress mocks base method.
+func (m *MockEC2API) AssociateAddress(arg0 context.Context, arg1 *ec2.AssociateAddressInput, arg2 ...func(*ec2.Options)) (*ec2.AssociateAddressOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AcceptAddressTransferRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AcceptAddressTransferOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AssociateAddress", varargs...)
+	ret0, _ := ret[0].(*ec2.AssociateAddressOutput)
+	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AcceptAddressTransferRequest indicates an expected call of AcceptAddressTransferRequest.
-func (mr *MockEC2APIMockRecorder) AcceptAddressTransferRequest(arg0 interface{}) *gomock.Call {
+// AssociateAddress indicates an expected call of AssociateAddress.
+func (mr *MockEC2APIMockRecorder) AssociateAddress(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptAddressTransferRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptAddressTransferRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateAddress", reflect.TypeOf((*MockEC2API)(nil).AssociateAddress), varargs...)
 }
 
-// AcceptAddressTransferWithContext mocks base method.
-func (m *MockEC2API) AcceptAddressTransferWithContext(arg0 context.Context, arg1 *ec2.AcceptAddressTransferInput, arg2 ...request.Option) (*ec2.AcceptAddressTransferOutput, error) {
+// AssociateRouteTable mocks base method.
+func (m *MockEC2API) AssociateRouteTable(arg0 context.Context, arg1 *ec2.AssociateRouteTableInput, arg2 ...func(*ec2.Options)) (*ec2.AssociateRouteTableOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AcceptAddressTransferWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AcceptAddressTransferOutput)
+	ret := m.ctrl.Call(m, "AssociateRouteTable", varargs...)
+	ret0, _ := ret[0].(*ec2.AssociateRouteTableOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AcceptAddressTransferWithContext indicates an expected call of AcceptAddressTransferWithContext.
-func (mr *MockEC2APIMockRecorder) AcceptAddressTransferWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// AssociateRouteTable indicates an expected call of AssociateRouteTable.
+func (mr *MockEC2APIMockRecorder) AssociateRouteTable(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, "AcceptAddressTransferWithContext", reflect.TypeOf((*MockEC2API)(nil).AcceptAddressTransferWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateRouteTable", reflect.TypeOf((*MockEC2API)(nil).AssociateRouteTable), varargs...)
 }
 
-// AcceptReservedInstancesExchangeQuote mocks base method.
-func (m *MockEC2API) AcceptReservedInstancesExchangeQuote(arg0 *ec2.AcceptReservedInstancesExchangeQuoteInput) (*ec2.AcceptReservedInstancesExchangeQuoteOutput, error) {
+// AssociateVpcCidrBlock mocks base method.
+func (m *MockEC2API) AssociateVpcCidrBlock(arg0 context.Context, arg1 *ec2.AssociateVpcCidrBlockInput, arg2 ...func(*ec2.Options)) (*ec2.AssociateVpcCidrBlockOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AcceptReservedInstancesExchangeQuote", arg0)
-	ret0, _ := ret[0].(*ec2.AcceptReservedInstancesExchangeQuoteOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AssociateVpcCidrBlock", varargs...)
+	ret0, _ := ret[0].(*ec2.AssociateVpcCidrBlockOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AcceptReservedInstancesExchangeQuote indicates an expected call of AcceptReservedInstancesExchangeQuote.
-func (mr *MockEC2APIMockRecorder) AcceptReservedInstancesExchangeQuote(arg0 interface{}) *gomock.Call {
+// AssociateVpcCidrBlock indicates an expected call of AssociateVpcCidrBlock.
+func (mr *MockEC2APIMockRecorder) AssociateVpcCidrBlock(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptReservedInstancesExchangeQuote", reflect.TypeOf((*MockEC2API)(nil).AcceptReservedInstancesExchangeQuote), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVpcCidrBlock", reflect.TypeOf((*MockEC2API)(nil).AssociateVpcCidrBlock), varargs...)
 }
 
-// AcceptReservedInstancesExchangeQuoteRequest mocks base method.
-func (m *MockEC2API) AcceptReservedInstancesExchangeQuoteRequest(arg0 *ec2.AcceptReservedInstancesExchangeQuoteInput) (*request.Request, *ec2.AcceptReservedInstancesExchangeQuoteOutput) {
+// AttachInternetGateway mocks base method.
+func (m *MockEC2API) AttachInternetGateway(arg0 context.Context, arg1 *ec2.AttachInternetGatewayInput, arg2 ...func(*ec2.Options)) (*ec2.AttachInternetGatewayOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AcceptReservedInstancesExchangeQuoteRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AcceptReservedInstancesExchangeQuoteOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AttachInternetGateway", varargs...)
+	ret0, _ := ret[0].(*ec2.AttachInternetGatewayOutput)
+	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AcceptReservedInstancesExchangeQuoteRequest indicates an expected call of AcceptReservedInstancesExchangeQuoteRequest.
-func (mr *MockEC2APIMockRecorder) AcceptReservedInstancesExchangeQuoteRequest(arg0 interface{}) *gomock.Call {
+// AttachInternetGateway indicates an expected call of AttachInternetGateway.
+func (mr *MockEC2APIMockRecorder) AttachInternetGateway(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptReservedInstancesExchangeQuoteRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptReservedInstancesExchangeQuoteRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachInternetGateway", reflect.TypeOf((*MockEC2API)(nil).AttachInternetGateway), varargs...)
 }
 
-// AcceptReservedInstancesExchangeQuoteWithContext mocks base method.
-func (m *MockEC2API) AcceptReservedInstancesExchangeQuoteWithContext(arg0 context.Context, arg1 *ec2.AcceptReservedInstancesExchangeQuoteInput, arg2 ...request.Option) (*ec2.AcceptReservedInstancesExchangeQuoteOutput, error) {
+// AuthorizeSecurityGroupIngress mocks base method.
+func (m *MockEC2API) AuthorizeSecurityGroupIngress(arg0 context.Context, arg1 *ec2.AuthorizeSecurityGroupIngressInput, arg2 ...func(*ec2.Options)) (*ec2.AuthorizeSecurityGroupIngressOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AcceptReservedInstancesExchangeQuoteWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AcceptReservedInstancesExchangeQuoteOutput)
+	ret := m.ctrl.Call(m, "AuthorizeSecurityGroupIngress", varargs...)
+	ret0, _ := ret[0].(*ec2.AuthorizeSecurityGroupIngressOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AcceptReservedInstancesExchangeQuoteWithContext indicates an expected call of AcceptReservedInstancesExchangeQuoteWithContext.
-func (mr *MockEC2APIMockRecorder) AcceptReservedInstancesExchangeQuoteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// AuthorizeSecurityGroupIngress indicates an expected call of AuthorizeSecurityGroupIngress.
+func (mr *MockEC2APIMockRecorder) AuthorizeSecurityGroupIngress(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, "AcceptReservedInstancesExchangeQuoteWithContext", reflect.TypeOf((*MockEC2API)(nil).AcceptReservedInstancesExchangeQuoteWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupIngress", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupIngress), varargs...)
 }
 
-// AcceptTransitGatewayMulticastDomainAssociations mocks base method.
-func (m *MockEC2API) AcceptTransitGatewayMulticastDomainAssociations(arg0 *ec2.AcceptTransitGatewayMulticastDomainAssociationsInput) (*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput, error) {
+// CreateCarrierGateway mocks base method.
+func (m *MockEC2API) CreateCarrierGateway(arg0 context.Context, arg1 *ec2.CreateCarrierGatewayInput, arg2 ...func(*ec2.Options)) (*ec2.CreateCarrierGatewayOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AcceptTransitGatewayMulticastDomainAssociations", arg0)
-	ret0, _ := ret[0].(*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateCarrierGateway", varargs...)
+	ret0, _ := ret[0].(*ec2.CreateCarrierGatewayOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AcceptTransitGatewayMulticastDomainAssociations indicates an expected call of AcceptTransitGatewayMulticastDomainAssociations.
-func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayMulticastDomainAssociations(arg0 interface{}) *gomock.Call {
+// CreateCarrierGateway indicates an expected call of CreateCarrierGateway.
+func (mr *MockEC2APIMockRecorder) CreateCarrierGateway(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayMulticastDomainAssociations", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayMulticastDomainAssociations), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCarrierGateway", reflect.TypeOf((*MockEC2API)(nil).CreateCarrierGateway), varargs...)
 }
 
-// AcceptTransitGatewayMulticastDomainAssociationsRequest mocks base method.
-func (m *MockEC2API) AcceptTransitGatewayMulticastDomainAssociationsRequest(arg0 *ec2.AcceptTransitGatewayMulticastDomainAssociationsInput) (*request.Request, *ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput) {
+// CreateEgressOnlyInternetGateway mocks base method.
+func (m *MockEC2API) CreateEgressOnlyInternetGateway(arg0 context.Context, arg1 *ec2.CreateEgressOnlyInternetGatewayInput, arg2 ...func(*ec2.Options)) (*ec2.CreateEgressOnlyInternetGatewayOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AcceptTransitGatewayMulticastDomainAssociationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateEgressOnlyInternetGateway", varargs...)
+	ret0, _ := ret[0].(*ec2.CreateEgressOnlyInternetGatewayOutput)
+	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AcceptTransitGatewayMulticastDomainAssociationsRequest indicates an expected call of AcceptTransitGatewayMulticastDomainAssociationsRequest.
-func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayMulticastDomainAssociationsRequest(arg0 interface{}) *gomock.Call {
+// CreateEgressOnlyInternetGateway indicates an expected call of CreateEgressOnlyInternetGateway.
+func (mr *MockEC2APIMockRecorder) CreateEgressOnlyInternetGateway(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayMulticastDomainAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayMulticastDomainAssociationsRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEgressOnlyInternetGateway", reflect.TypeOf((*MockEC2API)(nil).CreateEgressOnlyInternetGateway), varargs...)
 }
 
-// AcceptTransitGatewayMulticastDomainAssociationsWithContext mocks base method.
-func (m *MockEC2API) AcceptTransitGatewayMulticastDomainAssociationsWithContext(arg0 context.Context, arg1 *ec2.AcceptTransitGatewayMulticastDomainAssociationsInput, arg2 ...request.Option) (*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput, error) {
+// CreateInternetGateway mocks base method.
+func (m *MockEC2API) CreateInternetGateway(arg0 context.Context, arg1 *ec2.CreateInternetGatewayInput, arg2 ...func(*ec2.Options)) (*ec2.CreateInternetGatewayOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AcceptTransitGatewayMulticastDomainAssociationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput)
+	ret := m.ctrl.Call(m, "CreateInternetGateway", varargs...)
+	ret0, _ := ret[0].(*ec2.CreateInternetGatewayOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AcceptTransitGatewayMulticastDomainAssociationsWithContext indicates an expected call of AcceptTransitGatewayMulticastDomainAssociationsWithContext.
-func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayMulticastDomainAssociationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// CreateInternetGateway indicates an expected call of CreateInternetGateway.
+func (mr *MockEC2APIMockRecorder) CreateInternetGateway(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, "AcceptTransitGatewayMulticastDomainAssociationsWithContext", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayMulticastDomainAssociationsWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInternetGateway", reflect.TypeOf((*MockEC2API)(nil).CreateInternetGateway), varargs...)
 }
 
-// AcceptTransitGatewayPeeringAttachment mocks base method.
-func (m *MockEC2API) AcceptTransitGatewayPeeringAttachment(arg0 *ec2.AcceptTransitGatewayPeeringAttachmentInput) (*ec2.AcceptTransitGatewayPeeringAttachmentOutput, error) {
+// CreateLaunchTemplate mocks base method.
+func (m *MockEC2API) CreateLaunchTemplate(arg0 context.Context, arg1 *ec2.CreateLaunchTemplateInput, arg2 ...func(*ec2.Options)) (*ec2.CreateLaunchTemplateOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AcceptTransitGatewayPeeringAttachment", arg0)
-	ret0, _ := ret[0].(*ec2.AcceptTransitGatewayPeeringAttachmentOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateLaunchTemplate", varargs...)
+	ret0, _ := ret[0].(*ec2.CreateLaunchTemplateOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AcceptTransitGatewayPeeringAttachment indicates an expected call of AcceptTransitGatewayPeeringAttachment.
-func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayPeeringAttachment(arg0 interface{}) *gomock.Call {
+// CreateLaunchTemplate indicates an expected call of CreateLaunchTemplate.
+func (mr *MockEC2APIMockRecorder) CreateLaunchTemplate(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayPeeringAttachment", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayPeeringAttachment), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplate", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplate), varargs...)
 }
 
-// AcceptTransitGatewayPeeringAttachmentRequest mocks base method.
-func (m *MockEC2API) AcceptTransitGatewayPeeringAttachmentRequest(arg0 *ec2.AcceptTransitGatewayPeeringAttachmentInput) (*request.Request, *ec2.AcceptTransitGatewayPeeringAttachmentOutput) {
+// CreateLaunchTemplateVersion mocks base method.
+func (m *MockEC2API) CreateLaunchTemplateVersion(arg0 context.Context, arg1 *ec2.CreateLaunchTemplateVersionInput, arg2 ...func(*ec2.Options)) (*ec2.CreateLaunchTemplateVersionOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AcceptTransitGatewayPeeringAttachmentRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AcceptTransitGatewayPeeringAttachmentOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateLaunchTemplateVersion", varargs...)
+	ret0, _ := ret[0].(*ec2.CreateLaunchTemplateVersionOutput)
+	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AcceptTransitGatewayPeeringAttachmentRequest indicates an expected call of AcceptTransitGatewayPeeringAttachmentRequest.
-func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayPeeringAttachmentRequest(arg0 interface{}) *gomock.Call {
+// CreateLaunchTemplateVersion indicates an expected call of CreateLaunchTemplateVersion.
+func (mr *MockEC2APIMockRecorder) CreateLaunchTemplateVersion(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayPeeringAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayPeeringAttachmentRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplateVersion", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplateVersion), varargs...)
 }
 
-// AcceptTransitGatewayPeeringAttachmentWithContext mocks base method.
-func (m *MockEC2API) AcceptTransitGatewayPeeringAttachmentWithContext(arg0 context.Context, arg1 *ec2.AcceptTransitGatewayPeeringAttachmentInput, arg2 ...request.Option) (*ec2.AcceptTransitGatewayPeeringAttachmentOutput, error) {
+// CreateNatGateway mocks base method.
+func (m *MockEC2API) CreateNatGateway(arg0 context.Context, arg1 *ec2.CreateNatGatewayInput, arg2 ...func(*ec2.Options)) (*ec2.CreateNatGatewayOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AcceptTransitGatewayPeeringAttachmentWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AcceptTransitGatewayPeeringAttachmentOutput)
+	ret := m.ctrl.Call(m, "CreateNatGateway", varargs...)
+	ret0, _ := ret[0].(*ec2.CreateNatGatewayOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AcceptTransitGatewayPeeringAttachmentWithContext indicates an expected call of AcceptTransitGatewayPeeringAttachmentWithContext.
-func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayPeeringAttachmentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// CreateNatGateway indicates an expected call of CreateNatGateway.
+func (mr *MockEC2APIMockRecorder) CreateNatGateway(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, "AcceptTransitGatewayPeeringAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayPeeringAttachmentWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNatGateway", reflect.TypeOf((*MockEC2API)(nil).CreateNatGateway), varargs...)
 }
 
-// AcceptTransitGatewayVpcAttachment mocks base method.
-func (m *MockEC2API) AcceptTransitGatewayVpcAttachment(arg0 *ec2.AcceptTransitGatewayVpcAttachmentInput) (*ec2.AcceptTransitGatewayVpcAttachmentOutput, error) {
+// CreateRoute mocks base method.
+func (m *MockEC2API) CreateRoute(arg0 context.Context, arg1 *ec2.CreateRouteInput, arg2 ...func(*ec2.Options)) (*ec2.CreateRouteOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AcceptTransitGatewayVpcAttachment", arg0)
-	ret0, _ := ret[0].(*ec2.AcceptTransitGatewayVpcAttachmentOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateRoute", varargs...)
+	ret0, _ := ret[0].(*ec2.CreateRouteOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AcceptTransitGatewayVpcAttachment indicates an expected call of AcceptTransitGatewayVpcAttachment.
-func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call {
+// CreateRoute indicates an expected call of CreateRoute.
+func (mr *MockEC2APIMockRecorder) CreateRoute(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayVpcAttachment), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRoute", reflect.TypeOf((*MockEC2API)(nil).CreateRoute), varargs...)
 }
 
-// AcceptTransitGatewayVpcAttachmentRequest mocks base method.
-func (m *MockEC2API) AcceptTransitGatewayVpcAttachmentRequest(arg0 *ec2.AcceptTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.AcceptTransitGatewayVpcAttachmentOutput) {
+// CreateRouteTable mocks base method.
+func (m *MockEC2API) CreateRouteTable(arg0 context.Context, arg1 *ec2.CreateRouteTableInput, arg2 ...func(*ec2.Options)) (*ec2.CreateRouteTableOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AcceptTransitGatewayVpcAttachmentRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AcceptTransitGatewayVpcAttachmentOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateRouteTable", varargs...)
+	ret0, _ := ret[0].(*ec2.CreateRouteTableOutput)
+	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AcceptTransitGatewayVpcAttachmentRequest indicates an expected call of AcceptTransitGatewayVpcAttachmentRequest.
-func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call {
+// CreateRouteTable indicates an expected call of CreateRouteTable.
+func (mr *MockEC2APIMockRecorder) CreateRouteTable(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayVpcAttachmentRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouteTable", reflect.TypeOf((*MockEC2API)(nil).CreateRouteTable), varargs...)
 }
 
-// AcceptTransitGatewayVpcAttachmentWithContext mocks base method.
-func (m *MockEC2API) AcceptTransitGatewayVpcAttachmentWithContext(arg0 context.Context, arg1 *ec2.AcceptTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.AcceptTransitGatewayVpcAttachmentOutput, error) {
+// CreateSecurityGroup mocks base method.
+func (m *MockEC2API) CreateSecurityGroup(arg0 context.Context, arg1 *ec2.CreateSecurityGroupInput, arg2 ...func(*ec2.Options)) (*ec2.CreateSecurityGroupOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AcceptTransitGatewayVpcAttachmentWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AcceptTransitGatewayVpcAttachmentOutput)
+	ret := m.ctrl.Call(m, "CreateSecurityGroup", varargs...)
+	ret0, _ := ret[0].(*ec2.CreateSecurityGroupOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AcceptTransitGatewayVpcAttachmentWithContext indicates an expected call of AcceptTransitGatewayVpcAttachmentWithContext.
-func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayVpcAttachmentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// CreateSecurityGroup indicates an expected call of CreateSecurityGroup.
+func (mr *MockEC2APIMockRecorder) CreateSecurityGroup(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, "AcceptTransitGatewayVpcAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayVpcAttachmentWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecurityGroup", reflect.TypeOf((*MockEC2API)(nil).CreateSecurityGroup), varargs...)
 }
 
-// AcceptVpcEndpointConnections mocks base method.
-func (m *MockEC2API) AcceptVpcEndpointConnections(arg0 *ec2.AcceptVpcEndpointConnectionsInput) (*ec2.AcceptVpcEndpointConnectionsOutput, error) {
+// CreateSubnet mocks base method.
+func (m *MockEC2API) CreateSubnet(arg0 context.Context, arg1 *ec2.CreateSubnetInput, arg2 ...func(*ec2.Options)) (*ec2.CreateSubnetOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AcceptVpcEndpointConnections", arg0)
-	ret0, _ := ret[0].(*ec2.AcceptVpcEndpointConnectionsOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateSubnet", varargs...)
+	ret0, _ := ret[0].(*ec2.CreateSubnetOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AcceptVpcEndpointConnections indicates an expected call of AcceptVpcEndpointConnections.
-func (mr *MockEC2APIMockRecorder) AcceptVpcEndpointConnections(arg0 interface{}) *gomock.Call {
+// CreateSubnet indicates an expected call of CreateSubnet.
+func (mr *MockEC2APIMockRecorder) CreateSubnet(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcEndpointConnections", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcEndpointConnections), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubnet", reflect.TypeOf((*MockEC2API)(nil).CreateSubnet), varargs...)
 }
 
-// AcceptVpcEndpointConnectionsRequest mocks base method.
-func (m *MockEC2API) AcceptVpcEndpointConnectionsRequest(arg0 *ec2.AcceptVpcEndpointConnectionsInput) (*request.Request, *ec2.AcceptVpcEndpointConnectionsOutput) {
+// CreateTags mocks base method.
+func (m *MockEC2API) CreateTags(arg0 context.Context, arg1 *ec2.CreateTagsInput, arg2 ...func(*ec2.Options)) (*ec2.CreateTagsOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AcceptVpcEndpointConnectionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AcceptVpcEndpointConnectionsOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateTags", varargs...)
+	ret0, _ := ret[0].(*ec2.CreateTagsOutput)
+	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AcceptVpcEndpointConnectionsRequest indicates an expected call of AcceptVpcEndpointConnectionsRequest.
-func (mr *MockEC2APIMockRecorder) AcceptVpcEndpointConnectionsRequest(arg0 interface{}) *gomock.Call {
+// CreateTags indicates an expected call of CreateTags.
+func (mr *MockEC2APIMockRecorder) CreateTags(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcEndpointConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcEndpointConnectionsRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTags", reflect.TypeOf((*MockEC2API)(nil).CreateTags), varargs...)
 }
 
-// AcceptVpcEndpointConnectionsWithContext mocks base method.
-func (m *MockEC2API) AcceptVpcEndpointConnectionsWithContext(arg0 context.Context, arg1 *ec2.AcceptVpcEndpointConnectionsInput, arg2 ...request.Option) (*ec2.AcceptVpcEndpointConnectionsOutput, error) {
+// CreateVpc mocks base method.
+func (m *MockEC2API) CreateVpc(arg0 context.Context, arg1 *ec2.CreateVpcInput, arg2 ...func(*ec2.Options)) (*ec2.CreateVpcOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AcceptVpcEndpointConnectionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AcceptVpcEndpointConnectionsOutput)
+	ret := m.ctrl.Call(m, "CreateVpc", varargs...)
+	ret0, _ := ret[0].(*ec2.CreateVpcOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AcceptVpcEndpointConnectionsWithContext indicates an expected call of AcceptVpcEndpointConnectionsWithContext.
-func (mr *MockEC2APIMockRecorder) AcceptVpcEndpointConnectionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// CreateVpc indicates an expected call of CreateVpc.
+func (mr *MockEC2APIMockRecorder) CreateVpc(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, "AcceptVpcEndpointConnectionsWithContext", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcEndpointConnectionsWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpc", reflect.TypeOf((*MockEC2API)(nil).CreateVpc), varargs...)
 }
 
-// AcceptVpcPeeringConnection mocks base method.
-func (m *MockEC2API) AcceptVpcPeeringConnection(arg0 *ec2.AcceptVpcPeeringConnectionInput) (*ec2.AcceptVpcPeeringConnectionOutput, error) {
+// CreateVpcEndpoint mocks base method.
+func (m *MockEC2API) CreateVpcEndpoint(arg0 context.Context, arg1 *ec2.CreateVpcEndpointInput, arg2 ...func(*ec2.Options)) (*ec2.CreateVpcEndpointOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AcceptVpcPeeringConnection", arg0)
-	ret0, _ := ret[0].(*ec2.AcceptVpcPeeringConnectionOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateVpcEndpoint", varargs...)
+	ret0, _ := ret[0].(*ec2.CreateVpcEndpointOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AcceptVpcPeeringConnection indicates an expected call of AcceptVpcPeeringConnection.
-func (mr *MockEC2APIMockRecorder) AcceptVpcPeeringConnection(arg0 interface{}) *gomock.Call {
+// CreateVpcEndpoint indicates an expected call of CreateVpcEndpoint.
+func (mr *MockEC2APIMockRecorder) CreateVpcEndpoint(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcPeeringConnection", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcPeeringConnection), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpoint", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpoint), varargs...)
 }
 
-// AcceptVpcPeeringConnectionRequest mocks base method.
-func (m *MockEC2API) AcceptVpcPeeringConnectionRequest(arg0 *ec2.AcceptVpcPeeringConnectionInput) (*request.Request, *ec2.AcceptVpcPeeringConnectionOutput) {
+// DeleteCarrierGateway mocks base method.
+func (m *MockEC2API) DeleteCarrierGateway(arg0 context.Context, arg1 *ec2.DeleteCarrierGatewayInput, arg2 ...func(*ec2.Options)) (*ec2.DeleteCarrierGatewayOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AcceptVpcPeeringConnectionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AcceptVpcPeeringConnectionOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteCarrierGateway", varargs...)
+	ret0, _ := ret[0].(*ec2.DeleteCarrierGatewayOutput)
+	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AcceptVpcPeeringConnectionRequest indicates an expected call of AcceptVpcPeeringConnectionRequest.
-func (mr *MockEC2APIMockRecorder) AcceptVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call {
+// DeleteCarrierGateway indicates an expected call of DeleteCarrierGateway.
+func (mr *MockEC2APIMockRecorder) DeleteCarrierGateway(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcPeeringConnectionRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCarrierGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteCarrierGateway), varargs...)
 }
 
-// AcceptVpcPeeringConnectionWithContext mocks base method.
-func (m *MockEC2API) AcceptVpcPeeringConnectionWithContext(arg0 context.Context, arg1 *ec2.AcceptVpcPeeringConnectionInput, arg2 ...request.Option) (*ec2.AcceptVpcPeeringConnectionOutput, error) {
+// DeleteEgressOnlyInternetGateway mocks base method.
+func (m *MockEC2API) DeleteEgressOnlyInternetGateway(arg0 context.Context, arg1 *ec2.DeleteEgressOnlyInternetGatewayInput, arg2 ...func(*ec2.Options)) (*ec2.DeleteEgressOnlyInternetGatewayOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AcceptVpcPeeringConnectionWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AcceptVpcPeeringConnectionOutput)
+	ret := m.ctrl.Call(m, "DeleteEgressOnlyInternetGateway", varargs...)
+	ret0, _ := ret[0].(*ec2.DeleteEgressOnlyInternetGatewayOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AcceptVpcPeeringConnectionWithContext indicates an expected call of AcceptVpcPeeringConnectionWithContext.
-func (mr *MockEC2APIMockRecorder) AcceptVpcPeeringConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DeleteEgressOnlyInternetGateway indicates an expected call of DeleteEgressOnlyInternetGateway.
+func (mr *MockEC2APIMockRecorder) DeleteEgressOnlyInternetGateway(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, "AcceptVpcPeeringConnectionWithContext", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcPeeringConnectionWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEgressOnlyInternetGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteEgressOnlyInternetGateway), varargs...)
 }
 
-// AdvertiseByoipCidr mocks base method.
-func (m *MockEC2API) AdvertiseByoipCidr(arg0 *ec2.AdvertiseByoipCidrInput) (*ec2.AdvertiseByoipCidrOutput, error) {
+// DeleteInternetGateway mocks base method.
+func (m *MockEC2API) DeleteInternetGateway(arg0 context.Context, arg1 *ec2.DeleteInternetGatewayInput, arg2 ...func(*ec2.Options)) (*ec2.DeleteInternetGatewayOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AdvertiseByoipCidr", arg0)
-	ret0, _ := ret[0].(*ec2.AdvertiseByoipCidrOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteInternetGateway", varargs...)
+	ret0, _ := ret[0].(*ec2.DeleteInternetGatewayOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AdvertiseByoipCidr indicates an expected call of AdvertiseByoipCidr.
-func (mr *MockEC2APIMockRecorder) AdvertiseByoipCidr(arg0 interface{}) *gomock.Call {
+// DeleteInternetGateway indicates an expected call of DeleteInternetGateway.
+func (mr *MockEC2APIMockRecorder) DeleteInternetGateway(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdvertiseByoipCidr", reflect.TypeOf((*MockEC2API)(nil).AdvertiseByoipCidr), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInternetGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteInternetGateway), varargs...)
 }
 
-// AdvertiseByoipCidrRequest mocks base method.
-func (m *MockEC2API) AdvertiseByoipCidrRequest(arg0 *ec2.AdvertiseByoipCidrInput) (*request.Request, *ec2.AdvertiseByoipCidrOutput) {
+// DeleteLaunchTemplate mocks base method.
+func (m *MockEC2API) DeleteLaunchTemplate(arg0 context.Context, arg1 *ec2.DeleteLaunchTemplateInput, arg2 ...func(*ec2.Options)) (*ec2.DeleteLaunchTemplateOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AdvertiseByoipCidrRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AdvertiseByoipCidrOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteLaunchTemplate", varargs...)
+	ret0, _ := ret[0].(*ec2.DeleteLaunchTemplateOutput)
+	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AdvertiseByoipCidrRequest indicates an expected call of AdvertiseByoipCidrRequest.
-func (mr *MockEC2APIMockRecorder) AdvertiseByoipCidrRequest(arg0 interface{}) *gomock.Call {
+// DeleteLaunchTemplate indicates an expected call of DeleteLaunchTemplate.
+func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplate(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdvertiseByoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).AdvertiseByoipCidrRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplate", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplate), varargs...)
 }
 
-// AdvertiseByoipCidrWithContext mocks base method.
-func (m *MockEC2API) AdvertiseByoipCidrWithContext(arg0 context.Context, arg1 *ec2.AdvertiseByoipCidrInput, arg2 ...request.Option) (*ec2.AdvertiseByoipCidrOutput, error) {
+// DeleteLaunchTemplateVersions mocks base method.
+func (m *MockEC2API) DeleteLaunchTemplateVersions(arg0 context.Context, arg1 *ec2.DeleteLaunchTemplateVersionsInput, arg2 ...func(*ec2.Options)) (*ec2.DeleteLaunchTemplateVersionsOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AdvertiseByoipCidrWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AdvertiseByoipCidrOutput)
+	ret := m.ctrl.Call(m, "DeleteLaunchTemplateVersions", varargs...)
+	ret0, _ := ret[0].(*ec2.DeleteLaunchTemplateVersionsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AdvertiseByoipCidrWithContext indicates an expected call of AdvertiseByoipCidrWithContext.
-func (mr *MockEC2APIMockRecorder) AdvertiseByoipCidrWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DeleteLaunchTemplateVersions indicates an expected call of DeleteLaunchTemplateVersions.
+func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplateVersions(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, "AdvertiseByoipCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).AdvertiseByoipCidrWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplateVersions", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplateVersions), varargs...)
 }
 
-// AllocateAddress mocks base method.
-func (m *MockEC2API) AllocateAddress(arg0 *ec2.AllocateAddressInput) (*ec2.AllocateAddressOutput, error) {
+// DeleteNatGateway mocks base method.
+func (m *MockEC2API) DeleteNatGateway(arg0 context.Context, arg1 *ec2.DeleteNatGatewayInput, arg2 ...func(*ec2.Options)) (*ec2.DeleteNatGatewayOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AllocateAddress", arg0)
-	ret0, _ := ret[0].(*ec2.AllocateAddressOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteNatGateway", varargs...)
+	ret0, _ := ret[0].(*ec2.DeleteNatGatewayOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AllocateAddress indicates an expected call of AllocateAddress.
-func (mr *MockEC2APIMockRecorder) AllocateAddress(arg0 interface{}) *gomock.Call {
+// DeleteNatGateway indicates an expected call of DeleteNatGateway.
+func (mr *MockEC2APIMockRecorder) DeleteNatGateway(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateAddress", reflect.TypeOf((*MockEC2API)(nil).AllocateAddress), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNatGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteNatGateway), varargs...)
 }
 
-// AllocateAddressRequest mocks base method.
-func (m *MockEC2API) AllocateAddressRequest(arg0 *ec2.AllocateAddressInput) (*request.Request, *ec2.AllocateAddressOutput) {
+// DeleteRouteTable mocks base method.
+func (m *MockEC2API) DeleteRouteTable(arg0 context.Context, arg1 *ec2.DeleteRouteTableInput, arg2 ...func(*ec2.Options)) (*ec2.DeleteRouteTableOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AllocateAddressRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AllocateAddressOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteRouteTable", varargs...)
+	ret0, _ := ret[0].(*ec2.DeleteRouteTableOutput)
+	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AllocateAddressRequest indicates an expected call of AllocateAddressRequest.
-func (mr *MockEC2APIMockRecorder) AllocateAddressRequest(arg0 interface{}) *gomock.Call {
+// DeleteRouteTable indicates an expected call of DeleteRouteTable.
+func (mr *MockEC2APIMockRecorder) DeleteRouteTable(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateAddressRequest", reflect.TypeOf((*MockEC2API)(nil).AllocateAddressRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouteTable", reflect.TypeOf((*MockEC2API)(nil).DeleteRouteTable), varargs...)
 }
 
-// AllocateAddressWithContext mocks base method.
-func (m *MockEC2API) AllocateAddressWithContext(arg0 context.Context, arg1 *ec2.AllocateAddressInput, arg2 ...request.Option) (*ec2.AllocateAddressOutput, error) {
+// DeleteSecurityGroup mocks base method.
+func (m *MockEC2API) DeleteSecurityGroup(arg0 context.Context, arg1 *ec2.DeleteSecurityGroupInput, arg2 ...func(*ec2.Options)) (*ec2.DeleteSecurityGroupOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AllocateAddressWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AllocateAddressOutput)
+	ret := m.ctrl.Call(m, "DeleteSecurityGroup", varargs...)
+	ret0, _ := ret[0].(*ec2.DeleteSecurityGroupOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AllocateAddressWithContext indicates an expected call of AllocateAddressWithContext.
-func (mr *MockEC2APIMockRecorder) AllocateAddressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DeleteSecurityGroup indicates an expected call of DeleteSecurityGroup.
+func (mr *MockEC2APIMockRecorder) DeleteSecurityGroup(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, "AllocateAddressWithContext", reflect.TypeOf((*MockEC2API)(nil).AllocateAddressWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroup", reflect.TypeOf((*MockEC2API)(nil).DeleteSecurityGroup), varargs...)
 }
 
-// AllocateHosts mocks base method.
-func (m *MockEC2API) AllocateHosts(arg0 *ec2.AllocateHostsInput) (*ec2.AllocateHostsOutput, error) {
+// DeleteSubnet mocks base method.
+func (m *MockEC2API) DeleteSubnet(arg0 context.Context, arg1 *ec2.DeleteSubnetInput, arg2 ...func(*ec2.Options)) (*ec2.DeleteSubnetOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AllocateHosts", arg0)
-	ret0, _ := ret[0].(*ec2.AllocateHostsOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteSubnet", varargs...)
+	ret0, _ := ret[0].(*ec2.DeleteSubnetOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AllocateHosts indicates an expected call of AllocateHosts.
-func (mr *MockEC2APIMockRecorder) AllocateHosts(arg0 interface{}) *gomock.Call {
+// DeleteSubnet indicates an expected call of DeleteSubnet.
+func (mr *MockEC2APIMockRecorder) DeleteSubnet(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateHosts", reflect.TypeOf((*MockEC2API)(nil).AllocateHosts), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubnet", reflect.TypeOf((*MockEC2API)(nil).DeleteSubnet), varargs...)
 }
 
-// AllocateHostsRequest mocks base method.
-func (m *MockEC2API) AllocateHostsRequest(arg0 *ec2.AllocateHostsInput) (*request.Request, *ec2.AllocateHostsOutput) {
+// DeleteTags mocks base method.
+func (m *MockEC2API) DeleteTags(arg0 context.Context, arg1 *ec2.DeleteTagsInput, arg2 ...func(*ec2.Options)) (*ec2.DeleteTagsOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AllocateHostsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AllocateHostsOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteTags", varargs...)
+	ret0, _ := ret[0].(*ec2.DeleteTagsOutput)
+	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AllocateHostsRequest indicates an expected call of AllocateHostsRequest.
-func (mr *MockEC2APIMockRecorder) AllocateHostsRequest(arg0 interface{}) *gomock.Call {
+// DeleteTags indicates an expected call of DeleteTags.
+func (mr *MockEC2APIMockRecorder) DeleteTags(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateHostsRequest", reflect.TypeOf((*MockEC2API)(nil).AllocateHostsRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTags", reflect.TypeOf((*MockEC2API)(nil).DeleteTags), varargs...)
 }
 
-// AllocateHostsWithContext mocks base method.
-func (m *MockEC2API) AllocateHostsWithContext(arg0 context.Context, arg1 *ec2.AllocateHostsInput, arg2 ...request.Option) (*ec2.AllocateHostsOutput, error) {
+// DeleteVpc mocks base method.
+func (m *MockEC2API) DeleteVpc(arg0 context.Context, arg1 *ec2.DeleteVpcInput, arg2 ...func(*ec2.Options)) (*ec2.DeleteVpcOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AllocateHostsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AllocateHostsOutput)
+	ret := m.ctrl.Call(m, "DeleteVpc", varargs...)
+	ret0, _ := ret[0].(*ec2.DeleteVpcOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AllocateHostsWithContext indicates an expected call of AllocateHostsWithContext.
-func (mr *MockEC2APIMockRecorder) AllocateHostsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DeleteVpc indicates an expected call of DeleteVpc.
+func (mr *MockEC2APIMockRecorder) DeleteVpc(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, "AllocateHostsWithContext", reflect.TypeOf((*MockEC2API)(nil).AllocateHostsWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpc", reflect.TypeOf((*MockEC2API)(nil).DeleteVpc), varargs...)
 }
 
-// AllocateIpamPoolCidr mocks base method.
-func (m *MockEC2API) AllocateIpamPoolCidr(arg0 *ec2.AllocateIpamPoolCidrInput) (*ec2.AllocateIpamPoolCidrOutput, error) {
+// DeleteVpcEndpoints mocks base method.
+func (m *MockEC2API) DeleteVpcEndpoints(arg0 context.Context, arg1 *ec2.DeleteVpcEndpointsInput, arg2 ...func(*ec2.Options)) (*ec2.DeleteVpcEndpointsOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AllocateIpamPoolCidr", arg0)
-	ret0, _ := ret[0].(*ec2.AllocateIpamPoolCidrOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteVpcEndpoints", varargs...)
+	ret0, _ := ret[0].(*ec2.DeleteVpcEndpointsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AllocateIpamPoolCidr indicates an expected call of AllocateIpamPoolCidr.
-func (mr *MockEC2APIMockRecorder) AllocateIpamPoolCidr(arg0 interface{}) *gomock.Call {
+// DeleteVpcEndpoints indicates an expected call of DeleteVpcEndpoints.
+func (mr *MockEC2APIMockRecorder) DeleteVpcEndpoints(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateIpamPoolCidr", reflect.TypeOf((*MockEC2API)(nil).AllocateIpamPoolCidr), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpoints", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpoints), varargs...)
 }
 
-// AllocateIpamPoolCidrRequest mocks base method.
-func (m *MockEC2API) AllocateIpamPoolCidrRequest(arg0 *ec2.AllocateIpamPoolCidrInput) (*request.Request, *ec2.AllocateIpamPoolCidrOutput) {
+// DescribeAddresses mocks base method.
+func (m *MockEC2API) DescribeAddresses(arg0 context.Context, arg1 *ec2.DescribeAddressesInput, arg2 ...func(*ec2.Options)) (*ec2.DescribeAddressesOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AllocateIpamPoolCidrRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AllocateIpamPoolCidrOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeAddresses", varargs...)
+	ret0, _ := ret[0].(*ec2.DescribeAddressesOutput)
+	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AllocateIpamPoolCidrRequest indicates an expected call of AllocateIpamPoolCidrRequest.
-func (mr *MockEC2APIMockRecorder) AllocateIpamPoolCidrRequest(arg0 interface{}) *gomock.Call {
+// DescribeAddresses indicates an expected call of DescribeAddresses.
+func (mr *MockEC2APIMockRecorder) DescribeAddresses(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateIpamPoolCidrRequest", reflect.TypeOf((*MockEC2API)(nil).AllocateIpamPoolCidrRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddresses", reflect.TypeOf((*MockEC2API)(nil).DescribeAddresses), varargs...)
 }
 
-// AllocateIpamPoolCidrWithContext mocks base method.
-func (m *MockEC2API) AllocateIpamPoolCidrWithContext(arg0 context.Context, arg1 *ec2.AllocateIpamPoolCidrInput, arg2 ...request.Option) (*ec2.AllocateIpamPoolCidrOutput, error) {
+// DescribeAvailabilityZones mocks base method.
+func (m *MockEC2API) DescribeAvailabilityZones(arg0 context.Context, arg1 *ec2.DescribeAvailabilityZonesInput, arg2 ...func(*ec2.Options)) (*ec2.DescribeAvailabilityZonesOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AllocateIpamPoolCidrWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AllocateIpamPoolCidrOutput)
+	ret := m.ctrl.Call(m, "DescribeAvailabilityZones", varargs...)
+	ret0, _ := ret[0].(*ec2.DescribeAvailabilityZonesOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AllocateIpamPoolCidrWithContext indicates an expected call of AllocateIpamPoolCidrWithContext.
-func (mr *MockEC2APIMockRecorder) AllocateIpamPoolCidrWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DescribeAvailabilityZones indicates an expected call of DescribeAvailabilityZones.
+func (mr *MockEC2APIMockRecorder) DescribeAvailabilityZones(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, "AllocateIpamPoolCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).AllocateIpamPoolCidrWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAvailabilityZones", reflect.TypeOf((*MockEC2API)(nil).DescribeAvailabilityZones), varargs...)
 }
 
-// ApplySecurityGroupsToClientVpnTargetNetwork mocks base method.
-func (m *MockEC2API) ApplySecurityGroupsToClientVpnTargetNetwork(arg0 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput) (*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput, error) {
+// DescribeCarrierGateways mocks base method.
+func (m *MockEC2API) DescribeCarrierGateways(arg0 context.Context, arg1 *ec2.DescribeCarrierGatewaysInput, arg2 ...func(*ec2.Options)) (*ec2.DescribeCarrierGatewaysOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ApplySecurityGroupsToClientVpnTargetNetwork", arg0)
-	ret0, _ := ret[0].(*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeCarrierGateways", varargs...)
+	ret0, _ := ret[0].(*ec2.DescribeCarrierGatewaysOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// ApplySecurityGroupsToClientVpnTargetNetwork indicates an expected call of ApplySecurityGroupsToClientVpnTargetNetwork.
-func (mr *MockEC2APIMockRecorder) ApplySecurityGroupsToClientVpnTargetNetwork(arg0 interface{}) *gomock.Call {
+// DescribeCarrierGateways indicates an expected call of DescribeCarrierGateways.
+func (mr *MockEC2APIMockRecorder) DescribeCarrierGateways(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySecurityGroupsToClientVpnTargetNetwork", reflect.TypeOf((*MockEC2API)(nil).ApplySecurityGroupsToClientVpnTargetNetwork), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCarrierGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeCarrierGateways), varargs...)
 }
 
-// ApplySecurityGroupsToClientVpnTargetNetworkRequest mocks base method.
-func (m *MockEC2API) ApplySecurityGroupsToClientVpnTargetNetworkRequest(arg0 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput) (*request.Request, *ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput) {
+// DescribeDhcpOptions mocks base method.
+func (m *MockEC2API) DescribeDhcpOptions(arg0 context.Context, arg1 *ec2.DescribeDhcpOptionsInput, arg2 ...func(*ec2.Options)) (*ec2.DescribeDhcpOptionsOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ApplySecurityGroupsToClientVpnTargetNetworkRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeDhcpOptions", varargs...)
+	ret0, _ := ret[0].(*ec2.DescribeDhcpOptionsOutput)
+	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// ApplySecurityGroupsToClientVpnTargetNetworkRequest indicates an expected call of ApplySecurityGroupsToClientVpnTargetNetworkRequest.
-func (mr *MockEC2APIMockRecorder) ApplySecurityGroupsToClientVpnTargetNetworkRequest(arg0 interface{}) *gomock.Call {
+// DescribeDhcpOptions indicates an expected call of DescribeDhcpOptions.
+func (mr *MockEC2APIMockRecorder) DescribeDhcpOptions(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySecurityGroupsToClientVpnTargetNetworkRequest", reflect.TypeOf((*MockEC2API)(nil).ApplySecurityGroupsToClientVpnTargetNetworkRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptions", reflect.TypeOf((*MockEC2API)(nil).DescribeDhcpOptions), varargs...)
 }
 
-// ApplySecurityGroupsToClientVpnTargetNetworkWithContext mocks base method.
-func (m *MockEC2API) ApplySecurityGroupsToClientVpnTargetNetworkWithContext(arg0 context.Context, arg1 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput, arg2 ...request.Option) (*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput, error) {
+// DescribeEgressOnlyInternetGateways mocks base method.
+func (m *MockEC2API) DescribeEgressOnlyInternetGateways(arg0 context.Context, arg1 *ec2.DescribeEgressOnlyInternetGatewaysInput, arg2 ...func(*ec2.Options)) (*ec2.DescribeEgressOnlyInternetGatewaysOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "ApplySecurityGroupsToClientVpnTargetNetworkWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput)
+	ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGateways", varargs...)
+	ret0, _ := ret[0].(*ec2.DescribeEgressOnlyInternetGatewaysOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// ApplySecurityGroupsToClientVpnTargetNetworkWithContext indicates an expected call of ApplySecurityGroupsToClientVpnTargetNetworkWithContext.
-func (mr *MockEC2APIMockRecorder) ApplySecurityGroupsToClientVpnTargetNetworkWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DescribeEgressOnlyInternetGateways indicates an expected call of DescribeEgressOnlyInternetGateways.
+func (mr *MockEC2APIMockRecorder) DescribeEgressOnlyInternetGateways(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, "ApplySecurityGroupsToClientVpnTargetNetworkWithContext", reflect.TypeOf((*MockEC2API)(nil).ApplySecurityGroupsToClientVpnTargetNetworkWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEgressOnlyInternetGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeEgressOnlyInternetGateways), varargs...)
 }
 
-// AssignIpv6Addresses mocks base method.
-func (m *MockEC2API) AssignIpv6Addresses(arg0 *ec2.AssignIpv6AddressesInput) (*ec2.AssignIpv6AddressesOutput, error) {
+// DescribeImages mocks base method.
+func (m *MockEC2API) DescribeImages(arg0 context.Context, arg1 *ec2.DescribeImagesInput, arg2 ...func(*ec2.Options)) (*ec2.DescribeImagesOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssignIpv6Addresses", arg0)
-	ret0, _ := ret[0].(*ec2.AssignIpv6AddressesOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeImages", varargs...)
+	ret0, _ := ret[0].(*ec2.DescribeImagesOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssignIpv6Addresses indicates an expected call of AssignIpv6Addresses.
-func (mr *MockEC2APIMockRecorder) AssignIpv6Addresses(arg0 interface{}) *gomock.Call {
+// DescribeImages indicates an expected call of DescribeImages.
+func (mr *MockEC2APIMockRecorder) DescribeImages(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignIpv6Addresses", reflect.TypeOf((*MockEC2API)(nil).AssignIpv6Addresses), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImages", reflect.TypeOf((*MockEC2API)(nil).DescribeImages), varargs...)
 }
 
-// AssignIpv6AddressesRequest mocks base method.
-func (m *MockEC2API) AssignIpv6AddressesRequest(arg0 *ec2.AssignIpv6AddressesInput) (*request.Request, *ec2.AssignIpv6AddressesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssignIpv6AddressesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AssignIpv6AddressesOutput)
-	return ret0, ret1
-}
-
-// AssignIpv6AddressesRequest indicates an expected call of AssignIpv6AddressesRequest.
-func (mr *MockEC2APIMockRecorder) AssignIpv6AddressesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignIpv6AddressesRequest", reflect.TypeOf((*MockEC2API)(nil).AssignIpv6AddressesRequest), arg0)
-}
-
-// AssignIpv6AddressesWithContext mocks base method.
-func (m *MockEC2API) AssignIpv6AddressesWithContext(arg0 context.Context, arg1 *ec2.AssignIpv6AddressesInput, arg2 ...request.Option) (*ec2.AssignIpv6AddressesOutput, error) {
+// DescribeInstanceTypes mocks base method.
+func (m *MockEC2API) DescribeInstanceTypes(arg0 context.Context, arg1 *ec2.DescribeInstanceTypesInput, arg2 ...func(*ec2.Options)) (*ec2.DescribeInstanceTypesOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AssignIpv6AddressesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AssignIpv6AddressesOutput)
+	ret := m.ctrl.Call(m, "DescribeInstanceTypes", varargs...)
+	ret0, _ := ret[0].(*ec2.DescribeInstanceTypesOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssignIpv6AddressesWithContext indicates an expected call of AssignIpv6AddressesWithContext.
-func (mr *MockEC2APIMockRecorder) AssignIpv6AddressesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DescribeInstanceTypes indicates an expected call of DescribeInstanceTypes.
+func (mr *MockEC2APIMockRecorder) DescribeInstanceTypes(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, "AssignIpv6AddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).AssignIpv6AddressesWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypes", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypes), varargs...)
 }
 
-// AssignPrivateIpAddresses mocks base method.
-func (m *MockEC2API) AssignPrivateIpAddresses(arg0 *ec2.AssignPrivateIpAddressesInput) (*ec2.AssignPrivateIpAddressesOutput, error) {
+// DescribeInstances mocks base method.
+func (m *MockEC2API) DescribeInstances(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, arg2 ...func(*ec2.Options)) (*ec2.DescribeInstancesOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssignPrivateIpAddresses", arg0)
-	ret0, _ := ret[0].(*ec2.AssignPrivateIpAddressesOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeInstances", varargs...)
+	ret0, _ := ret[0].(*ec2.DescribeInstancesOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssignPrivateIpAddresses indicates an expected call of AssignPrivateIpAddresses.
-func (mr *MockEC2APIMockRecorder) AssignPrivateIpAddresses(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateIpAddresses", reflect.TypeOf((*MockEC2API)(nil).AssignPrivateIpAddresses), arg0)
-}
-
-// AssignPrivateIpAddressesRequest mocks base method.
-func (m *MockEC2API) AssignPrivateIpAddressesRequest(arg0 *ec2.AssignPrivateIpAddressesInput) (*request.Request, *ec2.AssignPrivateIpAddressesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssignPrivateIpAddressesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AssignPrivateIpAddressesOutput)
-	return ret0, ret1
-}
-
-// AssignPrivateIpAddressesRequest indicates an expected call of AssignPrivateIpAddressesRequest.
-func (mr *MockEC2APIMockRecorder) AssignPrivateIpAddressesRequest(arg0 interface{}) *gomock.Call {
+// DescribeInstances indicates an expected call of DescribeInstances.
+func (mr *MockEC2APIMockRecorder) DescribeInstances(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateIpAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).AssignPrivateIpAddressesRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeInstances), varargs...)
 }
 
-// AssignPrivateIpAddressesWithContext mocks base method.
-func (m *MockEC2API) AssignPrivateIpAddressesWithContext(arg0 context.Context, arg1 *ec2.AssignPrivateIpAddressesInput, arg2 ...request.Option) (*ec2.AssignPrivateIpAddressesOutput, error) {
+// DescribeInternetGateways mocks base method.
+func (m *MockEC2API) DescribeInternetGateways(arg0 context.Context, arg1 *ec2.DescribeInternetGatewaysInput, arg2 ...func(*ec2.Options)) (*ec2.DescribeInternetGatewaysOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AssignPrivateIpAddressesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AssignPrivateIpAddressesOutput)
+	ret := m.ctrl.Call(m, "DescribeInternetGateways", varargs...)
+	ret0, _ := ret[0].(*ec2.DescribeInternetGatewaysOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssignPrivateIpAddressesWithContext indicates an expected call of AssignPrivateIpAddressesWithContext.
-func (mr *MockEC2APIMockRecorder) AssignPrivateIpAddressesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DescribeInternetGateways indicates an expected call of DescribeInternetGateways.
+func (mr *MockEC2APIMockRecorder) DescribeInternetGateways(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, "AssignPrivateIpAddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).AssignPrivateIpAddressesWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInternetGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeInternetGateways), varargs...)
 }
 
-// AssignPrivateNatGatewayAddress mocks base method.
-func (m *MockEC2API) AssignPrivateNatGatewayAddress(arg0 *ec2.AssignPrivateNatGatewayAddressInput) (*ec2.AssignPrivateNatGatewayAddressOutput, error) {
+// DescribeIpamPools mocks base method.
+func (m *MockEC2API) DescribeIpamPools(arg0 context.Context, arg1 *ec2.DescribeIpamPoolsInput, arg2 ...func(*ec2.Options)) (*ec2.DescribeIpamPoolsOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssignPrivateNatGatewayAddress", arg0)
-	ret0, _ := ret[0].(*ec2.AssignPrivateNatGatewayAddressOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeIpamPools", varargs...)
+	ret0, _ := ret[0].(*ec2.DescribeIpamPoolsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssignPrivateNatGatewayAddress indicates an expected call of AssignPrivateNatGatewayAddress.
-func (mr *MockEC2APIMockRecorder) AssignPrivateNatGatewayAddress(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateNatGatewayAddress", reflect.TypeOf((*MockEC2API)(nil).AssignPrivateNatGatewayAddress), arg0)
-}
-
-// AssignPrivateNatGatewayAddressRequest mocks base method.
-func (m *MockEC2API) AssignPrivateNatGatewayAddressRequest(arg0 *ec2.AssignPrivateNatGatewayAddressInput) (*request.Request, *ec2.AssignPrivateNatGatewayAddressOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssignPrivateNatGatewayAddressRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AssignPrivateNatGatewayAddressOutput)
-	return ret0, ret1
-}
-
-// AssignPrivateNatGatewayAddressRequest indicates an expected call of AssignPrivateNatGatewayAddressRequest.
-func (mr *MockEC2APIMockRecorder) AssignPrivateNatGatewayAddressRequest(arg0 interface{}) *gomock.Call {
+// DescribeIpamPools indicates an expected call of DescribeIpamPools.
+func (mr *MockEC2APIMockRecorder) DescribeIpamPools(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateNatGatewayAddressRequest", reflect.TypeOf((*MockEC2API)(nil).AssignPrivateNatGatewayAddressRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamPools", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamPools), varargs...)
 }
 
-// AssignPrivateNatGatewayAddressWithContext mocks base method.
-func (m *MockEC2API) AssignPrivateNatGatewayAddressWithContext(arg0 context.Context, arg1 *ec2.AssignPrivateNatGatewayAddressInput, arg2 ...request.Option) (*ec2.AssignPrivateNatGatewayAddressOutput, error) {
+// DescribeLaunchTemplateVersions mocks base method.
+func (m *MockEC2API) DescribeLaunchTemplateVersions(arg0 context.Context, arg1 *ec2.DescribeLaunchTemplateVersionsInput, arg2 ...func(*ec2.Options)) (*ec2.DescribeLaunchTemplateVersionsOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AssignPrivateNatGatewayAddressWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AssignPrivateNatGatewayAddressOutput)
+	ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersions", varargs...)
+	ret0, _ := ret[0].(*ec2.DescribeLaunchTemplateVersionsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssignPrivateNatGatewayAddressWithContext indicates an expected call of AssignPrivateNatGatewayAddressWithContext.
-func (mr *MockEC2APIMockRecorder) AssignPrivateNatGatewayAddressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DescribeLaunchTemplateVersions indicates an expected call of DescribeLaunchTemplateVersions.
+func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplateVersions(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, "AssignPrivateNatGatewayAddressWithContext", reflect.TypeOf((*MockEC2API)(nil).AssignPrivateNatGatewayAddressWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplateVersions", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplateVersions), varargs...)
 }
 
-// AssociateAddress mocks base method.
-func (m *MockEC2API) AssociateAddress(arg0 *ec2.AssociateAddressInput) (*ec2.AssociateAddressOutput, error) {
+// DescribeNatGateways mocks base method.
+func (m *MockEC2API) DescribeNatGateways(arg0 context.Context, arg1 *ec2.DescribeNatGatewaysInput, arg2 ...func(*ec2.Options)) (*ec2.DescribeNatGatewaysOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateAddress", arg0)
-	ret0, _ := ret[0].(*ec2.AssociateAddressOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeNatGateways", varargs...)
+	ret0, _ := ret[0].(*ec2.DescribeNatGatewaysOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateAddress indicates an expected call of AssociateAddress.
-func (mr *MockEC2APIMockRecorder) AssociateAddress(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateAddress", reflect.TypeOf((*MockEC2API)(nil).AssociateAddress), arg0)
-}
-
-// AssociateAddressRequest mocks base method.
-func (m *MockEC2API) AssociateAddressRequest(arg0 *ec2.AssociateAddressInput) (*request.Request, *ec2.AssociateAddressOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateAddressRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AssociateAddressOutput)
-	return ret0, ret1
-}
-
-// AssociateAddressRequest indicates an expected call of AssociateAddressRequest.
-func (mr *MockEC2APIMockRecorder) AssociateAddressRequest(arg0 interface{}) *gomock.Call {
+// DescribeNatGateways indicates an expected call of DescribeNatGateways.
+func (mr *MockEC2APIMockRecorder) DescribeNatGateways(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateAddressRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateAddressRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeNatGateways), varargs...)
 }
 
-// AssociateAddressWithContext mocks base method.
-func (m *MockEC2API) AssociateAddressWithContext(arg0 context.Context, arg1 *ec2.AssociateAddressInput, arg2 ...request.Option) (*ec2.AssociateAddressOutput, error) {
+// DescribeNetworkInterfaceAttribute mocks base method.
+func (m *MockEC2API) DescribeNetworkInterfaceAttribute(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfaceAttributeInput, arg2 ...func(*ec2.Options)) (*ec2.DescribeNetworkInterfaceAttributeOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AssociateAddressWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AssociateAddressOutput)
+	ret := m.ctrl.Call(m, "DescribeNetworkInterfaceAttribute", varargs...)
+	ret0, _ := ret[0].(*ec2.DescribeNetworkInterfaceAttributeOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateAddressWithContext indicates an expected call of AssociateAddressWithContext.
-func (mr *MockEC2APIMockRecorder) AssociateAddressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DescribeNetworkInterfaceAttribute indicates an expected call of DescribeNetworkInterfaceAttribute.
+func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfaceAttribute(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, "AssociateAddressWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateAddressWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaceAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfaceAttribute), varargs...)
 }
 
-// AssociateClientVpnTargetNetwork mocks base method.
-func (m *MockEC2API) AssociateClientVpnTargetNetwork(arg0 *ec2.AssociateClientVpnTargetNetworkInput) (*ec2.AssociateClientVpnTargetNetworkOutput, error) {
+// DescribeNetworkInterfaces mocks base method.
+func (m *MockEC2API) DescribeNetworkInterfaces(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfacesInput, arg2 ...func(*ec2.Options)) (*ec2.DescribeNetworkInterfacesOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateClientVpnTargetNetwork", arg0)
-	ret0, _ := ret[0].(*ec2.AssociateClientVpnTargetNetworkOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeNetworkInterfaces", varargs...)
+	ret0, _ := ret[0].(*ec2.DescribeNetworkInterfacesOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateClientVpnTargetNetwork indicates an expected call of AssociateClientVpnTargetNetwork.
-func (mr *MockEC2APIMockRecorder) AssociateClientVpnTargetNetwork(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateClientVpnTargetNetwork", reflect.TypeOf((*MockEC2API)(nil).AssociateClientVpnTargetNetwork), arg0)
-}
-
-// AssociateClientVpnTargetNetworkRequest mocks base method.
-func (m *MockEC2API) AssociateClientVpnTargetNetworkRequest(arg0 *ec2.AssociateClientVpnTargetNetworkInput) (*request.Request, *ec2.AssociateClientVpnTargetNetworkOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateClientVpnTargetNetworkRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AssociateClientVpnTargetNetworkOutput)
-	return ret0, ret1
-}
-
-// AssociateClientVpnTargetNetworkRequest indicates an expected call of AssociateClientVpnTargetNetworkRequest.
-func (mr *MockEC2APIMockRecorder) AssociateClientVpnTargetNetworkRequest(arg0 interface{}) *gomock.Call {
+// DescribeNetworkInterfaces indicates an expected call of DescribeNetworkInterfaces.
+func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfaces(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateClientVpnTargetNetworkRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateClientVpnTargetNetworkRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaces", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfaces), varargs...)
 }
 
-// AssociateClientVpnTargetNetworkWithContext mocks base method.
-func (m *MockEC2API) AssociateClientVpnTargetNetworkWithContext(arg0 context.Context, arg1 *ec2.AssociateClientVpnTargetNetworkInput, arg2 ...request.Option) (*ec2.AssociateClientVpnTargetNetworkOutput, error) {
+// DescribePublicIpv4Pools mocks base method.
+func (m *MockEC2API) DescribePublicIpv4Pools(arg0 context.Context, arg1 *ec2.DescribePublicIpv4PoolsInput, arg2 ...func(*ec2.Options)) (*ec2.DescribePublicIpv4PoolsOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AssociateClientVpnTargetNetworkWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AssociateClientVpnTargetNetworkOutput)
+	ret := m.ctrl.Call(m, "DescribePublicIpv4Pools", varargs...)
+	ret0, _ := ret[0].(*ec2.DescribePublicIpv4PoolsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateClientVpnTargetNetworkWithContext indicates an expected call of AssociateClientVpnTargetNetworkWithContext.
-func (mr *MockEC2APIMockRecorder) AssociateClientVpnTargetNetworkWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DescribePublicIpv4Pools indicates an expected call of DescribePublicIpv4Pools.
+func (mr *MockEC2APIMockRecorder) DescribePublicIpv4Pools(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, "AssociateClientVpnTargetNetworkWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateClientVpnTargetNetworkWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublicIpv4Pools", reflect.TypeOf((*MockEC2API)(nil).DescribePublicIpv4Pools), varargs...)
 }
 
-// AssociateDhcpOptions mocks base method.
-func (m *MockEC2API) AssociateDhcpOptions(arg0 *ec2.AssociateDhcpOptionsInput) (*ec2.AssociateDhcpOptionsOutput, error) {
+// DescribeRouteTables mocks base method.
+func (m *MockEC2API) DescribeRouteTables(arg0 context.Context, arg1 *ec2.DescribeRouteTablesInput, arg2 ...func(*ec2.Options)) (*ec2.DescribeRouteTablesOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateDhcpOptions", arg0)
-	ret0, _ := ret[0].(*ec2.AssociateDhcpOptionsOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeRouteTables", varargs...)
+	ret0, _ := ret[0].(*ec2.DescribeRouteTablesOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateDhcpOptions indicates an expected call of AssociateDhcpOptions.
-func (mr *MockEC2APIMockRecorder) AssociateDhcpOptions(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateDhcpOptions", reflect.TypeOf((*MockEC2API)(nil).AssociateDhcpOptions), arg0)
-}
-
-// AssociateDhcpOptionsRequest mocks base method.
-func (m *MockEC2API) AssociateDhcpOptionsRequest(arg0 *ec2.AssociateDhcpOptionsInput) (*request.Request, *ec2.AssociateDhcpOptionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateDhcpOptionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AssociateDhcpOptionsOutput)
-	return ret0, ret1
-}
-
-// AssociateDhcpOptionsRequest indicates an expected call of AssociateDhcpOptionsRequest.
-func (mr *MockEC2APIMockRecorder) AssociateDhcpOptionsRequest(arg0 interface{}) *gomock.Call {
+// DescribeRouteTables indicates an expected call of DescribeRouteTables.
+func (mr *MockEC2APIMockRecorder) DescribeRouteTables(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateDhcpOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateDhcpOptionsRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRouteTables", reflect.TypeOf((*MockEC2API)(nil).DescribeRouteTables), varargs...)
 }
 
-// AssociateDhcpOptionsWithContext mocks base method.
-func (m *MockEC2API) AssociateDhcpOptionsWithContext(arg0 context.Context, arg1 *ec2.AssociateDhcpOptionsInput, arg2 ...request.Option) (*ec2.AssociateDhcpOptionsOutput, error) {
+// DescribeSecurityGroups mocks base method.
+func (m *MockEC2API) DescribeSecurityGroups(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupsInput, arg2 ...func(*ec2.Options)) (*ec2.DescribeSecurityGroupsOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AssociateDhcpOptionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AssociateDhcpOptionsOutput)
+	ret := m.ctrl.Call(m, "DescribeSecurityGroups", varargs...)
+	ret0, _ := ret[0].(*ec2.DescribeSecurityGroupsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateDhcpOptionsWithContext indicates an expected call of AssociateDhcpOptionsWithContext.
-func (mr *MockEC2APIMockRecorder) AssociateDhcpOptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DescribeSecurityGroups indicates an expected call of DescribeSecurityGroups.
+func (mr *MockEC2APIMockRecorder) DescribeSecurityGroups(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, "AssociateDhcpOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateDhcpOptionsWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroups", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroups), varargs...)
 }
 
-// AssociateEnclaveCertificateIamRole mocks base method.
-func (m *MockEC2API) AssociateEnclaveCertificateIamRole(arg0 *ec2.AssociateEnclaveCertificateIamRoleInput) (*ec2.AssociateEnclaveCertificateIamRoleOutput, error) {
+// DescribeSubnets mocks base method.
+func (m *MockEC2API) DescribeSubnets(arg0 context.Context, arg1 *ec2.DescribeSubnetsInput, arg2 ...func(*ec2.Options)) (*ec2.DescribeSubnetsOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateEnclaveCertificateIamRole", arg0)
-	ret0, _ := ret[0].(*ec2.AssociateEnclaveCertificateIamRoleOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeSubnets", varargs...)
+	ret0, _ := ret[0].(*ec2.DescribeSubnetsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateEnclaveCertificateIamRole indicates an expected call of AssociateEnclaveCertificateIamRole.
-func (mr *MockEC2APIMockRecorder) AssociateEnclaveCertificateIamRole(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateEnclaveCertificateIamRole", reflect.TypeOf((*MockEC2API)(nil).AssociateEnclaveCertificateIamRole), arg0)
-}
-
-// AssociateEnclaveCertificateIamRoleRequest mocks base method.
-func (m *MockEC2API) AssociateEnclaveCertificateIamRoleRequest(arg0 *ec2.AssociateEnclaveCertificateIamRoleInput) (*request.Request, *ec2.AssociateEnclaveCertificateIamRoleOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateEnclaveCertificateIamRoleRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AssociateEnclaveCertificateIamRoleOutput)
-	return ret0, ret1
-}
-
-// AssociateEnclaveCertificateIamRoleRequest indicates an expected call of AssociateEnclaveCertificateIamRoleRequest.
-func (mr *MockEC2APIMockRecorder) AssociateEnclaveCertificateIamRoleRequest(arg0 interface{}) *gomock.Call {
+// DescribeSubnets indicates an expected call of DescribeSubnets.
+func (mr *MockEC2APIMockRecorder) DescribeSubnets(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateEnclaveCertificateIamRoleRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateEnclaveCertificateIamRoleRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnets", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnets), varargs...)
 }
 
-// AssociateEnclaveCertificateIamRoleWithContext mocks base method.
-func (m *MockEC2API) AssociateEnclaveCertificateIamRoleWithContext(arg0 context.Context, arg1 *ec2.AssociateEnclaveCertificateIamRoleInput, arg2 ...request.Option) (*ec2.AssociateEnclaveCertificateIamRoleOutput, error) {
+// DescribeVpcAttribute mocks base method.
+func (m *MockEC2API) DescribeVpcAttribute(arg0 context.Context, arg1 *ec2.DescribeVpcAttributeInput, arg2 ...func(*ec2.Options)) (*ec2.DescribeVpcAttributeOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AssociateEnclaveCertificateIamRoleWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AssociateEnclaveCertificateIamRoleOutput)
+	ret := m.ctrl.Call(m, "DescribeVpcAttribute", varargs...)
+	ret0, _ := ret[0].(*ec2.DescribeVpcAttributeOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateEnclaveCertificateIamRoleWithContext indicates an expected call of AssociateEnclaveCertificateIamRoleWithContext.
-func (mr *MockEC2APIMockRecorder) AssociateEnclaveCertificateIamRoleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DescribeVpcAttribute indicates an expected call of DescribeVpcAttribute.
+func (mr *MockEC2APIMockRecorder) DescribeVpcAttribute(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, "AssociateEnclaveCertificateIamRoleWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateEnclaveCertificateIamRoleWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcAttribute), varargs...)
 }
 
-// AssociateIamInstanceProfile mocks base method.
-func (m *MockEC2API) AssociateIamInstanceProfile(arg0 *ec2.AssociateIamInstanceProfileInput) (*ec2.AssociateIamInstanceProfileOutput, error) {
+// DescribeVpcEndpoints mocks base method.
+func (m *MockEC2API) DescribeVpcEndpoints(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointsInput, arg2 ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointsOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateIamInstanceProfile", arg0)
-	ret0, _ := ret[0].(*ec2.AssociateIamInstanceProfileOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeVpcEndpoints", varargs...)
+	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateIamInstanceProfile indicates an expected call of AssociateIamInstanceProfile.
-func (mr *MockEC2APIMockRecorder) AssociateIamInstanceProfile(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIamInstanceProfile", reflect.TypeOf((*MockEC2API)(nil).AssociateIamInstanceProfile), arg0)
-}
-
-// AssociateIamInstanceProfileRequest mocks base method.
-func (m *MockEC2API) AssociateIamInstanceProfileRequest(arg0 *ec2.AssociateIamInstanceProfileInput) (*request.Request, *ec2.AssociateIamInstanceProfileOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateIamInstanceProfileRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AssociateIamInstanceProfileOutput)
-	return ret0, ret1
-}
-
-// AssociateIamInstanceProfileRequest indicates an expected call of AssociateIamInstanceProfileRequest.
-func (mr *MockEC2APIMockRecorder) AssociateIamInstanceProfileRequest(arg0 interface{}) *gomock.Call {
+// DescribeVpcEndpoints indicates an expected call of DescribeVpcEndpoints.
+func (mr *MockEC2APIMockRecorder) DescribeVpcEndpoints(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIamInstanceProfileRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateIamInstanceProfileRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpoints", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpoints), varargs...)
 }
 
-// AssociateIamInstanceProfileWithContext mocks base method.
-func (m *MockEC2API) AssociateIamInstanceProfileWithContext(arg0 context.Context, arg1 *ec2.AssociateIamInstanceProfileInput, arg2 ...request.Option) (*ec2.AssociateIamInstanceProfileOutput, error) {
+// DescribeVpcs mocks base method.
+func (m *MockEC2API) DescribeVpcs(arg0 context.Context, arg1 *ec2.DescribeVpcsInput, arg2 ...func(*ec2.Options)) (*ec2.DescribeVpcsOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AssociateIamInstanceProfileWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AssociateIamInstanceProfileOutput)
+	ret := m.ctrl.Call(m, "DescribeVpcs", varargs...)
+	ret0, _ := ret[0].(*ec2.DescribeVpcsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateIamInstanceProfileWithContext indicates an expected call of AssociateIamInstanceProfileWithContext.
-func (mr *MockEC2APIMockRecorder) AssociateIamInstanceProfileWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DescribeVpcs indicates an expected call of DescribeVpcs.
+func (mr *MockEC2APIMockRecorder) DescribeVpcs(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, "AssociateIamInstanceProfileWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateIamInstanceProfileWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcs", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcs), varargs...)
 }
 
-// AssociateInstanceEventWindow mocks base method.
-func (m *MockEC2API) AssociateInstanceEventWindow(arg0 *ec2.AssociateInstanceEventWindowInput) (*ec2.AssociateInstanceEventWindowOutput, error) {
+// DetachInternetGateway mocks base method.
+func (m *MockEC2API) DetachInternetGateway(arg0 context.Context, arg1 *ec2.DetachInternetGatewayInput, arg2 ...func(*ec2.Options)) (*ec2.DetachInternetGatewayOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateInstanceEventWindow", arg0)
-	ret0, _ := ret[0].(*ec2.AssociateInstanceEventWindowOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DetachInternetGateway", varargs...)
+	ret0, _ := ret[0].(*ec2.DetachInternetGatewayOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateInstanceEventWindow indicates an expected call of AssociateInstanceEventWindow.
-func (mr *MockEC2APIMockRecorder) AssociateInstanceEventWindow(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateInstanceEventWindow", reflect.TypeOf((*MockEC2API)(nil).AssociateInstanceEventWindow), arg0)
-}
-
-// AssociateInstanceEventWindowRequest mocks base method.
-func (m *MockEC2API) AssociateInstanceEventWindowRequest(arg0 *ec2.AssociateInstanceEventWindowInput) (*request.Request, *ec2.AssociateInstanceEventWindowOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateInstanceEventWindowRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AssociateInstanceEventWindowOutput)
-	return ret0, ret1
-}
-
-// AssociateInstanceEventWindowRequest indicates an expected call of AssociateInstanceEventWindowRequest.
-func (mr *MockEC2APIMockRecorder) AssociateInstanceEventWindowRequest(arg0 interface{}) *gomock.Call {
+// DetachInternetGateway indicates an expected call of DetachInternetGateway.
+func (mr *MockEC2APIMockRecorder) DetachInternetGateway(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateInstanceEventWindowRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateInstanceEventWindowRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachInternetGateway", reflect.TypeOf((*MockEC2API)(nil).DetachInternetGateway), varargs...)
 }
 
-// AssociateInstanceEventWindowWithContext mocks base method.
-func (m *MockEC2API) AssociateInstanceEventWindowWithContext(arg0 context.Context, arg1 *ec2.AssociateInstanceEventWindowInput, arg2 ...request.Option) (*ec2.AssociateInstanceEventWindowOutput, error) {
+// DisassociateAddress mocks base method.
+func (m *MockEC2API) DisassociateAddress(arg0 context.Context, arg1 *ec2.DisassociateAddressInput, arg2 ...func(*ec2.Options)) (*ec2.DisassociateAddressOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AssociateInstanceEventWindowWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AssociateInstanceEventWindowOutput)
+	ret := m.ctrl.Call(m, "DisassociateAddress", varargs...)
+	ret0, _ := ret[0].(*ec2.DisassociateAddressOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateInstanceEventWindowWithContext indicates an expected call of AssociateInstanceEventWindowWithContext.
-func (mr *MockEC2APIMockRecorder) AssociateInstanceEventWindowWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DisassociateAddress indicates an expected call of DisassociateAddress.
+func (mr *MockEC2APIMockRecorder) DisassociateAddress(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, "AssociateInstanceEventWindowWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateInstanceEventWindowWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateAddress", reflect.TypeOf((*MockEC2API)(nil).DisassociateAddress), varargs...)
 }
 
-// AssociateIpamByoasn mocks base method.
-func (m *MockEC2API) AssociateIpamByoasn(arg0 *ec2.AssociateIpamByoasnInput) (*ec2.AssociateIpamByoasnOutput, error) {
+// DisassociateRouteTable mocks base method.
+func (m *MockEC2API) DisassociateRouteTable(arg0 context.Context, arg1 *ec2.DisassociateRouteTableInput, arg2 ...func(*ec2.Options)) (*ec2.DisassociateRouteTableOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateIpamByoasn", arg0)
-	ret0, _ := ret[0].(*ec2.AssociateIpamByoasnOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DisassociateRouteTable", varargs...)
+	ret0, _ := ret[0].(*ec2.DisassociateRouteTableOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateIpamByoasn indicates an expected call of AssociateIpamByoasn.
-func (mr *MockEC2APIMockRecorder) AssociateIpamByoasn(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIpamByoasn", reflect.TypeOf((*MockEC2API)(nil).AssociateIpamByoasn), arg0)
-}
-
-// AssociateIpamByoasnRequest mocks base method.
-func (m *MockEC2API) AssociateIpamByoasnRequest(arg0 *ec2.AssociateIpamByoasnInput) (*request.Request, *ec2.AssociateIpamByoasnOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateIpamByoasnRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AssociateIpamByoasnOutput)
-	return ret0, ret1
-}
-
-// AssociateIpamByoasnRequest indicates an expected call of AssociateIpamByoasnRequest.
-func (mr *MockEC2APIMockRecorder) AssociateIpamByoasnRequest(arg0 interface{}) *gomock.Call {
+// DisassociateRouteTable indicates an expected call of DisassociateRouteTable.
+func (mr *MockEC2APIMockRecorder) DisassociateRouteTable(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIpamByoasnRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateIpamByoasnRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateRouteTable", reflect.TypeOf((*MockEC2API)(nil).DisassociateRouteTable), varargs...)
 }
 
-// AssociateIpamByoasnWithContext mocks base method.
-func (m *MockEC2API) AssociateIpamByoasnWithContext(arg0 context.Context, arg1 *ec2.AssociateIpamByoasnInput, arg2 ...request.Option) (*ec2.AssociateIpamByoasnOutput, error) {
+// DisassociateVpcCidrBlock mocks base method.
+func (m *MockEC2API) DisassociateVpcCidrBlock(arg0 context.Context, arg1 *ec2.DisassociateVpcCidrBlockInput, arg2 ...func(*ec2.Options)) (*ec2.DisassociateVpcCidrBlockOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AssociateIpamByoasnWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AssociateIpamByoasnOutput)
+	ret := m.ctrl.Call(m, "DisassociateVpcCidrBlock", varargs...)
+	ret0, _ := ret[0].(*ec2.DisassociateVpcCidrBlockOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateIpamByoasnWithContext indicates an expected call of AssociateIpamByoasnWithContext.
-func (mr *MockEC2APIMockRecorder) AssociateIpamByoasnWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DisassociateVpcCidrBlock indicates an expected call of DisassociateVpcCidrBlock.
+func (mr *MockEC2APIMockRecorder) DisassociateVpcCidrBlock(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, "AssociateIpamByoasnWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateIpamByoasnWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVpcCidrBlock", reflect.TypeOf((*MockEC2API)(nil).DisassociateVpcCidrBlock), varargs...)
 }
 
-// AssociateIpamResourceDiscovery mocks base method.
-func (m *MockEC2API) AssociateIpamResourceDiscovery(arg0 *ec2.AssociateIpamResourceDiscoveryInput) (*ec2.AssociateIpamResourceDiscoveryOutput, error) {
+// ModifyInstanceMetadataOptions mocks base method.
+func (m *MockEC2API) ModifyInstanceMetadataOptions(arg0 context.Context, arg1 *ec2.ModifyInstanceMetadataOptionsInput, arg2 ...func(*ec2.Options)) (*ec2.ModifyInstanceMetadataOptionsOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateIpamResourceDiscovery", arg0)
-	ret0, _ := ret[0].(*ec2.AssociateIpamResourceDiscoveryOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ModifyInstanceMetadataOptions", varargs...)
+	ret0, _ := ret[0].(*ec2.ModifyInstanceMetadataOptionsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateIpamResourceDiscovery indicates an expected call of AssociateIpamResourceDiscovery.
-func (mr *MockEC2APIMockRecorder) AssociateIpamResourceDiscovery(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIpamResourceDiscovery", reflect.TypeOf((*MockEC2API)(nil).AssociateIpamResourceDiscovery), arg0)
-}
-
-// AssociateIpamResourceDiscoveryRequest mocks base method.
-func (m *MockEC2API) AssociateIpamResourceDiscoveryRequest(arg0 *ec2.AssociateIpamResourceDiscoveryInput) (*request.Request, *ec2.AssociateIpamResourceDiscoveryOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateIpamResourceDiscoveryRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AssociateIpamResourceDiscoveryOutput)
-	return ret0, ret1
-}
-
-// AssociateIpamResourceDiscoveryRequest indicates an expected call of AssociateIpamResourceDiscoveryRequest.
-func (mr *MockEC2APIMockRecorder) AssociateIpamResourceDiscoveryRequest(arg0 interface{}) *gomock.Call {
+// ModifyInstanceMetadataOptions indicates an expected call of ModifyInstanceMetadataOptions.
+func (mr *MockEC2APIMockRecorder) ModifyInstanceMetadataOptions(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIpamResourceDiscoveryRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateIpamResourceDiscoveryRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceMetadataOptions", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceMetadataOptions), varargs...)
 }
 
-// AssociateIpamResourceDiscoveryWithContext mocks base method.
-func (m *MockEC2API) AssociateIpamResourceDiscoveryWithContext(arg0 context.Context, arg1 *ec2.AssociateIpamResourceDiscoveryInput, arg2 ...request.Option) (*ec2.AssociateIpamResourceDiscoveryOutput, error) {
+// ModifyNetworkInterfaceAttribute mocks base method.
+func (m *MockEC2API) ModifyNetworkInterfaceAttribute(arg0 context.Context, arg1 *ec2.ModifyNetworkInterfaceAttributeInput, arg2 ...func(*ec2.Options)) (*ec2.ModifyNetworkInterfaceAttributeOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AssociateIpamResourceDiscoveryWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AssociateIpamResourceDiscoveryOutput)
+	ret := m.ctrl.Call(m, "ModifyNetworkInterfaceAttribute", varargs...)
+	ret0, _ := ret[0].(*ec2.ModifyNetworkInterfaceAttributeOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateIpamResourceDiscoveryWithContext indicates an expected call of AssociateIpamResourceDiscoveryWithContext.
-func (mr *MockEC2APIMockRecorder) AssociateIpamResourceDiscoveryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// ModifyNetworkInterfaceAttribute indicates an expected call of ModifyNetworkInterfaceAttribute.
+func (mr *MockEC2APIMockRecorder) ModifyNetworkInterfaceAttribute(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, "AssociateIpamResourceDiscoveryWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateIpamResourceDiscoveryWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyNetworkInterfaceAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyNetworkInterfaceAttribute), varargs...)
 }
 
-// AssociateNatGatewayAddress mocks base method.
-func (m *MockEC2API) AssociateNatGatewayAddress(arg0 *ec2.AssociateNatGatewayAddressInput) (*ec2.AssociateNatGatewayAddressOutput, error) {
+// ModifySubnetAttribute mocks base method.
+func (m *MockEC2API) ModifySubnetAttribute(arg0 context.Context, arg1 *ec2.ModifySubnetAttributeInput, arg2 ...func(*ec2.Options)) (*ec2.ModifySubnetAttributeOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateNatGatewayAddress", arg0)
-	ret0, _ := ret[0].(*ec2.AssociateNatGatewayAddressOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ModifySubnetAttribute", varargs...)
+	ret0, _ := ret[0].(*ec2.ModifySubnetAttributeOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateNatGatewayAddress indicates an expected call of AssociateNatGatewayAddress.
-func (mr *MockEC2APIMockRecorder) AssociateNatGatewayAddress(arg0 interface{}) *gomock.Call {
+// ModifySubnetAttribute indicates an expected call of ModifySubnetAttribute.
+func (mr *MockEC2APIMockRecorder) ModifySubnetAttribute(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateNatGatewayAddress", reflect.TypeOf((*MockEC2API)(nil).AssociateNatGatewayAddress), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySubnetAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifySubnetAttribute), varargs...)
 }
 
-// AssociateNatGatewayAddressRequest mocks base method.
-func (m *MockEC2API) AssociateNatGatewayAddressRequest(arg0 *ec2.AssociateNatGatewayAddressInput) (*request.Request, *ec2.AssociateNatGatewayAddressOutput) {
+// ModifyVpcAttribute mocks base method.
+func (m *MockEC2API) ModifyVpcAttribute(arg0 context.Context, arg1 *ec2.ModifyVpcAttributeInput, arg2 ...func(*ec2.Options)) (*ec2.ModifyVpcAttributeOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateNatGatewayAddressRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AssociateNatGatewayAddressOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ModifyVpcAttribute", varargs...)
+	ret0, _ := ret[0].(*ec2.ModifyVpcAttributeOutput)
+	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateNatGatewayAddressRequest indicates an expected call of AssociateNatGatewayAddressRequest.
-func (mr *MockEC2APIMockRecorder) AssociateNatGatewayAddressRequest(arg0 interface{}) *gomock.Call {
+// ModifyVpcAttribute indicates an expected call of ModifyVpcAttribute.
+func (mr *MockEC2APIMockRecorder) ModifyVpcAttribute(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateNatGatewayAddressRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateNatGatewayAddressRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcAttribute), varargs...)
 }
 
-// AssociateNatGatewayAddressWithContext mocks base method.
-func (m *MockEC2API) AssociateNatGatewayAddressWithContext(arg0 context.Context, arg1 *ec2.AssociateNatGatewayAddressInput, arg2 ...request.Option) (*ec2.AssociateNatGatewayAddressOutput, error) {
+// ModifyVpcEndpoint mocks base method.
+func (m *MockEC2API) ModifyVpcEndpoint(arg0 context.Context, arg1 *ec2.ModifyVpcEndpointInput, arg2 ...func(*ec2.Options)) (*ec2.ModifyVpcEndpointOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AssociateNatGatewayAddressWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AssociateNatGatewayAddressOutput)
+	ret := m.ctrl.Call(m, "ModifyVpcEndpoint", varargs...)
+	ret0, _ := ret[0].(*ec2.ModifyVpcEndpointOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateNatGatewayAddressWithContext indicates an expected call of AssociateNatGatewayAddressWithContext.
-func (mr *MockEC2APIMockRecorder) AssociateNatGatewayAddressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// ModifyVpcEndpoint indicates an expected call of ModifyVpcEndpoint.
+func (mr *MockEC2APIMockRecorder) ModifyVpcEndpoint(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, "AssociateNatGatewayAddressWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateNatGatewayAddressWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpoint", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpoint), varargs...)
 }
 
-// AssociateRouteTable mocks base method.
-func (m *MockEC2API) AssociateRouteTable(arg0 *ec2.AssociateRouteTableInput) (*ec2.AssociateRouteTableOutput, error) {
+// ReleaseAddress mocks base method.
+func (m *MockEC2API) ReleaseAddress(arg0 context.Context, arg1 *ec2.ReleaseAddressInput, arg2 ...func(*ec2.Options)) (*ec2.ReleaseAddressOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateRouteTable", arg0)
-	ret0, _ := ret[0].(*ec2.AssociateRouteTableOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ReleaseAddress", varargs...)
+	ret0, _ := ret[0].(*ec2.ReleaseAddressOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateRouteTable indicates an expected call of AssociateRouteTable.
-func (mr *MockEC2APIMockRecorder) AssociateRouteTable(arg0 interface{}) *gomock.Call {
+// ReleaseAddress indicates an expected call of ReleaseAddress.
+func (mr *MockEC2APIMockRecorder) ReleaseAddress(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateRouteTable", reflect.TypeOf((*MockEC2API)(nil).AssociateRouteTable), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseAddress", reflect.TypeOf((*MockEC2API)(nil).ReleaseAddress), varargs...)
 }
 
-// AssociateRouteTableRequest mocks base method.
-func (m *MockEC2API) AssociateRouteTableRequest(arg0 *ec2.AssociateRouteTableInput) (*request.Request, *ec2.AssociateRouteTableOutput) {
+// ReplaceRoute mocks base method.
+func (m *MockEC2API) ReplaceRoute(arg0 context.Context, arg1 *ec2.ReplaceRouteInput, arg2 ...func(*ec2.Options)) (*ec2.ReplaceRouteOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateRouteTableRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AssociateRouteTableOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ReplaceRoute", varargs...)
+	ret0, _ := ret[0].(*ec2.ReplaceRouteOutput)
+	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateRouteTableRequest indicates an expected call of AssociateRouteTableRequest.
-func (mr *MockEC2APIMockRecorder) AssociateRouteTableRequest(arg0 interface{}) *gomock.Call {
+// ReplaceRoute indicates an expected call of ReplaceRoute.
+func (mr *MockEC2APIMockRecorder) ReplaceRoute(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateRouteTableRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRoute", reflect.TypeOf((*MockEC2API)(nil).ReplaceRoute), varargs...)
 }
 
-// AssociateRouteTableWithContext mocks base method.
-func (m *MockEC2API) AssociateRouteTableWithContext(arg0 context.Context, arg1 *ec2.AssociateRouteTableInput, arg2 ...request.Option) (*ec2.AssociateRouteTableOutput, error) {
+// RevokeSecurityGroupEgress mocks base method.
+func (m *MockEC2API) RevokeSecurityGroupEgress(arg0 context.Context, arg1 *ec2.RevokeSecurityGroupEgressInput, arg2 ...func(*ec2.Options)) (*ec2.RevokeSecurityGroupEgressOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AssociateRouteTableWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AssociateRouteTableOutput)
+	ret := m.ctrl.Call(m, "RevokeSecurityGroupEgress", varargs...)
+	ret0, _ := ret[0].(*ec2.RevokeSecurityGroupEgressOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateRouteTableWithContext indicates an expected call of AssociateRouteTableWithContext.
-func (mr *MockEC2APIMockRecorder) AssociateRouteTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// RevokeSecurityGroupEgress indicates an expected call of RevokeSecurityGroupEgress.
+func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupEgress(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, "AssociateRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateRouteTableWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupEgress", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupEgress), varargs...)
 }
 
-// AssociateSubnetCidrBlock mocks base method.
-func (m *MockEC2API) AssociateSubnetCidrBlock(arg0 *ec2.AssociateSubnetCidrBlockInput) (*ec2.AssociateSubnetCidrBlockOutput, error) {
+// RevokeSecurityGroupIngress mocks base method.
+func (m *MockEC2API) RevokeSecurityGroupIngress(arg0 context.Context, arg1 *ec2.RevokeSecurityGroupIngressInput, arg2 ...func(*ec2.Options)) (*ec2.RevokeSecurityGroupIngressOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateSubnetCidrBlock", arg0)
-	ret0, _ := ret[0].(*ec2.AssociateSubnetCidrBlockOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "RevokeSecurityGroupIngress", varargs...)
+	ret0, _ := ret[0].(*ec2.RevokeSecurityGroupIngressOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateSubnetCidrBlock indicates an expected call of AssociateSubnetCidrBlock.
-func (mr *MockEC2APIMockRecorder) AssociateSubnetCidrBlock(arg0 interface{}) *gomock.Call {
+// RevokeSecurityGroupIngress indicates an expected call of RevokeSecurityGroupIngress.
+func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupIngress(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateSubnetCidrBlock", reflect.TypeOf((*MockEC2API)(nil).AssociateSubnetCidrBlock), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupIngress", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupIngress), varargs...)
 }
 
-// AssociateSubnetCidrBlockRequest mocks base method.
-func (m *MockEC2API) AssociateSubnetCidrBlockRequest(arg0 *ec2.AssociateSubnetCidrBlockInput) (*request.Request, *ec2.AssociateSubnetCidrBlockOutput) {
+// RunInstances mocks base method.
+func (m *MockEC2API) RunInstances(arg0 context.Context, arg1 *ec2.RunInstancesInput, arg2 ...func(*ec2.Options)) (*ec2.RunInstancesOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateSubnetCidrBlockRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AssociateSubnetCidrBlockOutput)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "RunInstances", varargs...)
+	ret0, _ := ret[0].(*ec2.RunInstancesOutput)
+	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateSubnetCidrBlockRequest indicates an expected call of AssociateSubnetCidrBlockRequest.
-func (mr *MockEC2APIMockRecorder) AssociateSubnetCidrBlockRequest(arg0 interface{}) *gomock.Call {
+// RunInstances indicates an expected call of RunInstances.
+func (mr *MockEC2APIMockRecorder) RunInstances(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateSubnetCidrBlockRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateSubnetCidrBlockRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunInstances", reflect.TypeOf((*MockEC2API)(nil).RunInstances), varargs...)
 }
 
-// AssociateSubnetCidrBlockWithContext mocks base method.
-func (m *MockEC2API) AssociateSubnetCidrBlockWithContext(arg0 context.Context, arg1 *ec2.AssociateSubnetCidrBlockInput, arg2 ...request.Option) (*ec2.AssociateSubnetCidrBlockOutput, error) {
+// TerminateInstances mocks base method.
+func (m *MockEC2API) TerminateInstances(arg0 context.Context, arg1 *ec2.TerminateInstancesInput, arg2 ...func(*ec2.Options)) (*ec2.TerminateInstancesOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "AssociateSubnetCidrBlockWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AssociateSubnetCidrBlockOutput)
+	ret := m.ctrl.Call(m, "TerminateInstances", varargs...)
+	ret0, _ := ret[0].(*ec2.TerminateInstancesOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// AssociateSubnetCidrBlockWithContext indicates an expected call of AssociateSubnetCidrBlockWithContext.
-func (mr *MockEC2APIMockRecorder) AssociateSubnetCidrBlockWithContext(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, "AssociateSubnetCidrBlockWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateSubnetCidrBlockWithContext), varargs...)
-}
-
-// AssociateTransitGatewayMulticastDomain mocks base method.
-func (m *MockEC2API) AssociateTransitGatewayMulticastDomain(arg0 *ec2.AssociateTransitGatewayMulticastDomainInput) (*ec2.AssociateTransitGatewayMulticastDomainOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateTransitGatewayMulticastDomain", arg0)
-	ret0, _ := ret[0].(*ec2.AssociateTransitGatewayMulticastDomainOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AssociateTransitGatewayMulticastDomain indicates an expected call of AssociateTransitGatewayMulticastDomain.
-func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayMulticastDomain(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayMulticastDomain", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayMulticastDomain), arg0)
-}
-
-// AssociateTransitGatewayMulticastDomainRequest mocks base method.
-func (m *MockEC2API) AssociateTransitGatewayMulticastDomainRequest(arg0 *ec2.AssociateTransitGatewayMulticastDomainInput) (*request.Request, *ec2.AssociateTransitGatewayMulticastDomainOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateTransitGatewayMulticastDomainRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AssociateTransitGatewayMulticastDomainOutput)
-	return ret0, ret1
-}
-
-// AssociateTransitGatewayMulticastDomainRequest indicates an expected call of AssociateTransitGatewayMulticastDomainRequest.
-func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayMulticastDomainRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayMulticastDomainRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayMulticastDomainRequest), arg0)
-}
-
-// AssociateTransitGatewayMulticastDomainWithContext mocks base method.
-func (m *MockEC2API) AssociateTransitGatewayMulticastDomainWithContext(arg0 context.Context, arg1 *ec2.AssociateTransitGatewayMulticastDomainInput, arg2 ...request.Option) (*ec2.AssociateTransitGatewayMulticastDomainOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "AssociateTransitGatewayMulticastDomainWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AssociateTransitGatewayMulticastDomainOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AssociateTransitGatewayMulticastDomainWithContext indicates an expected call of AssociateTransitGatewayMulticastDomainWithContext.
-func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayMulticastDomainWithContext(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, "AssociateTransitGatewayMulticastDomainWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayMulticastDomainWithContext), varargs...)
-}
-
-// AssociateTransitGatewayPolicyTable mocks base method.
-func (m *MockEC2API) AssociateTransitGatewayPolicyTable(arg0 *ec2.AssociateTransitGatewayPolicyTableInput) (*ec2.AssociateTransitGatewayPolicyTableOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateTransitGatewayPolicyTable", arg0)
-	ret0, _ := ret[0].(*ec2.AssociateTransitGatewayPolicyTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AssociateTransitGatewayPolicyTable indicates an expected call of AssociateTransitGatewayPolicyTable.
-func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayPolicyTable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayPolicyTable", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayPolicyTable), arg0)
-}
-
-// AssociateTransitGatewayPolicyTableRequest mocks base method.
-func (m *MockEC2API) AssociateTransitGatewayPolicyTableRequest(arg0 *ec2.AssociateTransitGatewayPolicyTableInput) (*request.Request, *ec2.AssociateTransitGatewayPolicyTableOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateTransitGatewayPolicyTableRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AssociateTransitGatewayPolicyTableOutput)
-	return ret0, ret1
-}
-
-// AssociateTransitGatewayPolicyTableRequest indicates an expected call of AssociateTransitGatewayPolicyTableRequest.
-func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayPolicyTableRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayPolicyTableRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayPolicyTableRequest), arg0)
-}
-
-// AssociateTransitGatewayPolicyTableWithContext mocks base method.
-func (m *MockEC2API) AssociateTransitGatewayPolicyTableWithContext(arg0 context.Context, arg1 *ec2.AssociateTransitGatewayPolicyTableInput, arg2 ...request.Option) (*ec2.AssociateTransitGatewayPolicyTableOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "AssociateTransitGatewayPolicyTableWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AssociateTransitGatewayPolicyTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AssociateTransitGatewayPolicyTableWithContext indicates an expected call of AssociateTransitGatewayPolicyTableWithContext.
-func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayPolicyTableWithContext(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, "AssociateTransitGatewayPolicyTableWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayPolicyTableWithContext), varargs...)
-}
-
-// AssociateTransitGatewayRouteTable mocks base method.
-func (m *MockEC2API) AssociateTransitGatewayRouteTable(arg0 *ec2.AssociateTransitGatewayRouteTableInput) (*ec2.AssociateTransitGatewayRouteTableOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateTransitGatewayRouteTable", arg0)
-	ret0, _ := ret[0].(*ec2.AssociateTransitGatewayRouteTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AssociateTransitGatewayRouteTable indicates an expected call of AssociateTransitGatewayRouteTable.
-func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayRouteTable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayRouteTable), arg0)
-}
-
-// AssociateTransitGatewayRouteTableRequest mocks base method.
-func (m *MockEC2API) AssociateTransitGatewayRouteTableRequest(arg0 *ec2.AssociateTransitGatewayRouteTableInput) (*request.Request, *ec2.AssociateTransitGatewayRouteTableOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateTransitGatewayRouteTableRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AssociateTransitGatewayRouteTableOutput)
-	return ret0, ret1
-}
-
-// AssociateTransitGatewayRouteTableRequest indicates an expected call of AssociateTransitGatewayRouteTableRequest.
-func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayRouteTableRequest), arg0)
-}
-
-// AssociateTransitGatewayRouteTableWithContext mocks base method.
-func (m *MockEC2API) AssociateTransitGatewayRouteTableWithContext(arg0 context.Context, arg1 *ec2.AssociateTransitGatewayRouteTableInput, arg2 ...request.Option) (*ec2.AssociateTransitGatewayRouteTableOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "AssociateTransitGatewayRouteTableWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AssociateTransitGatewayRouteTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AssociateTransitGatewayRouteTableWithContext indicates an expected call of AssociateTransitGatewayRouteTableWithContext.
-func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayRouteTableWithContext(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, "AssociateTransitGatewayRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayRouteTableWithContext), varargs...)
-}
-
-// AssociateTrunkInterface mocks base method.
-func (m *MockEC2API) AssociateTrunkInterface(arg0 *ec2.AssociateTrunkInterfaceInput) (*ec2.AssociateTrunkInterfaceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateTrunkInterface", arg0)
-	ret0, _ := ret[0].(*ec2.AssociateTrunkInterfaceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AssociateTrunkInterface indicates an expected call of AssociateTrunkInterface.
-func (mr *MockEC2APIMockRecorder) AssociateTrunkInterface(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTrunkInterface", reflect.TypeOf((*MockEC2API)(nil).AssociateTrunkInterface), arg0)
-}
-
-// AssociateTrunkInterfaceRequest mocks base method.
-func (m *MockEC2API) AssociateTrunkInterfaceRequest(arg0 *ec2.AssociateTrunkInterfaceInput) (*request.Request, *ec2.AssociateTrunkInterfaceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateTrunkInterfaceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AssociateTrunkInterfaceOutput)
-	return ret0, ret1
-}
-
-// AssociateTrunkInterfaceRequest indicates an expected call of AssociateTrunkInterfaceRequest.
-func (mr *MockEC2APIMockRecorder) AssociateTrunkInterfaceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTrunkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateTrunkInterfaceRequest), arg0)
-}
-
-// AssociateTrunkInterfaceWithContext mocks base method.
-func (m *MockEC2API) AssociateTrunkInterfaceWithContext(arg0 context.Context, arg1 *ec2.AssociateTrunkInterfaceInput, arg2 ...request.Option) (*ec2.AssociateTrunkInterfaceOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "AssociateTrunkInterfaceWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AssociateTrunkInterfaceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AssociateTrunkInterfaceWithContext indicates an expected call of AssociateTrunkInterfaceWithContext.
-func (mr *MockEC2APIMockRecorder) AssociateTrunkInterfaceWithContext(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, "AssociateTrunkInterfaceWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateTrunkInterfaceWithContext), varargs...)
-}
-
-// AssociateVpcCidrBlock mocks base method.
-func (m *MockEC2API) AssociateVpcCidrBlock(arg0 *ec2.AssociateVpcCidrBlockInput) (*ec2.AssociateVpcCidrBlockOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateVpcCidrBlock", arg0)
-	ret0, _ := ret[0].(*ec2.AssociateVpcCidrBlockOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AssociateVpcCidrBlock indicates an expected call of AssociateVpcCidrBlock.
-func (mr *MockEC2APIMockRecorder) AssociateVpcCidrBlock(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVpcCidrBlock", reflect.TypeOf((*MockEC2API)(nil).AssociateVpcCidrBlock), arg0)
-}
-
-// AssociateVpcCidrBlockRequest mocks base method.
-func (m *MockEC2API) AssociateVpcCidrBlockRequest(arg0 *ec2.AssociateVpcCidrBlockInput) (*request.Request, *ec2.AssociateVpcCidrBlockOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AssociateVpcCidrBlockRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AssociateVpcCidrBlockOutput)
-	return ret0, ret1
-}
-
-// AssociateVpcCidrBlockRequest indicates an expected call of AssociateVpcCidrBlockRequest.
-func (mr *MockEC2APIMockRecorder) AssociateVpcCidrBlockRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVpcCidrBlockRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateVpcCidrBlockRequest), arg0)
-}
-
-// AssociateVpcCidrBlockWithContext mocks base method.
-func (m *MockEC2API) AssociateVpcCidrBlockWithContext(arg0 context.Context, arg1 *ec2.AssociateVpcCidrBlockInput, arg2 ...request.Option) (*ec2.AssociateVpcCidrBlockOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "AssociateVpcCidrBlockWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AssociateVpcCidrBlockOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AssociateVpcCidrBlockWithContext indicates an expected call of AssociateVpcCidrBlockWithContext.
-func (mr *MockEC2APIMockRecorder) AssociateVpcCidrBlockWithContext(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, "AssociateVpcCidrBlockWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateVpcCidrBlockWithContext), varargs...)
-}
-
-// AttachClassicLinkVpc mocks base method.
-func (m *MockEC2API) AttachClassicLinkVpc(arg0 *ec2.AttachClassicLinkVpcInput) (*ec2.AttachClassicLinkVpcOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AttachClassicLinkVpc", arg0)
-	ret0, _ := ret[0].(*ec2.AttachClassicLinkVpcOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AttachClassicLinkVpc indicates an expected call of AttachClassicLinkVpc.
-func (mr *MockEC2APIMockRecorder) AttachClassicLinkVpc(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachClassicLinkVpc", reflect.TypeOf((*MockEC2API)(nil).AttachClassicLinkVpc), arg0)
-}
-
-// AttachClassicLinkVpcRequest mocks base method.
-func (m *MockEC2API) AttachClassicLinkVpcRequest(arg0 *ec2.AttachClassicLinkVpcInput) (*request.Request, *ec2.AttachClassicLinkVpcOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AttachClassicLinkVpcRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AttachClassicLinkVpcOutput)
-	return ret0, ret1
-}
-
-// AttachClassicLinkVpcRequest indicates an expected call of AttachClassicLinkVpcRequest.
-func (mr *MockEC2APIMockRecorder) AttachClassicLinkVpcRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachClassicLinkVpcRequest", reflect.TypeOf((*MockEC2API)(nil).AttachClassicLinkVpcRequest), arg0)
-}
-
-// AttachClassicLinkVpcWithContext mocks base method.
-func (m *MockEC2API) AttachClassicLinkVpcWithContext(arg0 context.Context, arg1 *ec2.AttachClassicLinkVpcInput, arg2 ...request.Option) (*ec2.AttachClassicLinkVpcOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "AttachClassicLinkVpcWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AttachClassicLinkVpcOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AttachClassicLinkVpcWithContext indicates an expected call of AttachClassicLinkVpcWithContext.
-func (mr *MockEC2APIMockRecorder) AttachClassicLinkVpcWithContext(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, "AttachClassicLinkVpcWithContext", reflect.TypeOf((*MockEC2API)(nil).AttachClassicLinkVpcWithContext), varargs...)
-}
-
-// AttachInternetGateway mocks base method.
-func (m *MockEC2API) AttachInternetGateway(arg0 *ec2.AttachInternetGatewayInput) (*ec2.AttachInternetGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AttachInternetGateway", arg0)
-	ret0, _ := ret[0].(*ec2.AttachInternetGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AttachInternetGateway indicates an expected call of AttachInternetGateway.
-func (mr *MockEC2APIMockRecorder) AttachInternetGateway(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachInternetGateway", reflect.TypeOf((*MockEC2API)(nil).AttachInternetGateway), arg0)
-}
-
-// AttachInternetGatewayRequest mocks base method.
-func (m *MockEC2API) AttachInternetGatewayRequest(arg0 *ec2.AttachInternetGatewayInput) (*request.Request, *ec2.AttachInternetGatewayOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AttachInternetGatewayRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AttachInternetGatewayOutput)
-	return ret0, ret1
-}
-
-// AttachInternetGatewayRequest indicates an expected call of AttachInternetGatewayRequest.
-func (mr *MockEC2APIMockRecorder) AttachInternetGatewayRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).AttachInternetGatewayRequest), arg0)
-}
-
-// AttachInternetGatewayWithContext mocks base method.
-func (m *MockEC2API) AttachInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.AttachInternetGatewayInput, arg2 ...request.Option) (*ec2.AttachInternetGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "AttachInternetGatewayWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AttachInternetGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AttachInternetGatewayWithContext indicates an expected call of AttachInternetGatewayWithContext.
-func (mr *MockEC2APIMockRecorder) AttachInternetGatewayWithContext(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, "AttachInternetGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).AttachInternetGatewayWithContext), varargs...)
-}
-
-// AttachNetworkInterface mocks base method.
-func (m *MockEC2API) AttachNetworkInterface(arg0 *ec2.AttachNetworkInterfaceInput) (*ec2.AttachNetworkInterfaceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AttachNetworkInterface", arg0)
-	ret0, _ := ret[0].(*ec2.AttachNetworkInterfaceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AttachNetworkInterface indicates an expected call of AttachNetworkInterface.
-func (mr *MockEC2APIMockRecorder) AttachNetworkInterface(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachNetworkInterface", reflect.TypeOf((*MockEC2API)(nil).AttachNetworkInterface), arg0)
-}
-
-// AttachNetworkInterfaceRequest mocks base method.
-func (m *MockEC2API) AttachNetworkInterfaceRequest(arg0 *ec2.AttachNetworkInterfaceInput) (*request.Request, *ec2.AttachNetworkInterfaceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AttachNetworkInterfaceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AttachNetworkInterfaceOutput)
-	return ret0, ret1
-}
-
-// AttachNetworkInterfaceRequest indicates an expected call of AttachNetworkInterfaceRequest.
-func (mr *MockEC2APIMockRecorder) AttachNetworkInterfaceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachNetworkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).AttachNetworkInterfaceRequest), arg0)
-}
-
-// AttachNetworkInterfaceWithContext mocks base method.
-func (m *MockEC2API) AttachNetworkInterfaceWithContext(arg0 context.Context, arg1 *ec2.AttachNetworkInterfaceInput, arg2 ...request.Option) (*ec2.AttachNetworkInterfaceOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "AttachNetworkInterfaceWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AttachNetworkInterfaceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AttachNetworkInterfaceWithContext indicates an expected call of AttachNetworkInterfaceWithContext.
-func (mr *MockEC2APIMockRecorder) AttachNetworkInterfaceWithContext(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, "AttachNetworkInterfaceWithContext", reflect.TypeOf((*MockEC2API)(nil).AttachNetworkInterfaceWithContext), varargs...)
-}
-
-// AttachVerifiedAccessTrustProvider mocks base method.
-func (m *MockEC2API) AttachVerifiedAccessTrustProvider(arg0 *ec2.AttachVerifiedAccessTrustProviderInput) (*ec2.AttachVerifiedAccessTrustProviderOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AttachVerifiedAccessTrustProvider", arg0)
-	ret0, _ := ret[0].(*ec2.AttachVerifiedAccessTrustProviderOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AttachVerifiedAccessTrustProvider indicates an expected call of AttachVerifiedAccessTrustProvider.
-func (mr *MockEC2APIMockRecorder) AttachVerifiedAccessTrustProvider(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVerifiedAccessTrustProvider", reflect.TypeOf((*MockEC2API)(nil).AttachVerifiedAccessTrustProvider), arg0)
-}
-
-// AttachVerifiedAccessTrustProviderRequest mocks base method.
-func (m *MockEC2API) AttachVerifiedAccessTrustProviderRequest(arg0 *ec2.AttachVerifiedAccessTrustProviderInput) (*request.Request, *ec2.AttachVerifiedAccessTrustProviderOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AttachVerifiedAccessTrustProviderRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AttachVerifiedAccessTrustProviderOutput)
-	return ret0, ret1
-}
-
-// AttachVerifiedAccessTrustProviderRequest indicates an expected call of AttachVerifiedAccessTrustProviderRequest.
-func (mr *MockEC2APIMockRecorder) AttachVerifiedAccessTrustProviderRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVerifiedAccessTrustProviderRequest", reflect.TypeOf((*MockEC2API)(nil).AttachVerifiedAccessTrustProviderRequest), arg0)
-}
-
-// AttachVerifiedAccessTrustProviderWithContext mocks base method.
-func (m *MockEC2API) AttachVerifiedAccessTrustProviderWithContext(arg0 context.Context, arg1 *ec2.AttachVerifiedAccessTrustProviderInput, arg2 ...request.Option) (*ec2.AttachVerifiedAccessTrustProviderOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "AttachVerifiedAccessTrustProviderWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AttachVerifiedAccessTrustProviderOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AttachVerifiedAccessTrustProviderWithContext indicates an expected call of AttachVerifiedAccessTrustProviderWithContext.
-func (mr *MockEC2APIMockRecorder) AttachVerifiedAccessTrustProviderWithContext(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, "AttachVerifiedAccessTrustProviderWithContext", reflect.TypeOf((*MockEC2API)(nil).AttachVerifiedAccessTrustProviderWithContext), varargs...)
-}
-
-// AttachVolume mocks base method.
-func (m *MockEC2API) AttachVolume(arg0 *ec2.AttachVolumeInput) (*ec2.VolumeAttachment, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AttachVolume", arg0)
-	ret0, _ := ret[0].(*ec2.VolumeAttachment)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AttachVolume indicates an expected call of AttachVolume.
-func (mr *MockEC2APIMockRecorder) AttachVolume(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVolume", reflect.TypeOf((*MockEC2API)(nil).AttachVolume), arg0)
-}
-
-// AttachVolumeRequest mocks base method.
-func (m *MockEC2API) AttachVolumeRequest(arg0 *ec2.AttachVolumeInput) (*request.Request, *ec2.VolumeAttachment) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AttachVolumeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.VolumeAttachment)
-	return ret0, ret1
-}
-
-// AttachVolumeRequest indicates an expected call of AttachVolumeRequest.
-func (mr *MockEC2APIMockRecorder) AttachVolumeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).AttachVolumeRequest), arg0)
-}
-
-// AttachVolumeWithContext mocks base method.
-func (m *MockEC2API) AttachVolumeWithContext(arg0 context.Context, arg1 *ec2.AttachVolumeInput, arg2 ...request.Option) (*ec2.VolumeAttachment, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "AttachVolumeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.VolumeAttachment)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AttachVolumeWithContext indicates an expected call of AttachVolumeWithContext.
-func (mr *MockEC2APIMockRecorder) AttachVolumeWithContext(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, "AttachVolumeWithContext", reflect.TypeOf((*MockEC2API)(nil).AttachVolumeWithContext), varargs...)
-}
-
-// AttachVpnGateway mocks base method.
-func (m *MockEC2API) AttachVpnGateway(arg0 *ec2.AttachVpnGatewayInput) (*ec2.AttachVpnGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AttachVpnGateway", arg0)
-	ret0, _ := ret[0].(*ec2.AttachVpnGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AttachVpnGateway indicates an expected call of AttachVpnGateway.
-func (mr *MockEC2APIMockRecorder) AttachVpnGateway(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVpnGateway", reflect.TypeOf((*MockEC2API)(nil).AttachVpnGateway), arg0)
-}
-
-// AttachVpnGatewayRequest mocks base method.
-func (m *MockEC2API) AttachVpnGatewayRequest(arg0 *ec2.AttachVpnGatewayInput) (*request.Request, *ec2.AttachVpnGatewayOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AttachVpnGatewayRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AttachVpnGatewayOutput)
-	return ret0, ret1
-}
-
-// AttachVpnGatewayRequest indicates an expected call of AttachVpnGatewayRequest.
-func (mr *MockEC2APIMockRecorder) AttachVpnGatewayRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVpnGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).AttachVpnGatewayRequest), arg0)
-}
-
-// AttachVpnGatewayWithContext mocks base method.
-func (m *MockEC2API) AttachVpnGatewayWithContext(arg0 context.Context, arg1 *ec2.AttachVpnGatewayInput, arg2 ...request.Option) (*ec2.AttachVpnGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "AttachVpnGatewayWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AttachVpnGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AttachVpnGatewayWithContext indicates an expected call of AttachVpnGatewayWithContext.
-func (mr *MockEC2APIMockRecorder) AttachVpnGatewayWithContext(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, "AttachVpnGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).AttachVpnGatewayWithContext), varargs...)
-}
-
-// AuthorizeClientVpnIngress mocks base method.
-func (m *MockEC2API) AuthorizeClientVpnIngress(arg0 *ec2.AuthorizeClientVpnIngressInput) (*ec2.AuthorizeClientVpnIngressOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AuthorizeClientVpnIngress", arg0)
-	ret0, _ := ret[0].(*ec2.AuthorizeClientVpnIngressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AuthorizeClientVpnIngress indicates an expected call of AuthorizeClientVpnIngress.
-func (mr *MockEC2APIMockRecorder) AuthorizeClientVpnIngress(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeClientVpnIngress", reflect.TypeOf((*MockEC2API)(nil).AuthorizeClientVpnIngress), arg0)
-}
-
-// AuthorizeClientVpnIngressRequest mocks base method.
-func (m *MockEC2API) AuthorizeClientVpnIngressRequest(arg0 *ec2.AuthorizeClientVpnIngressInput) (*request.Request, *ec2.AuthorizeClientVpnIngressOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AuthorizeClientVpnIngressRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AuthorizeClientVpnIngressOutput)
-	return ret0, ret1
-}
-
-// AuthorizeClientVpnIngressRequest indicates an expected call of AuthorizeClientVpnIngressRequest.
-func (mr *MockEC2APIMockRecorder) AuthorizeClientVpnIngressRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeClientVpnIngressRequest", reflect.TypeOf((*MockEC2API)(nil).AuthorizeClientVpnIngressRequest), arg0)
-}
-
-// AuthorizeClientVpnIngressWithContext mocks base method.
-func (m *MockEC2API) AuthorizeClientVpnIngressWithContext(arg0 context.Context, arg1 *ec2.AuthorizeClientVpnIngressInput, arg2 ...request.Option) (*ec2.AuthorizeClientVpnIngressOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "AuthorizeClientVpnIngressWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AuthorizeClientVpnIngressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AuthorizeClientVpnIngressWithContext indicates an expected call of AuthorizeClientVpnIngressWithContext.
-func (mr *MockEC2APIMockRecorder) AuthorizeClientVpnIngressWithContext(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, "AuthorizeClientVpnIngressWithContext", reflect.TypeOf((*MockEC2API)(nil).AuthorizeClientVpnIngressWithContext), varargs...)
-}
-
-// AuthorizeSecurityGroupEgress mocks base method.
-func (m *MockEC2API) AuthorizeSecurityGroupEgress(arg0 *ec2.AuthorizeSecurityGroupEgressInput) (*ec2.AuthorizeSecurityGroupEgressOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AuthorizeSecurityGroupEgress", arg0)
-	ret0, _ := ret[0].(*ec2.AuthorizeSecurityGroupEgressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AuthorizeSecurityGroupEgress indicates an expected call of AuthorizeSecurityGroupEgress.
-func (mr *MockEC2APIMockRecorder) AuthorizeSecurityGroupEgress(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupEgress", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupEgress), arg0)
-}
-
-// AuthorizeSecurityGroupEgressRequest mocks base method.
-func (m *MockEC2API) AuthorizeSecurityGroupEgressRequest(arg0 *ec2.AuthorizeSecurityGroupEgressInput) (*request.Request, *ec2.AuthorizeSecurityGroupEgressOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AuthorizeSecurityGroupEgressRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AuthorizeSecurityGroupEgressOutput)
-	return ret0, ret1
-}
-
-// AuthorizeSecurityGroupEgressRequest indicates an expected call of AuthorizeSecurityGroupEgressRequest.
-func (mr *MockEC2APIMockRecorder) AuthorizeSecurityGroupEgressRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupEgressRequest", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupEgressRequest), arg0)
-}
-
-// AuthorizeSecurityGroupEgressWithContext mocks base method.
-func (m *MockEC2API) AuthorizeSecurityGroupEgressWithContext(arg0 context.Context, arg1 *ec2.AuthorizeSecurityGroupEgressInput, arg2 ...request.Option) (*ec2.AuthorizeSecurityGroupEgressOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "AuthorizeSecurityGroupEgressWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AuthorizeSecurityGroupEgressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AuthorizeSecurityGroupEgressWithContext indicates an expected call of AuthorizeSecurityGroupEgressWithContext.
-func (mr *MockEC2APIMockRecorder) AuthorizeSecurityGroupEgressWithContext(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, "AuthorizeSecurityGroupEgressWithContext", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupEgressWithContext), varargs...)
-}
-
-// AuthorizeSecurityGroupIngress mocks base method.
-func (m *MockEC2API) AuthorizeSecurityGroupIngress(arg0 *ec2.AuthorizeSecurityGroupIngressInput) (*ec2.AuthorizeSecurityGroupIngressOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AuthorizeSecurityGroupIngress", arg0)
-	ret0, _ := ret[0].(*ec2.AuthorizeSecurityGroupIngressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AuthorizeSecurityGroupIngress indicates an expected call of AuthorizeSecurityGroupIngress.
-func (mr *MockEC2APIMockRecorder) AuthorizeSecurityGroupIngress(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupIngress", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupIngress), arg0)
-}
-
-// AuthorizeSecurityGroupIngressRequest mocks base method.
-func (m *MockEC2API) AuthorizeSecurityGroupIngressRequest(arg0 *ec2.AuthorizeSecurityGroupIngressInput) (*request.Request, *ec2.AuthorizeSecurityGroupIngressOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AuthorizeSecurityGroupIngressRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.AuthorizeSecurityGroupIngressOutput)
-	return ret0, ret1
-}
-
-// AuthorizeSecurityGroupIngressRequest indicates an expected call of AuthorizeSecurityGroupIngressRequest.
-func (mr *MockEC2APIMockRecorder) AuthorizeSecurityGroupIngressRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupIngressRequest", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupIngressRequest), arg0)
-}
-
-// AuthorizeSecurityGroupIngressWithContext mocks base method.
-func (m *MockEC2API) AuthorizeSecurityGroupIngressWithContext(arg0 context.Context, arg1 *ec2.AuthorizeSecurityGroupIngressInput, arg2 ...request.Option) (*ec2.AuthorizeSecurityGroupIngressOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "AuthorizeSecurityGroupIngressWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.AuthorizeSecurityGroupIngressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AuthorizeSecurityGroupIngressWithContext indicates an expected call of AuthorizeSecurityGroupIngressWithContext.
-func (mr *MockEC2APIMockRecorder) AuthorizeSecurityGroupIngressWithContext(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, "AuthorizeSecurityGroupIngressWithContext", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupIngressWithContext), varargs...)
-}
-
-// BundleInstance mocks base method.
-func (m *MockEC2API) BundleInstance(arg0 *ec2.BundleInstanceInput) (*ec2.BundleInstanceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "BundleInstance", arg0)
-	ret0, _ := ret[0].(*ec2.BundleInstanceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// BundleInstance indicates an expected call of BundleInstance.
-func (mr *MockEC2APIMockRecorder) BundleInstance(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BundleInstance", reflect.TypeOf((*MockEC2API)(nil).BundleInstance), arg0)
-}
-
-// BundleInstanceRequest mocks base method.
-func (m *MockEC2API) BundleInstanceRequest(arg0 *ec2.BundleInstanceInput) (*request.Request, *ec2.BundleInstanceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "BundleInstanceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.BundleInstanceOutput)
-	return ret0, ret1
-}
-
-// BundleInstanceRequest indicates an expected call of BundleInstanceRequest.
-func (mr *MockEC2APIMockRecorder) BundleInstanceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BundleInstanceRequest", reflect.TypeOf((*MockEC2API)(nil).BundleInstanceRequest), arg0)
-}
-
-// BundleInstanceWithContext mocks base method.
-func (m *MockEC2API) BundleInstanceWithContext(arg0 context.Context, arg1 *ec2.BundleInstanceInput, arg2 ...request.Option) (*ec2.BundleInstanceOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "BundleInstanceWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.BundleInstanceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// BundleInstanceWithContext indicates an expected call of BundleInstanceWithContext.
-func (mr *MockEC2APIMockRecorder) BundleInstanceWithContext(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, "BundleInstanceWithContext", reflect.TypeOf((*MockEC2API)(nil).BundleInstanceWithContext), varargs...)
-}
-
-// CancelBundleTask mocks base method.
-func (m *MockEC2API) CancelBundleTask(arg0 *ec2.CancelBundleTaskInput) (*ec2.CancelBundleTaskOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelBundleTask", arg0)
-	ret0, _ := ret[0].(*ec2.CancelBundleTaskOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelBundleTask indicates an expected call of CancelBundleTask.
-func (mr *MockEC2APIMockRecorder) CancelBundleTask(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelBundleTask", reflect.TypeOf((*MockEC2API)(nil).CancelBundleTask), arg0)
-}
-
-// CancelBundleTaskRequest mocks base method.
-func (m *MockEC2API) CancelBundleTaskRequest(arg0 *ec2.CancelBundleTaskInput) (*request.Request, *ec2.CancelBundleTaskOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelBundleTaskRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CancelBundleTaskOutput)
-	return ret0, ret1
-}
-
-// CancelBundleTaskRequest indicates an expected call of CancelBundleTaskRequest.
-func (mr *MockEC2APIMockRecorder) CancelBundleTaskRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelBundleTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CancelBundleTaskRequest), arg0)
-}
-
-// CancelBundleTaskWithContext mocks base method.
-func (m *MockEC2API) CancelBundleTaskWithContext(arg0 context.Context, arg1 *ec2.CancelBundleTaskInput, arg2 ...request.Option) (*ec2.CancelBundleTaskOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CancelBundleTaskWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CancelBundleTaskOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelBundleTaskWithContext indicates an expected call of CancelBundleTaskWithContext.
-func (mr *MockEC2APIMockRecorder) CancelBundleTaskWithContext(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, "CancelBundleTaskWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelBundleTaskWithContext), varargs...)
-}
-
-// CancelCapacityReservation mocks base method.
-func (m *MockEC2API) CancelCapacityReservation(arg0 *ec2.CancelCapacityReservationInput) (*ec2.CancelCapacityReservationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelCapacityReservation", arg0)
-	ret0, _ := ret[0].(*ec2.CancelCapacityReservationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelCapacityReservation indicates an expected call of CancelCapacityReservation.
-func (mr *MockEC2APIMockRecorder) CancelCapacityReservation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelCapacityReservation", reflect.TypeOf((*MockEC2API)(nil).CancelCapacityReservation), arg0)
-}
-
-// CancelCapacityReservationFleets mocks base method.
-func (m *MockEC2API) CancelCapacityReservationFleets(arg0 *ec2.CancelCapacityReservationFleetsInput) (*ec2.CancelCapacityReservationFleetsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelCapacityReservationFleets", arg0)
-	ret0, _ := ret[0].(*ec2.CancelCapacityReservationFleetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelCapacityReservationFleets indicates an expected call of CancelCapacityReservationFleets.
-func (mr *MockEC2APIMockRecorder) CancelCapacityReservationFleets(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelCapacityReservationFleets", reflect.TypeOf((*MockEC2API)(nil).CancelCapacityReservationFleets), arg0)
-}
-
-// CancelCapacityReservationFleetsRequest mocks base method.
-func (m *MockEC2API) CancelCapacityReservationFleetsRequest(arg0 *ec2.CancelCapacityReservationFleetsInput) (*request.Request, *ec2.CancelCapacityReservationFleetsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelCapacityReservationFleetsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CancelCapacityReservationFleetsOutput)
-	return ret0, ret1
-}
-
-// CancelCapacityReservationFleetsRequest indicates an expected call of CancelCapacityReservationFleetsRequest.
-func (mr *MockEC2APIMockRecorder) CancelCapacityReservationFleetsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelCapacityReservationFleetsRequest", reflect.TypeOf((*MockEC2API)(nil).CancelCapacityReservationFleetsRequest), arg0)
-}
-
-// CancelCapacityReservationFleetsWithContext mocks base method.
-func (m *MockEC2API) CancelCapacityReservationFleetsWithContext(arg0 context.Context, arg1 *ec2.CancelCapacityReservationFleetsInput, arg2 ...request.Option) (*ec2.CancelCapacityReservationFleetsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CancelCapacityReservationFleetsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CancelCapacityReservationFleetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelCapacityReservationFleetsWithContext indicates an expected call of CancelCapacityReservationFleetsWithContext.
-func (mr *MockEC2APIMockRecorder) CancelCapacityReservationFleetsWithContext(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, "CancelCapacityReservationFleetsWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelCapacityReservationFleetsWithContext), varargs...)
-}
-
-// CancelCapacityReservationRequest mocks base method.
-func (m *MockEC2API) CancelCapacityReservationRequest(arg0 *ec2.CancelCapacityReservationInput) (*request.Request, *ec2.CancelCapacityReservationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelCapacityReservationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CancelCapacityReservationOutput)
-	return ret0, ret1
-}
-
-// CancelCapacityReservationRequest indicates an expected call of CancelCapacityReservationRequest.
-func (mr *MockEC2APIMockRecorder) CancelCapacityReservationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelCapacityReservationRequest", reflect.TypeOf((*MockEC2API)(nil).CancelCapacityReservationRequest), arg0)
-}
-
-// CancelCapacityReservationWithContext mocks base method.
-func (m *MockEC2API) CancelCapacityReservationWithContext(arg0 context.Context, arg1 *ec2.CancelCapacityReservationInput, arg2 ...request.Option) (*ec2.CancelCapacityReservationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CancelCapacityReservationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CancelCapacityReservationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelCapacityReservationWithContext indicates an expected call of CancelCapacityReservationWithContext.
-func (mr *MockEC2APIMockRecorder) CancelCapacityReservationWithContext(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, "CancelCapacityReservationWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelCapacityReservationWithContext), varargs...)
-}
-
-// CancelConversionTask mocks base method.
-func (m *MockEC2API) CancelConversionTask(arg0 *ec2.CancelConversionTaskInput) (*ec2.CancelConversionTaskOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelConversionTask", arg0)
-	ret0, _ := ret[0].(*ec2.CancelConversionTaskOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelConversionTask indicates an expected call of CancelConversionTask.
-func (mr *MockEC2APIMockRecorder) CancelConversionTask(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelConversionTask", reflect.TypeOf((*MockEC2API)(nil).CancelConversionTask), arg0)
-}
-
-// CancelConversionTaskRequest mocks base method.
-func (m *MockEC2API) CancelConversionTaskRequest(arg0 *ec2.CancelConversionTaskInput) (*request.Request, *ec2.CancelConversionTaskOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelConversionTaskRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CancelConversionTaskOutput)
-	return ret0, ret1
-}
-
-// CancelConversionTaskRequest indicates an expected call of CancelConversionTaskRequest.
-func (mr *MockEC2APIMockRecorder) CancelConversionTaskRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelConversionTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CancelConversionTaskRequest), arg0)
-}
-
-// CancelConversionTaskWithContext mocks base method.
-func (m *MockEC2API) CancelConversionTaskWithContext(arg0 context.Context, arg1 *ec2.CancelConversionTaskInput, arg2 ...request.Option) (*ec2.CancelConversionTaskOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CancelConversionTaskWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CancelConversionTaskOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelConversionTaskWithContext indicates an expected call of CancelConversionTaskWithContext.
-func (mr *MockEC2APIMockRecorder) CancelConversionTaskWithContext(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, "CancelConversionTaskWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelConversionTaskWithContext), varargs...)
-}
-
-// CancelExportTask mocks base method.
-func (m *MockEC2API) CancelExportTask(arg0 *ec2.CancelExportTaskInput) (*ec2.CancelExportTaskOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelExportTask", arg0)
-	ret0, _ := ret[0].(*ec2.CancelExportTaskOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelExportTask indicates an expected call of CancelExportTask.
-func (mr *MockEC2APIMockRecorder) CancelExportTask(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelExportTask", reflect.TypeOf((*MockEC2API)(nil).CancelExportTask), arg0)
-}
-
-// CancelExportTaskRequest mocks base method.
-func (m *MockEC2API) CancelExportTaskRequest(arg0 *ec2.CancelExportTaskInput) (*request.Request, *ec2.CancelExportTaskOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelExportTaskRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CancelExportTaskOutput)
-	return ret0, ret1
-}
-
-// CancelExportTaskRequest indicates an expected call of CancelExportTaskRequest.
-func (mr *MockEC2APIMockRecorder) CancelExportTaskRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelExportTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CancelExportTaskRequest), arg0)
-}
-
-// CancelExportTaskWithContext mocks base method.
-func (m *MockEC2API) CancelExportTaskWithContext(arg0 context.Context, arg1 *ec2.CancelExportTaskInput, arg2 ...request.Option) (*ec2.CancelExportTaskOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CancelExportTaskWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CancelExportTaskOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelExportTaskWithContext indicates an expected call of CancelExportTaskWithContext.
-func (mr *MockEC2APIMockRecorder) CancelExportTaskWithContext(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, "CancelExportTaskWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelExportTaskWithContext), varargs...)
-}
-
-// CancelImageLaunchPermission mocks base method.
-func (m *MockEC2API) CancelImageLaunchPermission(arg0 *ec2.CancelImageLaunchPermissionInput) (*ec2.CancelImageLaunchPermissionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelImageLaunchPermission", arg0)
-	ret0, _ := ret[0].(*ec2.CancelImageLaunchPermissionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelImageLaunchPermission indicates an expected call of CancelImageLaunchPermission.
-func (mr *MockEC2APIMockRecorder) CancelImageLaunchPermission(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelImageLaunchPermission", reflect.TypeOf((*MockEC2API)(nil).CancelImageLaunchPermission), arg0)
-}
-
-// CancelImageLaunchPermissionRequest mocks base method.
-func (m *MockEC2API) CancelImageLaunchPermissionRequest(arg0 *ec2.CancelImageLaunchPermissionInput) (*request.Request, *ec2.CancelImageLaunchPermissionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelImageLaunchPermissionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CancelImageLaunchPermissionOutput)
-	return ret0, ret1
-}
-
-// CancelImageLaunchPermissionRequest indicates an expected call of CancelImageLaunchPermissionRequest.
-func (mr *MockEC2APIMockRecorder) CancelImageLaunchPermissionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelImageLaunchPermissionRequest", reflect.TypeOf((*MockEC2API)(nil).CancelImageLaunchPermissionRequest), arg0)
-}
-
-// CancelImageLaunchPermissionWithContext mocks base method.
-func (m *MockEC2API) CancelImageLaunchPermissionWithContext(arg0 context.Context, arg1 *ec2.CancelImageLaunchPermissionInput, arg2 ...request.Option) (*ec2.CancelImageLaunchPermissionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CancelImageLaunchPermissionWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CancelImageLaunchPermissionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelImageLaunchPermissionWithContext indicates an expected call of CancelImageLaunchPermissionWithContext.
-func (mr *MockEC2APIMockRecorder) CancelImageLaunchPermissionWithContext(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, "CancelImageLaunchPermissionWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelImageLaunchPermissionWithContext), varargs...)
-}
-
-// CancelImportTask mocks base method.
-func (m *MockEC2API) CancelImportTask(arg0 *ec2.CancelImportTaskInput) (*ec2.CancelImportTaskOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelImportTask", arg0)
-	ret0, _ := ret[0].(*ec2.CancelImportTaskOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelImportTask indicates an expected call of CancelImportTask.
-func (mr *MockEC2APIMockRecorder) CancelImportTask(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelImportTask", reflect.TypeOf((*MockEC2API)(nil).CancelImportTask), arg0)
-}
-
-// CancelImportTaskRequest mocks base method.
-func (m *MockEC2API) CancelImportTaskRequest(arg0 *ec2.CancelImportTaskInput) (*request.Request, *ec2.CancelImportTaskOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelImportTaskRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CancelImportTaskOutput)
-	return ret0, ret1
-}
-
-// CancelImportTaskRequest indicates an expected call of CancelImportTaskRequest.
-func (mr *MockEC2APIMockRecorder) CancelImportTaskRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelImportTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CancelImportTaskRequest), arg0)
-}
-
-// CancelImportTaskWithContext mocks base method.
-func (m *MockEC2API) CancelImportTaskWithContext(arg0 context.Context, arg1 *ec2.CancelImportTaskInput, arg2 ...request.Option) (*ec2.CancelImportTaskOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CancelImportTaskWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CancelImportTaskOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelImportTaskWithContext indicates an expected call of CancelImportTaskWithContext.
-func (mr *MockEC2APIMockRecorder) CancelImportTaskWithContext(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, "CancelImportTaskWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelImportTaskWithContext), varargs...)
-}
-
-// CancelReservedInstancesListing mocks base method.
-func (m *MockEC2API) CancelReservedInstancesListing(arg0 *ec2.CancelReservedInstancesListingInput) (*ec2.CancelReservedInstancesListingOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelReservedInstancesListing", arg0)
-	ret0, _ := ret[0].(*ec2.CancelReservedInstancesListingOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelReservedInstancesListing indicates an expected call of CancelReservedInstancesListing.
-func (mr *MockEC2APIMockRecorder) CancelReservedInstancesListing(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelReservedInstancesListing", reflect.TypeOf((*MockEC2API)(nil).CancelReservedInstancesListing), arg0)
-}
-
-// CancelReservedInstancesListingRequest mocks base method.
-func (m *MockEC2API) CancelReservedInstancesListingRequest(arg0 *ec2.CancelReservedInstancesListingInput) (*request.Request, *ec2.CancelReservedInstancesListingOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelReservedInstancesListingRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CancelReservedInstancesListingOutput)
-	return ret0, ret1
-}
-
-// CancelReservedInstancesListingRequest indicates an expected call of CancelReservedInstancesListingRequest.
-func (mr *MockEC2APIMockRecorder) CancelReservedInstancesListingRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelReservedInstancesListingRequest", reflect.TypeOf((*MockEC2API)(nil).CancelReservedInstancesListingRequest), arg0)
-}
-
-// CancelReservedInstancesListingWithContext mocks base method.
-func (m *MockEC2API) CancelReservedInstancesListingWithContext(arg0 context.Context, arg1 *ec2.CancelReservedInstancesListingInput, arg2 ...request.Option) (*ec2.CancelReservedInstancesListingOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CancelReservedInstancesListingWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CancelReservedInstancesListingOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelReservedInstancesListingWithContext indicates an expected call of CancelReservedInstancesListingWithContext.
-func (mr *MockEC2APIMockRecorder) CancelReservedInstancesListingWithContext(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, "CancelReservedInstancesListingWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelReservedInstancesListingWithContext), varargs...)
-}
-
-// CancelSpotFleetRequests mocks base method.
-func (m *MockEC2API) CancelSpotFleetRequests(arg0 *ec2.CancelSpotFleetRequestsInput) (*ec2.CancelSpotFleetRequestsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelSpotFleetRequests", arg0)
-	ret0, _ := ret[0].(*ec2.CancelSpotFleetRequestsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelSpotFleetRequests indicates an expected call of CancelSpotFleetRequests.
-func (mr *MockEC2APIMockRecorder) CancelSpotFleetRequests(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotFleetRequests", reflect.TypeOf((*MockEC2API)(nil).CancelSpotFleetRequests), arg0)
-}
-
-// CancelSpotFleetRequestsRequest mocks base method.
-func (m *MockEC2API) CancelSpotFleetRequestsRequest(arg0 *ec2.CancelSpotFleetRequestsInput) (*request.Request, *ec2.CancelSpotFleetRequestsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelSpotFleetRequestsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CancelSpotFleetRequestsOutput)
-	return ret0, ret1
-}
-
-// CancelSpotFleetRequestsRequest indicates an expected call of CancelSpotFleetRequestsRequest.
-func (mr *MockEC2APIMockRecorder) CancelSpotFleetRequestsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotFleetRequestsRequest", reflect.TypeOf((*MockEC2API)(nil).CancelSpotFleetRequestsRequest), arg0)
-}
-
-// CancelSpotFleetRequestsWithContext mocks base method.
-func (m *MockEC2API) CancelSpotFleetRequestsWithContext(arg0 context.Context, arg1 *ec2.CancelSpotFleetRequestsInput, arg2 ...request.Option) (*ec2.CancelSpotFleetRequestsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CancelSpotFleetRequestsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CancelSpotFleetRequestsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelSpotFleetRequestsWithContext indicates an expected call of CancelSpotFleetRequestsWithContext.
-func (mr *MockEC2APIMockRecorder) CancelSpotFleetRequestsWithContext(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, "CancelSpotFleetRequestsWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelSpotFleetRequestsWithContext), varargs...)
-}
-
-// CancelSpotInstanceRequests mocks base method.
-func (m *MockEC2API) CancelSpotInstanceRequests(arg0 *ec2.CancelSpotInstanceRequestsInput) (*ec2.CancelSpotInstanceRequestsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelSpotInstanceRequests", arg0)
-	ret0, _ := ret[0].(*ec2.CancelSpotInstanceRequestsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelSpotInstanceRequests indicates an expected call of CancelSpotInstanceRequests.
-func (mr *MockEC2APIMockRecorder) CancelSpotInstanceRequests(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotInstanceRequests", reflect.TypeOf((*MockEC2API)(nil).CancelSpotInstanceRequests), arg0)
-}
-
-// CancelSpotInstanceRequestsRequest mocks base method.
-func (m *MockEC2API) CancelSpotInstanceRequestsRequest(arg0 *ec2.CancelSpotInstanceRequestsInput) (*request.Request, *ec2.CancelSpotInstanceRequestsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelSpotInstanceRequestsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CancelSpotInstanceRequestsOutput)
-	return ret0, ret1
-}
-
-// CancelSpotInstanceRequestsRequest indicates an expected call of CancelSpotInstanceRequestsRequest.
-func (mr *MockEC2APIMockRecorder) CancelSpotInstanceRequestsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotInstanceRequestsRequest", reflect.TypeOf((*MockEC2API)(nil).CancelSpotInstanceRequestsRequest), arg0)
-}
-
-// CancelSpotInstanceRequestsWithContext mocks base method.
-func (m *MockEC2API) CancelSpotInstanceRequestsWithContext(arg0 context.Context, arg1 *ec2.CancelSpotInstanceRequestsInput, arg2 ...request.Option) (*ec2.CancelSpotInstanceRequestsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CancelSpotInstanceRequestsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CancelSpotInstanceRequestsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelSpotInstanceRequestsWithContext indicates an expected call of CancelSpotInstanceRequestsWithContext.
-func (mr *MockEC2APIMockRecorder) CancelSpotInstanceRequestsWithContext(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, "CancelSpotInstanceRequestsWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelSpotInstanceRequestsWithContext), varargs...)
-}
-
-// ConfirmProductInstance mocks base method.
-func (m *MockEC2API) ConfirmProductInstance(arg0 *ec2.ConfirmProductInstanceInput) (*ec2.ConfirmProductInstanceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ConfirmProductInstance", arg0)
-	ret0, _ := ret[0].(*ec2.ConfirmProductInstanceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ConfirmProductInstance indicates an expected call of ConfirmProductInstance.
-func (mr *MockEC2APIMockRecorder) ConfirmProductInstance(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmProductInstance", reflect.TypeOf((*MockEC2API)(nil).ConfirmProductInstance), arg0)
-}
-
-// ConfirmProductInstanceRequest mocks base method.
-func (m *MockEC2API) ConfirmProductInstanceRequest(arg0 *ec2.ConfirmProductInstanceInput) (*request.Request, *ec2.ConfirmProductInstanceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ConfirmProductInstanceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ConfirmProductInstanceOutput)
-	return ret0, ret1
-}
-
-// ConfirmProductInstanceRequest indicates an expected call of ConfirmProductInstanceRequest.
-func (mr *MockEC2APIMockRecorder) ConfirmProductInstanceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmProductInstanceRequest", reflect.TypeOf((*MockEC2API)(nil).ConfirmProductInstanceRequest), arg0)
-}
-
-// ConfirmProductInstanceWithContext mocks base method.
-func (m *MockEC2API) ConfirmProductInstanceWithContext(arg0 context.Context, arg1 *ec2.ConfirmProductInstanceInput, arg2 ...request.Option) (*ec2.ConfirmProductInstanceOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ConfirmProductInstanceWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ConfirmProductInstanceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ConfirmProductInstanceWithContext indicates an expected call of ConfirmProductInstanceWithContext.
-func (mr *MockEC2APIMockRecorder) ConfirmProductInstanceWithContext(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, "ConfirmProductInstanceWithContext", reflect.TypeOf((*MockEC2API)(nil).ConfirmProductInstanceWithContext), varargs...)
-}
-
-// CopyFpgaImage mocks base method.
-func (m *MockEC2API) CopyFpgaImage(arg0 *ec2.CopyFpgaImageInput) (*ec2.CopyFpgaImageOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CopyFpgaImage", arg0)
-	ret0, _ := ret[0].(*ec2.CopyFpgaImageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CopyFpgaImage indicates an expected call of CopyFpgaImage.
-func (mr *MockEC2APIMockRecorder) CopyFpgaImage(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyFpgaImage", reflect.TypeOf((*MockEC2API)(nil).CopyFpgaImage), arg0)
-}
-
-// CopyFpgaImageRequest mocks base method.
-func (m *MockEC2API) CopyFpgaImageRequest(arg0 *ec2.CopyFpgaImageInput) (*request.Request, *ec2.CopyFpgaImageOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CopyFpgaImageRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CopyFpgaImageOutput)
-	return ret0, ret1
-}
-
-// CopyFpgaImageRequest indicates an expected call of CopyFpgaImageRequest.
-func (mr *MockEC2APIMockRecorder) CopyFpgaImageRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyFpgaImageRequest", reflect.TypeOf((*MockEC2API)(nil).CopyFpgaImageRequest), arg0)
-}
-
-// CopyFpgaImageWithContext mocks base method.
-func (m *MockEC2API) CopyFpgaImageWithContext(arg0 context.Context, arg1 *ec2.CopyFpgaImageInput, arg2 ...request.Option) (*ec2.CopyFpgaImageOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CopyFpgaImageWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CopyFpgaImageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CopyFpgaImageWithContext indicates an expected call of CopyFpgaImageWithContext.
-func (mr *MockEC2APIMockRecorder) CopyFpgaImageWithContext(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, "CopyFpgaImageWithContext", reflect.TypeOf((*MockEC2API)(nil).CopyFpgaImageWithContext), varargs...)
-}
-
-// CopyImage mocks base method.
-func (m *MockEC2API) CopyImage(arg0 *ec2.CopyImageInput) (*ec2.CopyImageOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CopyImage", arg0)
-	ret0, _ := ret[0].(*ec2.CopyImageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CopyImage indicates an expected call of CopyImage.
-func (mr *MockEC2APIMockRecorder) CopyImage(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyImage", reflect.TypeOf((*MockEC2API)(nil).CopyImage), arg0)
-}
-
-// CopyImageRequest mocks base method.
-func (m *MockEC2API) CopyImageRequest(arg0 *ec2.CopyImageInput) (*request.Request, *ec2.CopyImageOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CopyImageRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CopyImageOutput)
-	return ret0, ret1
-}
-
-// CopyImageRequest indicates an expected call of CopyImageRequest.
-func (mr *MockEC2APIMockRecorder) CopyImageRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyImageRequest", reflect.TypeOf((*MockEC2API)(nil).CopyImageRequest), arg0)
-}
-
-// CopyImageWithContext mocks base method.
-func (m *MockEC2API) CopyImageWithContext(arg0 context.Context, arg1 *ec2.CopyImageInput, arg2 ...request.Option) (*ec2.CopyImageOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CopyImageWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CopyImageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CopyImageWithContext indicates an expected call of CopyImageWithContext.
-func (mr *MockEC2APIMockRecorder) CopyImageWithContext(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, "CopyImageWithContext", reflect.TypeOf((*MockEC2API)(nil).CopyImageWithContext), varargs...)
-}
-
-// CopySnapshot mocks base method.
-func (m *MockEC2API) CopySnapshot(arg0 *ec2.CopySnapshotInput) (*ec2.CopySnapshotOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CopySnapshot", arg0)
-	ret0, _ := ret[0].(*ec2.CopySnapshotOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CopySnapshot indicates an expected call of CopySnapshot.
-func (mr *MockEC2APIMockRecorder) CopySnapshot(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopySnapshot", reflect.TypeOf((*MockEC2API)(nil).CopySnapshot), arg0)
-}
-
-// CopySnapshotRequest mocks base method.
-func (m *MockEC2API) CopySnapshotRequest(arg0 *ec2.CopySnapshotInput) (*request.Request, *ec2.CopySnapshotOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CopySnapshotRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CopySnapshotOutput)
-	return ret0, ret1
-}
-
-// CopySnapshotRequest indicates an expected call of CopySnapshotRequest.
-func (mr *MockEC2APIMockRecorder) CopySnapshotRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopySnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).CopySnapshotRequest), arg0)
-}
-
-// CopySnapshotWithContext mocks base method.
-func (m *MockEC2API) CopySnapshotWithContext(arg0 context.Context, arg1 *ec2.CopySnapshotInput, arg2 ...request.Option) (*ec2.CopySnapshotOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CopySnapshotWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CopySnapshotOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CopySnapshotWithContext indicates an expected call of CopySnapshotWithContext.
-func (mr *MockEC2APIMockRecorder) CopySnapshotWithContext(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, "CopySnapshotWithContext", reflect.TypeOf((*MockEC2API)(nil).CopySnapshotWithContext), varargs...)
-}
-
-// CreateCapacityReservation mocks base method.
-func (m *MockEC2API) CreateCapacityReservation(arg0 *ec2.CreateCapacityReservationInput) (*ec2.CreateCapacityReservationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateCapacityReservation", arg0)
-	ret0, _ := ret[0].(*ec2.CreateCapacityReservationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateCapacityReservation indicates an expected call of CreateCapacityReservation.
-func (mr *MockEC2APIMockRecorder) CreateCapacityReservation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCapacityReservation", reflect.TypeOf((*MockEC2API)(nil).CreateCapacityReservation), arg0)
-}
-
-// CreateCapacityReservationFleet mocks base method.
-func (m *MockEC2API) CreateCapacityReservationFleet(arg0 *ec2.CreateCapacityReservationFleetInput) (*ec2.CreateCapacityReservationFleetOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateCapacityReservationFleet", arg0)
-	ret0, _ := ret[0].(*ec2.CreateCapacityReservationFleetOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateCapacityReservationFleet indicates an expected call of CreateCapacityReservationFleet.
-func (mr *MockEC2APIMockRecorder) CreateCapacityReservationFleet(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCapacityReservationFleet", reflect.TypeOf((*MockEC2API)(nil).CreateCapacityReservationFleet), arg0)
-}
-
-// CreateCapacityReservationFleetRequest mocks base method.
-func (m *MockEC2API) CreateCapacityReservationFleetRequest(arg0 *ec2.CreateCapacityReservationFleetInput) (*request.Request, *ec2.CreateCapacityReservationFleetOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateCapacityReservationFleetRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateCapacityReservationFleetOutput)
-	return ret0, ret1
-}
-
-// CreateCapacityReservationFleetRequest indicates an expected call of CreateCapacityReservationFleetRequest.
-func (mr *MockEC2APIMockRecorder) CreateCapacityReservationFleetRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCapacityReservationFleetRequest", reflect.TypeOf((*MockEC2API)(nil).CreateCapacityReservationFleetRequest), arg0)
-}
-
-// CreateCapacityReservationFleetWithContext mocks base method.
-func (m *MockEC2API) CreateCapacityReservationFleetWithContext(arg0 context.Context, arg1 *ec2.CreateCapacityReservationFleetInput, arg2 ...request.Option) (*ec2.CreateCapacityReservationFleetOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateCapacityReservationFleetWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateCapacityReservationFleetOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateCapacityReservationFleetWithContext indicates an expected call of CreateCapacityReservationFleetWithContext.
-func (mr *MockEC2APIMockRecorder) CreateCapacityReservationFleetWithContext(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, "CreateCapacityReservationFleetWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateCapacityReservationFleetWithContext), varargs...)
-}
-
-// CreateCapacityReservationRequest mocks base method.
-func (m *MockEC2API) CreateCapacityReservationRequest(arg0 *ec2.CreateCapacityReservationInput) (*request.Request, *ec2.CreateCapacityReservationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateCapacityReservationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateCapacityReservationOutput)
-	return ret0, ret1
-}
-
-// CreateCapacityReservationRequest indicates an expected call of CreateCapacityReservationRequest.
-func (mr *MockEC2APIMockRecorder) CreateCapacityReservationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCapacityReservationRequest", reflect.TypeOf((*MockEC2API)(nil).CreateCapacityReservationRequest), arg0)
-}
-
-// CreateCapacityReservationWithContext mocks base method.
-func (m *MockEC2API) CreateCapacityReservationWithContext(arg0 context.Context, arg1 *ec2.CreateCapacityReservationInput, arg2 ...request.Option) (*ec2.CreateCapacityReservationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateCapacityReservationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateCapacityReservationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateCapacityReservationWithContext indicates an expected call of CreateCapacityReservationWithContext.
-func (mr *MockEC2APIMockRecorder) CreateCapacityReservationWithContext(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, "CreateCapacityReservationWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateCapacityReservationWithContext), varargs...)
-}
-
-// CreateCarrierGateway mocks base method.
-func (m *MockEC2API) CreateCarrierGateway(arg0 *ec2.CreateCarrierGatewayInput) (*ec2.CreateCarrierGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateCarrierGateway", arg0)
-	ret0, _ := ret[0].(*ec2.CreateCarrierGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateCarrierGateway indicates an expected call of CreateCarrierGateway.
-func (mr *MockEC2APIMockRecorder) CreateCarrierGateway(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCarrierGateway", reflect.TypeOf((*MockEC2API)(nil).CreateCarrierGateway), arg0)
-}
-
-// CreateCarrierGatewayRequest mocks base method.
-func (m *MockEC2API) CreateCarrierGatewayRequest(arg0 *ec2.CreateCarrierGatewayInput) (*request.Request, *ec2.CreateCarrierGatewayOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateCarrierGatewayRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateCarrierGatewayOutput)
-	return ret0, ret1
-}
-
-// CreateCarrierGatewayRequest indicates an expected call of CreateCarrierGatewayRequest.
-func (mr *MockEC2APIMockRecorder) CreateCarrierGatewayRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCarrierGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateCarrierGatewayRequest), arg0)
-}
-
-// CreateCarrierGatewayWithContext mocks base method.
-func (m *MockEC2API) CreateCarrierGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateCarrierGatewayInput, arg2 ...request.Option) (*ec2.CreateCarrierGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateCarrierGatewayWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateCarrierGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateCarrierGatewayWithContext indicates an expected call of CreateCarrierGatewayWithContext.
-func (mr *MockEC2APIMockRecorder) CreateCarrierGatewayWithContext(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, "CreateCarrierGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateCarrierGatewayWithContext), varargs...)
-}
-
-// CreateClientVpnEndpoint mocks base method.
-func (m *MockEC2API) CreateClientVpnEndpoint(arg0 *ec2.CreateClientVpnEndpointInput) (*ec2.CreateClientVpnEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateClientVpnEndpoint", arg0)
-	ret0, _ := ret[0].(*ec2.CreateClientVpnEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateClientVpnEndpoint indicates an expected call of CreateClientVpnEndpoint.
-func (mr *MockEC2APIMockRecorder) CreateClientVpnEndpoint(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnEndpoint", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnEndpoint), arg0)
-}
-
-// CreateClientVpnEndpointRequest mocks base method.
-func (m *MockEC2API) CreateClientVpnEndpointRequest(arg0 *ec2.CreateClientVpnEndpointInput) (*request.Request, *ec2.CreateClientVpnEndpointOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateClientVpnEndpointRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateClientVpnEndpointOutput)
-	return ret0, ret1
-}
-
-// CreateClientVpnEndpointRequest indicates an expected call of CreateClientVpnEndpointRequest.
-func (mr *MockEC2APIMockRecorder) CreateClientVpnEndpointRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnEndpointRequest), arg0)
-}
-
-// CreateClientVpnEndpointWithContext mocks base method.
-func (m *MockEC2API) CreateClientVpnEndpointWithContext(arg0 context.Context, arg1 *ec2.CreateClientVpnEndpointInput, arg2 ...request.Option) (*ec2.CreateClientVpnEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateClientVpnEndpointWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateClientVpnEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateClientVpnEndpointWithContext indicates an expected call of CreateClientVpnEndpointWithContext.
-func (mr *MockEC2APIMockRecorder) CreateClientVpnEndpointWithContext(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, "CreateClientVpnEndpointWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnEndpointWithContext), varargs...)
-}
-
-// CreateClientVpnRoute mocks base method.
-func (m *MockEC2API) CreateClientVpnRoute(arg0 *ec2.CreateClientVpnRouteInput) (*ec2.CreateClientVpnRouteOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateClientVpnRoute", arg0)
-	ret0, _ := ret[0].(*ec2.CreateClientVpnRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateClientVpnRoute indicates an expected call of CreateClientVpnRoute.
-func (mr *MockEC2APIMockRecorder) CreateClientVpnRoute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnRoute", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnRoute), arg0)
-}
-
-// CreateClientVpnRouteRequest mocks base method.
-func (m *MockEC2API) CreateClientVpnRouteRequest(arg0 *ec2.CreateClientVpnRouteInput) (*request.Request, *ec2.CreateClientVpnRouteOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateClientVpnRouteRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateClientVpnRouteOutput)
-	return ret0, ret1
-}
-
-// CreateClientVpnRouteRequest indicates an expected call of CreateClientVpnRouteRequest.
-func (mr *MockEC2APIMockRecorder) CreateClientVpnRouteRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnRouteRequest), arg0)
-}
-
-// CreateClientVpnRouteWithContext mocks base method.
-func (m *MockEC2API) CreateClientVpnRouteWithContext(arg0 context.Context, arg1 *ec2.CreateClientVpnRouteInput, arg2 ...request.Option) (*ec2.CreateClientVpnRouteOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateClientVpnRouteWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateClientVpnRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateClientVpnRouteWithContext indicates an expected call of CreateClientVpnRouteWithContext.
-func (mr *MockEC2APIMockRecorder) CreateClientVpnRouteWithContext(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, "CreateClientVpnRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnRouteWithContext), varargs...)
-}
-
-// CreateCoipCidr mocks base method.
-func (m *MockEC2API) CreateCoipCidr(arg0 *ec2.CreateCoipCidrInput) (*ec2.CreateCoipCidrOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateCoipCidr", arg0)
-	ret0, _ := ret[0].(*ec2.CreateCoipCidrOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateCoipCidr indicates an expected call of CreateCoipCidr.
-func (mr *MockEC2APIMockRecorder) CreateCoipCidr(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCoipCidr", reflect.TypeOf((*MockEC2API)(nil).CreateCoipCidr), arg0)
-}
-
-// CreateCoipCidrRequest mocks base method.
-func (m *MockEC2API) CreateCoipCidrRequest(arg0 *ec2.CreateCoipCidrInput) (*request.Request, *ec2.CreateCoipCidrOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateCoipCidrRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateCoipCidrOutput)
-	return ret0, ret1
-}
-
-// CreateCoipCidrRequest indicates an expected call of CreateCoipCidrRequest.
-func (mr *MockEC2APIMockRecorder) CreateCoipCidrRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).CreateCoipCidrRequest), arg0)
-}
-
-// CreateCoipCidrWithContext mocks base method.
-func (m *MockEC2API) CreateCoipCidrWithContext(arg0 context.Context, arg1 *ec2.CreateCoipCidrInput, arg2 ...request.Option) (*ec2.CreateCoipCidrOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateCoipCidrWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateCoipCidrOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateCoipCidrWithContext indicates an expected call of CreateCoipCidrWithContext.
-func (mr *MockEC2APIMockRecorder) CreateCoipCidrWithContext(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, "CreateCoipCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateCoipCidrWithContext), varargs...)
-}
-
-// CreateCoipPool mocks base method.
-func (m *MockEC2API) CreateCoipPool(arg0 *ec2.CreateCoipPoolInput) (*ec2.CreateCoipPoolOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateCoipPool", arg0)
-	ret0, _ := ret[0].(*ec2.CreateCoipPoolOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateCoipPool indicates an expected call of CreateCoipPool.
-func (mr *MockEC2APIMockRecorder) CreateCoipPool(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCoipPool", reflect.TypeOf((*MockEC2API)(nil).CreateCoipPool), arg0)
-}
-
-// CreateCoipPoolRequest mocks base method.
-func (m *MockEC2API) CreateCoipPoolRequest(arg0 *ec2.CreateCoipPoolInput) (*request.Request, *ec2.CreateCoipPoolOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateCoipPoolRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateCoipPoolOutput)
-	return ret0, ret1
-}
-
-// CreateCoipPoolRequest indicates an expected call of CreateCoipPoolRequest.
-func (mr *MockEC2APIMockRecorder) CreateCoipPoolRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCoipPoolRequest", reflect.TypeOf((*MockEC2API)(nil).CreateCoipPoolRequest), arg0)
-}
-
-// CreateCoipPoolWithContext mocks base method.
-func (m *MockEC2API) CreateCoipPoolWithContext(arg0 context.Context, arg1 *ec2.CreateCoipPoolInput, arg2 ...request.Option) (*ec2.CreateCoipPoolOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateCoipPoolWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateCoipPoolOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateCoipPoolWithContext indicates an expected call of CreateCoipPoolWithContext.
-func (mr *MockEC2APIMockRecorder) CreateCoipPoolWithContext(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, "CreateCoipPoolWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateCoipPoolWithContext), varargs...)
-}
-
-// CreateCustomerGateway mocks base method.
-func (m *MockEC2API) CreateCustomerGateway(arg0 *ec2.CreateCustomerGatewayInput) (*ec2.CreateCustomerGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateCustomerGateway", arg0)
-	ret0, _ := ret[0].(*ec2.CreateCustomerGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateCustomerGateway indicates an expected call of CreateCustomerGateway.
-func (mr *MockEC2APIMockRecorder) CreateCustomerGateway(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomerGateway", reflect.TypeOf((*MockEC2API)(nil).CreateCustomerGateway), arg0)
-}
-
-// CreateCustomerGatewayRequest mocks base method.
-func (m *MockEC2API) CreateCustomerGatewayRequest(arg0 *ec2.CreateCustomerGatewayInput) (*request.Request, *ec2.CreateCustomerGatewayOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateCustomerGatewayRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateCustomerGatewayOutput)
-	return ret0, ret1
-}
-
-// CreateCustomerGatewayRequest indicates an expected call of CreateCustomerGatewayRequest.
-func (mr *MockEC2APIMockRecorder) CreateCustomerGatewayRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomerGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateCustomerGatewayRequest), arg0)
-}
-
-// CreateCustomerGatewayWithContext mocks base method.
-func (m *MockEC2API) CreateCustomerGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateCustomerGatewayInput, arg2 ...request.Option) (*ec2.CreateCustomerGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateCustomerGatewayWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateCustomerGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateCustomerGatewayWithContext indicates an expected call of CreateCustomerGatewayWithContext.
-func (mr *MockEC2APIMockRecorder) CreateCustomerGatewayWithContext(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, "CreateCustomerGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateCustomerGatewayWithContext), varargs...)
-}
-
-// CreateDefaultSubnet mocks base method.
-func (m *MockEC2API) CreateDefaultSubnet(arg0 *ec2.CreateDefaultSubnetInput) (*ec2.CreateDefaultSubnetOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateDefaultSubnet", arg0)
-	ret0, _ := ret[0].(*ec2.CreateDefaultSubnetOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateDefaultSubnet indicates an expected call of CreateDefaultSubnet.
-func (mr *MockEC2APIMockRecorder) CreateDefaultSubnet(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultSubnet", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultSubnet), arg0)
-}
-
-// CreateDefaultSubnetRequest mocks base method.
-func (m *MockEC2API) CreateDefaultSubnetRequest(arg0 *ec2.CreateDefaultSubnetInput) (*request.Request, *ec2.CreateDefaultSubnetOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateDefaultSubnetRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateDefaultSubnetOutput)
-	return ret0, ret1
-}
-
-// CreateDefaultSubnetRequest indicates an expected call of CreateDefaultSubnetRequest.
-func (mr *MockEC2APIMockRecorder) CreateDefaultSubnetRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultSubnetRequest", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultSubnetRequest), arg0)
-}
-
-// CreateDefaultSubnetWithContext mocks base method.
-func (m *MockEC2API) CreateDefaultSubnetWithContext(arg0 context.Context, arg1 *ec2.CreateDefaultSubnetInput, arg2 ...request.Option) (*ec2.CreateDefaultSubnetOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateDefaultSubnetWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateDefaultSubnetOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateDefaultSubnetWithContext indicates an expected call of CreateDefaultSubnetWithContext.
-func (mr *MockEC2APIMockRecorder) CreateDefaultSubnetWithContext(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, "CreateDefaultSubnetWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultSubnetWithContext), varargs...)
-}
-
-// CreateDefaultVpc mocks base method.
-func (m *MockEC2API) CreateDefaultVpc(arg0 *ec2.CreateDefaultVpcInput) (*ec2.CreateDefaultVpcOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateDefaultVpc", arg0)
-	ret0, _ := ret[0].(*ec2.CreateDefaultVpcOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateDefaultVpc indicates an expected call of CreateDefaultVpc.
-func (mr *MockEC2APIMockRecorder) CreateDefaultVpc(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultVpc", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultVpc), arg0)
-}
-
-// CreateDefaultVpcRequest mocks base method.
-func (m *MockEC2API) CreateDefaultVpcRequest(arg0 *ec2.CreateDefaultVpcInput) (*request.Request, *ec2.CreateDefaultVpcOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateDefaultVpcRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateDefaultVpcOutput)
-	return ret0, ret1
-}
-
-// CreateDefaultVpcRequest indicates an expected call of CreateDefaultVpcRequest.
-func (mr *MockEC2APIMockRecorder) CreateDefaultVpcRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultVpcRequest", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultVpcRequest), arg0)
-}
-
-// CreateDefaultVpcWithContext mocks base method.
-func (m *MockEC2API) CreateDefaultVpcWithContext(arg0 context.Context, arg1 *ec2.CreateDefaultVpcInput, arg2 ...request.Option) (*ec2.CreateDefaultVpcOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateDefaultVpcWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateDefaultVpcOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateDefaultVpcWithContext indicates an expected call of CreateDefaultVpcWithContext.
-func (mr *MockEC2APIMockRecorder) CreateDefaultVpcWithContext(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, "CreateDefaultVpcWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultVpcWithContext), varargs...)
-}
-
-// CreateDhcpOptions mocks base method.
-func (m *MockEC2API) CreateDhcpOptions(arg0 *ec2.CreateDhcpOptionsInput) (*ec2.CreateDhcpOptionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateDhcpOptions", arg0)
-	ret0, _ := ret[0].(*ec2.CreateDhcpOptionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateDhcpOptions indicates an expected call of CreateDhcpOptions.
-func (mr *MockEC2APIMockRecorder) CreateDhcpOptions(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDhcpOptions", reflect.TypeOf((*MockEC2API)(nil).CreateDhcpOptions), arg0)
-}
-
-// CreateDhcpOptionsRequest mocks base method.
-func (m *MockEC2API) CreateDhcpOptionsRequest(arg0 *ec2.CreateDhcpOptionsInput) (*request.Request, *ec2.CreateDhcpOptionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateDhcpOptionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateDhcpOptionsOutput)
-	return ret0, ret1
-}
-
-// CreateDhcpOptionsRequest indicates an expected call of CreateDhcpOptionsRequest.
-func (mr *MockEC2APIMockRecorder) CreateDhcpOptionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDhcpOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).CreateDhcpOptionsRequest), arg0)
-}
-
-// CreateDhcpOptionsWithContext mocks base method.
-func (m *MockEC2API) CreateDhcpOptionsWithContext(arg0 context.Context, arg1 *ec2.CreateDhcpOptionsInput, arg2 ...request.Option) (*ec2.CreateDhcpOptionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateDhcpOptionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateDhcpOptionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateDhcpOptionsWithContext indicates an expected call of CreateDhcpOptionsWithContext.
-func (mr *MockEC2APIMockRecorder) CreateDhcpOptionsWithContext(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, "CreateDhcpOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateDhcpOptionsWithContext), varargs...)
-}
-
-// CreateEgressOnlyInternetGateway mocks base method.
-func (m *MockEC2API) CreateEgressOnlyInternetGateway(arg0 *ec2.CreateEgressOnlyInternetGatewayInput) (*ec2.CreateEgressOnlyInternetGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateEgressOnlyInternetGateway", arg0)
-	ret0, _ := ret[0].(*ec2.CreateEgressOnlyInternetGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateEgressOnlyInternetGateway indicates an expected call of CreateEgressOnlyInternetGateway.
-func (mr *MockEC2APIMockRecorder) CreateEgressOnlyInternetGateway(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEgressOnlyInternetGateway", reflect.TypeOf((*MockEC2API)(nil).CreateEgressOnlyInternetGateway), arg0)
-}
-
-// CreateEgressOnlyInternetGatewayRequest mocks base method.
-func (m *MockEC2API) CreateEgressOnlyInternetGatewayRequest(arg0 *ec2.CreateEgressOnlyInternetGatewayInput) (*request.Request, *ec2.CreateEgressOnlyInternetGatewayOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateEgressOnlyInternetGatewayRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateEgressOnlyInternetGatewayOutput)
-	return ret0, ret1
-}
-
-// CreateEgressOnlyInternetGatewayRequest indicates an expected call of CreateEgressOnlyInternetGatewayRequest.
-func (mr *MockEC2APIMockRecorder) CreateEgressOnlyInternetGatewayRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEgressOnlyInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateEgressOnlyInternetGatewayRequest), arg0)
-}
-
-// CreateEgressOnlyInternetGatewayWithContext mocks base method.
-func (m *MockEC2API) CreateEgressOnlyInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateEgressOnlyInternetGatewayInput, arg2 ...request.Option) (*ec2.CreateEgressOnlyInternetGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateEgressOnlyInternetGatewayWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateEgressOnlyInternetGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateEgressOnlyInternetGatewayWithContext indicates an expected call of CreateEgressOnlyInternetGatewayWithContext.
-func (mr *MockEC2APIMockRecorder) CreateEgressOnlyInternetGatewayWithContext(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, "CreateEgressOnlyInternetGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateEgressOnlyInternetGatewayWithContext), varargs...)
-}
-
-// CreateFleet mocks base method.
-func (m *MockEC2API) CreateFleet(arg0 *ec2.CreateFleetInput) (*ec2.CreateFleetOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateFleet", arg0)
-	ret0, _ := ret[0].(*ec2.CreateFleetOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateFleet indicates an expected call of CreateFleet.
-func (mr *MockEC2APIMockRecorder) CreateFleet(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFleet", reflect.TypeOf((*MockEC2API)(nil).CreateFleet), arg0)
-}
-
-// CreateFleetRequest mocks base method.
-func (m *MockEC2API) CreateFleetRequest(arg0 *ec2.CreateFleetInput) (*request.Request, *ec2.CreateFleetOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateFleetRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateFleetOutput)
-	return ret0, ret1
-}
-
-// CreateFleetRequest indicates an expected call of CreateFleetRequest.
-func (mr *MockEC2APIMockRecorder) CreateFleetRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFleetRequest", reflect.TypeOf((*MockEC2API)(nil).CreateFleetRequest), arg0)
-}
-
-// CreateFleetWithContext mocks base method.
-func (m *MockEC2API) CreateFleetWithContext(arg0 context.Context, arg1 *ec2.CreateFleetInput, arg2 ...request.Option) (*ec2.CreateFleetOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateFleetWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateFleetOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateFleetWithContext indicates an expected call of CreateFleetWithContext.
-func (mr *MockEC2APIMockRecorder) CreateFleetWithContext(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, "CreateFleetWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateFleetWithContext), varargs...)
-}
-
-// CreateFlowLogs mocks base method.
-func (m *MockEC2API) CreateFlowLogs(arg0 *ec2.CreateFlowLogsInput) (*ec2.CreateFlowLogsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateFlowLogs", arg0)
-	ret0, _ := ret[0].(*ec2.CreateFlowLogsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateFlowLogs indicates an expected call of CreateFlowLogs.
-func (mr *MockEC2APIMockRecorder) CreateFlowLogs(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFlowLogs", reflect.TypeOf((*MockEC2API)(nil).CreateFlowLogs), arg0)
-}
-
-// CreateFlowLogsRequest mocks base method.
-func (m *MockEC2API) CreateFlowLogsRequest(arg0 *ec2.CreateFlowLogsInput) (*request.Request, *ec2.CreateFlowLogsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateFlowLogsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateFlowLogsOutput)
-	return ret0, ret1
-}
-
-// CreateFlowLogsRequest indicates an expected call of CreateFlowLogsRequest.
-func (mr *MockEC2APIMockRecorder) CreateFlowLogsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFlowLogsRequest", reflect.TypeOf((*MockEC2API)(nil).CreateFlowLogsRequest), arg0)
-}
-
-// CreateFlowLogsWithContext mocks base method.
-func (m *MockEC2API) CreateFlowLogsWithContext(arg0 context.Context, arg1 *ec2.CreateFlowLogsInput, arg2 ...request.Option) (*ec2.CreateFlowLogsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateFlowLogsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateFlowLogsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateFlowLogsWithContext indicates an expected call of CreateFlowLogsWithContext.
-func (mr *MockEC2APIMockRecorder) CreateFlowLogsWithContext(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, "CreateFlowLogsWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateFlowLogsWithContext), varargs...)
-}
-
-// CreateFpgaImage mocks base method.
-func (m *MockEC2API) CreateFpgaImage(arg0 *ec2.CreateFpgaImageInput) (*ec2.CreateFpgaImageOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateFpgaImage", arg0)
-	ret0, _ := ret[0].(*ec2.CreateFpgaImageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateFpgaImage indicates an expected call of CreateFpgaImage.
-func (mr *MockEC2APIMockRecorder) CreateFpgaImage(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFpgaImage", reflect.TypeOf((*MockEC2API)(nil).CreateFpgaImage), arg0)
-}
-
-// CreateFpgaImageRequest mocks base method.
-func (m *MockEC2API) CreateFpgaImageRequest(arg0 *ec2.CreateFpgaImageInput) (*request.Request, *ec2.CreateFpgaImageOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateFpgaImageRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateFpgaImageOutput)
-	return ret0, ret1
-}
-
-// CreateFpgaImageRequest indicates an expected call of CreateFpgaImageRequest.
-func (mr *MockEC2APIMockRecorder) CreateFpgaImageRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFpgaImageRequest", reflect.TypeOf((*MockEC2API)(nil).CreateFpgaImageRequest), arg0)
-}
-
-// CreateFpgaImageWithContext mocks base method.
-func (m *MockEC2API) CreateFpgaImageWithContext(arg0 context.Context, arg1 *ec2.CreateFpgaImageInput, arg2 ...request.Option) (*ec2.CreateFpgaImageOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateFpgaImageWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateFpgaImageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateFpgaImageWithContext indicates an expected call of CreateFpgaImageWithContext.
-func (mr *MockEC2APIMockRecorder) CreateFpgaImageWithContext(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, "CreateFpgaImageWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateFpgaImageWithContext), varargs...)
-}
-
-// CreateImage mocks base method.
-func (m *MockEC2API) CreateImage(arg0 *ec2.CreateImageInput) (*ec2.CreateImageOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateImage", arg0)
-	ret0, _ := ret[0].(*ec2.CreateImageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateImage indicates an expected call of CreateImage.
-func (mr *MockEC2APIMockRecorder) CreateImage(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateImage", reflect.TypeOf((*MockEC2API)(nil).CreateImage), arg0)
-}
-
-// CreateImageRequest mocks base method.
-func (m *MockEC2API) CreateImageRequest(arg0 *ec2.CreateImageInput) (*request.Request, *ec2.CreateImageOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateImageRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateImageOutput)
-	return ret0, ret1
-}
-
-// CreateImageRequest indicates an expected call of CreateImageRequest.
-func (mr *MockEC2APIMockRecorder) CreateImageRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateImageRequest", reflect.TypeOf((*MockEC2API)(nil).CreateImageRequest), arg0)
-}
-
-// CreateImageWithContext mocks base method.
-func (m *MockEC2API) CreateImageWithContext(arg0 context.Context, arg1 *ec2.CreateImageInput, arg2 ...request.Option) (*ec2.CreateImageOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateImageWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateImageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateImageWithContext indicates an expected call of CreateImageWithContext.
-func (mr *MockEC2APIMockRecorder) CreateImageWithContext(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, "CreateImageWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateImageWithContext), varargs...)
-}
-
-// CreateInstanceConnectEndpoint mocks base method.
-func (m *MockEC2API) CreateInstanceConnectEndpoint(arg0 *ec2.CreateInstanceConnectEndpointInput) (*ec2.CreateInstanceConnectEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateInstanceConnectEndpoint", arg0)
-	ret0, _ := ret[0].(*ec2.CreateInstanceConnectEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateInstanceConnectEndpoint indicates an expected call of CreateInstanceConnectEndpoint.
-func (mr *MockEC2APIMockRecorder) CreateInstanceConnectEndpoint(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceConnectEndpoint", reflect.TypeOf((*MockEC2API)(nil).CreateInstanceConnectEndpoint), arg0)
-}
-
-// CreateInstanceConnectEndpointRequest mocks base method.
-func (m *MockEC2API) CreateInstanceConnectEndpointRequest(arg0 *ec2.CreateInstanceConnectEndpointInput) (*request.Request, *ec2.CreateInstanceConnectEndpointOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateInstanceConnectEndpointRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateInstanceConnectEndpointOutput)
-	return ret0, ret1
-}
-
-// CreateInstanceConnectEndpointRequest indicates an expected call of CreateInstanceConnectEndpointRequest.
-func (mr *MockEC2APIMockRecorder) CreateInstanceConnectEndpointRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceConnectEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).CreateInstanceConnectEndpointRequest), arg0)
-}
-
-// CreateInstanceConnectEndpointWithContext mocks base method.
-func (m *MockEC2API) CreateInstanceConnectEndpointWithContext(arg0 context.Context, arg1 *ec2.CreateInstanceConnectEndpointInput, arg2 ...request.Option) (*ec2.CreateInstanceConnectEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateInstanceConnectEndpointWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateInstanceConnectEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateInstanceConnectEndpointWithContext indicates an expected call of CreateInstanceConnectEndpointWithContext.
-func (mr *MockEC2APIMockRecorder) CreateInstanceConnectEndpointWithContext(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, "CreateInstanceConnectEndpointWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateInstanceConnectEndpointWithContext), varargs...)
-}
-
-// CreateInstanceEventWindow mocks base method.
-func (m *MockEC2API) CreateInstanceEventWindow(arg0 *ec2.CreateInstanceEventWindowInput) (*ec2.CreateInstanceEventWindowOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateInstanceEventWindow", arg0)
-	ret0, _ := ret[0].(*ec2.CreateInstanceEventWindowOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateInstanceEventWindow indicates an expected call of CreateInstanceEventWindow.
-func (mr *MockEC2APIMockRecorder) CreateInstanceEventWindow(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceEventWindow", reflect.TypeOf((*MockEC2API)(nil).CreateInstanceEventWindow), arg0)
-}
-
-// CreateInstanceEventWindowRequest mocks base method.
-func (m *MockEC2API) CreateInstanceEventWindowRequest(arg0 *ec2.CreateInstanceEventWindowInput) (*request.Request, *ec2.CreateInstanceEventWindowOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateInstanceEventWindowRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateInstanceEventWindowOutput)
-	return ret0, ret1
-}
-
-// CreateInstanceEventWindowRequest indicates an expected call of CreateInstanceEventWindowRequest.
-func (mr *MockEC2APIMockRecorder) CreateInstanceEventWindowRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceEventWindowRequest", reflect.TypeOf((*MockEC2API)(nil).CreateInstanceEventWindowRequest), arg0)
-}
-
-// CreateInstanceEventWindowWithContext mocks base method.
-func (m *MockEC2API) CreateInstanceEventWindowWithContext(arg0 context.Context, arg1 *ec2.CreateInstanceEventWindowInput, arg2 ...request.Option) (*ec2.CreateInstanceEventWindowOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateInstanceEventWindowWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateInstanceEventWindowOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateInstanceEventWindowWithContext indicates an expected call of CreateInstanceEventWindowWithContext.
-func (mr *MockEC2APIMockRecorder) CreateInstanceEventWindowWithContext(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, "CreateInstanceEventWindowWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateInstanceEventWindowWithContext), varargs...)
-}
-
-// CreateInstanceExportTask mocks base method.
-func (m *MockEC2API) CreateInstanceExportTask(arg0 *ec2.CreateInstanceExportTaskInput) (*ec2.CreateInstanceExportTaskOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateInstanceExportTask", arg0)
-	ret0, _ := ret[0].(*ec2.CreateInstanceExportTaskOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateInstanceExportTask indicates an expected call of CreateInstanceExportTask.
-func (mr *MockEC2APIMockRecorder) CreateInstanceExportTask(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceExportTask", reflect.TypeOf((*MockEC2API)(nil).CreateInstanceExportTask), arg0)
-}
-
-// CreateInstanceExportTaskRequest mocks base method.
-func (m *MockEC2API) CreateInstanceExportTaskRequest(arg0 *ec2.CreateInstanceExportTaskInput) (*request.Request, *ec2.CreateInstanceExportTaskOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateInstanceExportTaskRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateInstanceExportTaskOutput)
-	return ret0, ret1
-}
-
-// CreateInstanceExportTaskRequest indicates an expected call of CreateInstanceExportTaskRequest.
-func (mr *MockEC2APIMockRecorder) CreateInstanceExportTaskRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceExportTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CreateInstanceExportTaskRequest), arg0)
-}
-
-// CreateInstanceExportTaskWithContext mocks base method.
-func (m *MockEC2API) CreateInstanceExportTaskWithContext(arg0 context.Context, arg1 *ec2.CreateInstanceExportTaskInput, arg2 ...request.Option) (*ec2.CreateInstanceExportTaskOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateInstanceExportTaskWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateInstanceExportTaskOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateInstanceExportTaskWithContext indicates an expected call of CreateInstanceExportTaskWithContext.
-func (mr *MockEC2APIMockRecorder) CreateInstanceExportTaskWithContext(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, "CreateInstanceExportTaskWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateInstanceExportTaskWithContext), varargs...)
-}
-
-// CreateInternetGateway mocks base method.
-func (m *MockEC2API) CreateInternetGateway(arg0 *ec2.CreateInternetGatewayInput) (*ec2.CreateInternetGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateInternetGateway", arg0)
-	ret0, _ := ret[0].(*ec2.CreateInternetGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateInternetGateway indicates an expected call of CreateInternetGateway.
-func (mr *MockEC2APIMockRecorder) CreateInternetGateway(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInternetGateway", reflect.TypeOf((*MockEC2API)(nil).CreateInternetGateway), arg0)
-}
-
-// CreateInternetGatewayRequest mocks base method.
-func (m *MockEC2API) CreateInternetGatewayRequest(arg0 *ec2.CreateInternetGatewayInput) (*request.Request, *ec2.CreateInternetGatewayOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateInternetGatewayRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateInternetGatewayOutput)
-	return ret0, ret1
-}
-
-// CreateInternetGatewayRequest indicates an expected call of CreateInternetGatewayRequest.
-func (mr *MockEC2APIMockRecorder) CreateInternetGatewayRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateInternetGatewayRequest), arg0)
-}
-
-// CreateInternetGatewayWithContext mocks base method.
-func (m *MockEC2API) CreateInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateInternetGatewayInput, arg2 ...request.Option) (*ec2.CreateInternetGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateInternetGatewayWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateInternetGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateInternetGatewayWithContext indicates an expected call of CreateInternetGatewayWithContext.
-func (mr *MockEC2APIMockRecorder) CreateInternetGatewayWithContext(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, "CreateInternetGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateInternetGatewayWithContext), varargs...)
-}
-
-// CreateIpam mocks base method.
-func (m *MockEC2API) CreateIpam(arg0 *ec2.CreateIpamInput) (*ec2.CreateIpamOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateIpam", arg0)
-	ret0, _ := ret[0].(*ec2.CreateIpamOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateIpam indicates an expected call of CreateIpam.
-func (mr *MockEC2APIMockRecorder) CreateIpam(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpam", reflect.TypeOf((*MockEC2API)(nil).CreateIpam), arg0)
-}
-
-// CreateIpamExternalResourceVerificationToken mocks base method.
-func (m *MockEC2API) CreateIpamExternalResourceVerificationToken(arg0 *ec2.CreateIpamExternalResourceVerificationTokenInput) (*ec2.CreateIpamExternalResourceVerificationTokenOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateIpamExternalResourceVerificationToken", arg0)
-	ret0, _ := ret[0].(*ec2.CreateIpamExternalResourceVerificationTokenOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateIpamExternalResourceVerificationToken indicates an expected call of CreateIpamExternalResourceVerificationToken.
-func (mr *MockEC2APIMockRecorder) CreateIpamExternalResourceVerificationToken(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamExternalResourceVerificationToken", reflect.TypeOf((*MockEC2API)(nil).CreateIpamExternalResourceVerificationToken), arg0)
-}
-
-// CreateIpamExternalResourceVerificationTokenRequest mocks base method.
-func (m *MockEC2API) CreateIpamExternalResourceVerificationTokenRequest(arg0 *ec2.CreateIpamExternalResourceVerificationTokenInput) (*request.Request, *ec2.CreateIpamExternalResourceVerificationTokenOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateIpamExternalResourceVerificationTokenRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateIpamExternalResourceVerificationTokenOutput)
-	return ret0, ret1
-}
-
-// CreateIpamExternalResourceVerificationTokenRequest indicates an expected call of CreateIpamExternalResourceVerificationTokenRequest.
-func (mr *MockEC2APIMockRecorder) CreateIpamExternalResourceVerificationTokenRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamExternalResourceVerificationTokenRequest", reflect.TypeOf((*MockEC2API)(nil).CreateIpamExternalResourceVerificationTokenRequest), arg0)
-}
-
-// CreateIpamExternalResourceVerificationTokenWithContext mocks base method.
-func (m *MockEC2API) CreateIpamExternalResourceVerificationTokenWithContext(arg0 context.Context, arg1 *ec2.CreateIpamExternalResourceVerificationTokenInput, arg2 ...request.Option) (*ec2.CreateIpamExternalResourceVerificationTokenOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateIpamExternalResourceVerificationTokenWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateIpamExternalResourceVerificationTokenOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateIpamExternalResourceVerificationTokenWithContext indicates an expected call of CreateIpamExternalResourceVerificationTokenWithContext.
-func (mr *MockEC2APIMockRecorder) CreateIpamExternalResourceVerificationTokenWithContext(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, "CreateIpamExternalResourceVerificationTokenWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateIpamExternalResourceVerificationTokenWithContext), varargs...)
-}
-
-// CreateIpamPool mocks base method.
-func (m *MockEC2API) CreateIpamPool(arg0 *ec2.CreateIpamPoolInput) (*ec2.CreateIpamPoolOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateIpamPool", arg0)
-	ret0, _ := ret[0].(*ec2.CreateIpamPoolOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateIpamPool indicates an expected call of CreateIpamPool.
-func (mr *MockEC2APIMockRecorder) CreateIpamPool(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamPool", reflect.TypeOf((*MockEC2API)(nil).CreateIpamPool), arg0)
-}
-
-// CreateIpamPoolRequest mocks base method.
-func (m *MockEC2API) CreateIpamPoolRequest(arg0 *ec2.CreateIpamPoolInput) (*request.Request, *ec2.CreateIpamPoolOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateIpamPoolRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateIpamPoolOutput)
-	return ret0, ret1
-}
-
-// CreateIpamPoolRequest indicates an expected call of CreateIpamPoolRequest.
-func (mr *MockEC2APIMockRecorder) CreateIpamPoolRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamPoolRequest", reflect.TypeOf((*MockEC2API)(nil).CreateIpamPoolRequest), arg0)
-}
-
-// CreateIpamPoolWithContext mocks base method.
-func (m *MockEC2API) CreateIpamPoolWithContext(arg0 context.Context, arg1 *ec2.CreateIpamPoolInput, arg2 ...request.Option) (*ec2.CreateIpamPoolOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateIpamPoolWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateIpamPoolOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateIpamPoolWithContext indicates an expected call of CreateIpamPoolWithContext.
-func (mr *MockEC2APIMockRecorder) CreateIpamPoolWithContext(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, "CreateIpamPoolWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateIpamPoolWithContext), varargs...)
-}
-
-// CreateIpamRequest mocks base method.
-func (m *MockEC2API) CreateIpamRequest(arg0 *ec2.CreateIpamInput) (*request.Request, *ec2.CreateIpamOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateIpamRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateIpamOutput)
-	return ret0, ret1
-}
-
-// CreateIpamRequest indicates an expected call of CreateIpamRequest.
-func (mr *MockEC2APIMockRecorder) CreateIpamRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamRequest", reflect.TypeOf((*MockEC2API)(nil).CreateIpamRequest), arg0)
-}
-
-// CreateIpamResourceDiscovery mocks base method.
-func (m *MockEC2API) CreateIpamResourceDiscovery(arg0 *ec2.CreateIpamResourceDiscoveryInput) (*ec2.CreateIpamResourceDiscoveryOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateIpamResourceDiscovery", arg0)
-	ret0, _ := ret[0].(*ec2.CreateIpamResourceDiscoveryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateIpamResourceDiscovery indicates an expected call of CreateIpamResourceDiscovery.
-func (mr *MockEC2APIMockRecorder) CreateIpamResourceDiscovery(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamResourceDiscovery", reflect.TypeOf((*MockEC2API)(nil).CreateIpamResourceDiscovery), arg0)
-}
-
-// CreateIpamResourceDiscoveryRequest mocks base method.
-func (m *MockEC2API) CreateIpamResourceDiscoveryRequest(arg0 *ec2.CreateIpamResourceDiscoveryInput) (*request.Request, *ec2.CreateIpamResourceDiscoveryOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateIpamResourceDiscoveryRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateIpamResourceDiscoveryOutput)
-	return ret0, ret1
-}
-
-// CreateIpamResourceDiscoveryRequest indicates an expected call of CreateIpamResourceDiscoveryRequest.
-func (mr *MockEC2APIMockRecorder) CreateIpamResourceDiscoveryRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamResourceDiscoveryRequest", reflect.TypeOf((*MockEC2API)(nil).CreateIpamResourceDiscoveryRequest), arg0)
-}
-
-// CreateIpamResourceDiscoveryWithContext mocks base method.
-func (m *MockEC2API) CreateIpamResourceDiscoveryWithContext(arg0 context.Context, arg1 *ec2.CreateIpamResourceDiscoveryInput, arg2 ...request.Option) (*ec2.CreateIpamResourceDiscoveryOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateIpamResourceDiscoveryWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateIpamResourceDiscoveryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateIpamResourceDiscoveryWithContext indicates an expected call of CreateIpamResourceDiscoveryWithContext.
-func (mr *MockEC2APIMockRecorder) CreateIpamResourceDiscoveryWithContext(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, "CreateIpamResourceDiscoveryWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateIpamResourceDiscoveryWithContext), varargs...)
-}
-
-// CreateIpamScope mocks base method.
-func (m *MockEC2API) CreateIpamScope(arg0 *ec2.CreateIpamScopeInput) (*ec2.CreateIpamScopeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateIpamScope", arg0)
-	ret0, _ := ret[0].(*ec2.CreateIpamScopeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateIpamScope indicates an expected call of CreateIpamScope.
-func (mr *MockEC2APIMockRecorder) CreateIpamScope(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamScope", reflect.TypeOf((*MockEC2API)(nil).CreateIpamScope), arg0)
-}
-
-// CreateIpamScopeRequest mocks base method.
-func (m *MockEC2API) CreateIpamScopeRequest(arg0 *ec2.CreateIpamScopeInput) (*request.Request, *ec2.CreateIpamScopeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateIpamScopeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateIpamScopeOutput)
-	return ret0, ret1
-}
-
-// CreateIpamScopeRequest indicates an expected call of CreateIpamScopeRequest.
-func (mr *MockEC2APIMockRecorder) CreateIpamScopeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamScopeRequest", reflect.TypeOf((*MockEC2API)(nil).CreateIpamScopeRequest), arg0)
-}
-
-// CreateIpamScopeWithContext mocks base method.
-func (m *MockEC2API) CreateIpamScopeWithContext(arg0 context.Context, arg1 *ec2.CreateIpamScopeInput, arg2 ...request.Option) (*ec2.CreateIpamScopeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateIpamScopeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateIpamScopeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateIpamScopeWithContext indicates an expected call of CreateIpamScopeWithContext.
-func (mr *MockEC2APIMockRecorder) CreateIpamScopeWithContext(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, "CreateIpamScopeWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateIpamScopeWithContext), varargs...)
-}
-
-// CreateIpamWithContext mocks base method.
-func (m *MockEC2API) CreateIpamWithContext(arg0 context.Context, arg1 *ec2.CreateIpamInput, arg2 ...request.Option) (*ec2.CreateIpamOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateIpamWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateIpamOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateIpamWithContext indicates an expected call of CreateIpamWithContext.
-func (mr *MockEC2APIMockRecorder) CreateIpamWithContext(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, "CreateIpamWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateIpamWithContext), varargs...)
-}
-
-// CreateKeyPair mocks base method.
-func (m *MockEC2API) CreateKeyPair(arg0 *ec2.CreateKeyPairInput) (*ec2.CreateKeyPairOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateKeyPair", arg0)
-	ret0, _ := ret[0].(*ec2.CreateKeyPairOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateKeyPair indicates an expected call of CreateKeyPair.
-func (mr *MockEC2APIMockRecorder) CreateKeyPair(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKeyPair", reflect.TypeOf((*MockEC2API)(nil).CreateKeyPair), arg0)
-}
-
-// CreateKeyPairRequest mocks base method.
-func (m *MockEC2API) CreateKeyPairRequest(arg0 *ec2.CreateKeyPairInput) (*request.Request, *ec2.CreateKeyPairOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateKeyPairRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateKeyPairOutput)
-	return ret0, ret1
-}
-
-// CreateKeyPairRequest indicates an expected call of CreateKeyPairRequest.
-func (mr *MockEC2APIMockRecorder) CreateKeyPairRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKeyPairRequest", reflect.TypeOf((*MockEC2API)(nil).CreateKeyPairRequest), arg0)
-}
-
-// CreateKeyPairWithContext mocks base method.
-func (m *MockEC2API) CreateKeyPairWithContext(arg0 context.Context, arg1 *ec2.CreateKeyPairInput, arg2 ...request.Option) (*ec2.CreateKeyPairOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateKeyPairWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateKeyPairOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateKeyPairWithContext indicates an expected call of CreateKeyPairWithContext.
-func (mr *MockEC2APIMockRecorder) CreateKeyPairWithContext(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, "CreateKeyPairWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateKeyPairWithContext), varargs...)
-}
-
-// CreateLaunchTemplate mocks base method.
-func (m *MockEC2API) CreateLaunchTemplate(arg0 *ec2.CreateLaunchTemplateInput) (*ec2.CreateLaunchTemplateOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLaunchTemplate", arg0)
-	ret0, _ := ret[0].(*ec2.CreateLaunchTemplateOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateLaunchTemplate indicates an expected call of CreateLaunchTemplate.
-func (mr *MockEC2APIMockRecorder) CreateLaunchTemplate(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplate", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplate), arg0)
-}
-
-// CreateLaunchTemplateRequest mocks base method.
-func (m *MockEC2API) CreateLaunchTemplateRequest(arg0 *ec2.CreateLaunchTemplateInput) (*request.Request, *ec2.CreateLaunchTemplateOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLaunchTemplateRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateLaunchTemplateOutput)
-	return ret0, ret1
-}
-
-// CreateLaunchTemplateRequest indicates an expected call of CreateLaunchTemplateRequest.
-func (mr *MockEC2APIMockRecorder) CreateLaunchTemplateRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplateRequest", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplateRequest), arg0)
-}
-
-// CreateLaunchTemplateVersion mocks base method.
-func (m *MockEC2API) CreateLaunchTemplateVersion(arg0 *ec2.CreateLaunchTemplateVersionInput) (*ec2.CreateLaunchTemplateVersionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLaunchTemplateVersion", arg0)
-	ret0, _ := ret[0].(*ec2.CreateLaunchTemplateVersionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateLaunchTemplateVersion indicates an expected call of CreateLaunchTemplateVersion.
-func (mr *MockEC2APIMockRecorder) CreateLaunchTemplateVersion(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplateVersion", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplateVersion), arg0)
-}
-
-// CreateLaunchTemplateVersionRequest mocks base method.
-func (m *MockEC2API) CreateLaunchTemplateVersionRequest(arg0 *ec2.CreateLaunchTemplateVersionInput) (*request.Request, *ec2.CreateLaunchTemplateVersionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLaunchTemplateVersionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateLaunchTemplateVersionOutput)
-	return ret0, ret1
-}
-
-// CreateLaunchTemplateVersionRequest indicates an expected call of CreateLaunchTemplateVersionRequest.
-func (mr *MockEC2APIMockRecorder) CreateLaunchTemplateVersionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplateVersionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplateVersionRequest), arg0)
-}
-
-// CreateLaunchTemplateVersionWithContext mocks base method.
-func (m *MockEC2API) CreateLaunchTemplateVersionWithContext(arg0 context.Context, arg1 *ec2.CreateLaunchTemplateVersionInput, arg2 ...request.Option) (*ec2.CreateLaunchTemplateVersionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateLaunchTemplateVersionWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateLaunchTemplateVersionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateLaunchTemplateVersionWithContext indicates an expected call of CreateLaunchTemplateVersionWithContext.
-func (mr *MockEC2APIMockRecorder) CreateLaunchTemplateVersionWithContext(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, "CreateLaunchTemplateVersionWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplateVersionWithContext), varargs...)
-}
-
-// CreateLaunchTemplateWithContext mocks base method.
-func (m *MockEC2API) CreateLaunchTemplateWithContext(arg0 context.Context, arg1 *ec2.CreateLaunchTemplateInput, arg2 ...request.Option) (*ec2.CreateLaunchTemplateOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateLaunchTemplateWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateLaunchTemplateOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateLaunchTemplateWithContext indicates an expected call of CreateLaunchTemplateWithContext.
-func (mr *MockEC2APIMockRecorder) CreateLaunchTemplateWithContext(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, "CreateLaunchTemplateWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplateWithContext), varargs...)
-}
-
-// CreateLocalGatewayRoute mocks base method.
-func (m *MockEC2API) CreateLocalGatewayRoute(arg0 *ec2.CreateLocalGatewayRouteInput) (*ec2.CreateLocalGatewayRouteOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLocalGatewayRoute", arg0)
-	ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateLocalGatewayRoute indicates an expected call of CreateLocalGatewayRoute.
-func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRoute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRoute), arg0)
-}
-
-// CreateLocalGatewayRouteRequest mocks base method.
-func (m *MockEC2API) CreateLocalGatewayRouteRequest(arg0 *ec2.CreateLocalGatewayRouteInput) (*request.Request, *ec2.CreateLocalGatewayRouteOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLocalGatewayRouteRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateLocalGatewayRouteOutput)
-	return ret0, ret1
-}
-
-// CreateLocalGatewayRouteRequest indicates an expected call of CreateLocalGatewayRouteRequest.
-func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRouteRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteRequest), arg0)
-}
-
-// CreateLocalGatewayRouteTable mocks base method.
-func (m *MockEC2API) CreateLocalGatewayRouteTable(arg0 *ec2.CreateLocalGatewayRouteTableInput) (*ec2.CreateLocalGatewayRouteTableOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTable", arg0)
-	ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateLocalGatewayRouteTable indicates an expected call of CreateLocalGatewayRouteTable.
-func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRouteTable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteTable), arg0)
-}
-
-// CreateLocalGatewayRouteTableRequest mocks base method.
-func (m *MockEC2API) CreateLocalGatewayRouteTableRequest(arg0 *ec2.CreateLocalGatewayRouteTableInput) (*request.Request, *ec2.CreateLocalGatewayRouteTableOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateLocalGatewayRouteTableOutput)
-	return ret0, ret1
-}
-
-// CreateLocalGatewayRouteTableRequest indicates an expected call of CreateLocalGatewayRouteTableRequest.
-func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRouteTableRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteTableRequest), arg0)
-}
-
-// CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation mocks base method.
-func (m *MockEC2API) CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation(arg0 *ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput) (*ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation", arg0)
-	ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation indicates an expected call of CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation.
-func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation), arg0)
-}
-
-// CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest mocks base method.
-func (m *MockEC2API) CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest(arg0 *ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput) (*request.Request, *ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput)
-	return ret0, ret1
-}
-
-// CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest indicates an expected call of CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest.
-func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest), arg0)
-}
-
-// CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext mocks base method.
-func (m *MockEC2API) CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext(arg0 context.Context, arg1 *ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput, arg2 ...request.Option) (*ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext indicates an expected call of CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext.
-func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext(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, "CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext), varargs...)
-}
-
-// CreateLocalGatewayRouteTableVpcAssociation mocks base method.
-func (m *MockEC2API) CreateLocalGatewayRouteTableVpcAssociation(arg0 *ec2.CreateLocalGatewayRouteTableVpcAssociationInput) (*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableVpcAssociation", arg0)
-	ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateLocalGatewayRouteTableVpcAssociation indicates an expected call of CreateLocalGatewayRouteTableVpcAssociation.
-func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRouteTableVpcAssociation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteTableVpcAssociation", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteTableVpcAssociation), arg0)
-}
-
-// CreateLocalGatewayRouteTableVpcAssociationRequest mocks base method.
-func (m *MockEC2API) CreateLocalGatewayRouteTableVpcAssociationRequest(arg0 *ec2.CreateLocalGatewayRouteTableVpcAssociationInput) (*request.Request, *ec2.CreateLocalGatewayRouteTableVpcAssociationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableVpcAssociationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput)
-	return ret0, ret1
-}
-
-// CreateLocalGatewayRouteTableVpcAssociationRequest indicates an expected call of CreateLocalGatewayRouteTableVpcAssociationRequest.
-func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRouteTableVpcAssociationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteTableVpcAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteTableVpcAssociationRequest), arg0)
-}
-
-// CreateLocalGatewayRouteTableVpcAssociationWithContext mocks base method.
-func (m *MockEC2API) CreateLocalGatewayRouteTableVpcAssociationWithContext(arg0 context.Context, arg1 *ec2.CreateLocalGatewayRouteTableVpcAssociationInput, arg2 ...request.Option) (*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableVpcAssociationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateLocalGatewayRouteTableVpcAssociationWithContext indicates an expected call of CreateLocalGatewayRouteTableVpcAssociationWithContext.
-func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRouteTableVpcAssociationWithContext(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, "CreateLocalGatewayRouteTableVpcAssociationWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteTableVpcAssociationWithContext), varargs...)
-}
-
-// CreateLocalGatewayRouteTableWithContext mocks base method.
-func (m *MockEC2API) CreateLocalGatewayRouteTableWithContext(arg0 context.Context, arg1 *ec2.CreateLocalGatewayRouteTableInput, arg2 ...request.Option) (*ec2.CreateLocalGatewayRouteTableOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateLocalGatewayRouteTableWithContext indicates an expected call of CreateLocalGatewayRouteTableWithContext.
-func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRouteTableWithContext(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, "CreateLocalGatewayRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteTableWithContext), varargs...)
-}
-
-// CreateLocalGatewayRouteWithContext mocks base method.
-func (m *MockEC2API) CreateLocalGatewayRouteWithContext(arg0 context.Context, arg1 *ec2.CreateLocalGatewayRouteInput, arg2 ...request.Option) (*ec2.CreateLocalGatewayRouteOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateLocalGatewayRouteWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateLocalGatewayRouteWithContext indicates an expected call of CreateLocalGatewayRouteWithContext.
-func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRouteWithContext(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, "CreateLocalGatewayRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteWithContext), varargs...)
-}
-
-// CreateManagedPrefixList mocks base method.
-func (m *MockEC2API) CreateManagedPrefixList(arg0 *ec2.CreateManagedPrefixListInput) (*ec2.CreateManagedPrefixListOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateManagedPrefixList", arg0)
-	ret0, _ := ret[0].(*ec2.CreateManagedPrefixListOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateManagedPrefixList indicates an expected call of CreateManagedPrefixList.
-func (mr *MockEC2APIMockRecorder) CreateManagedPrefixList(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateManagedPrefixList", reflect.TypeOf((*MockEC2API)(nil).CreateManagedPrefixList), arg0)
-}
-
-// CreateManagedPrefixListRequest mocks base method.
-func (m *MockEC2API) CreateManagedPrefixListRequest(arg0 *ec2.CreateManagedPrefixListInput) (*request.Request, *ec2.CreateManagedPrefixListOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateManagedPrefixListRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateManagedPrefixListOutput)
-	return ret0, ret1
-}
-
-// CreateManagedPrefixListRequest indicates an expected call of CreateManagedPrefixListRequest.
-func (mr *MockEC2APIMockRecorder) CreateManagedPrefixListRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateManagedPrefixListRequest", reflect.TypeOf((*MockEC2API)(nil).CreateManagedPrefixListRequest), arg0)
-}
-
-// CreateManagedPrefixListWithContext mocks base method.
-func (m *MockEC2API) CreateManagedPrefixListWithContext(arg0 context.Context, arg1 *ec2.CreateManagedPrefixListInput, arg2 ...request.Option) (*ec2.CreateManagedPrefixListOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateManagedPrefixListWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateManagedPrefixListOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateManagedPrefixListWithContext indicates an expected call of CreateManagedPrefixListWithContext.
-func (mr *MockEC2APIMockRecorder) CreateManagedPrefixListWithContext(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, "CreateManagedPrefixListWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateManagedPrefixListWithContext), varargs...)
-}
-
-// CreateNatGateway mocks base method.
-func (m *MockEC2API) CreateNatGateway(arg0 *ec2.CreateNatGatewayInput) (*ec2.CreateNatGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateNatGateway", arg0)
-	ret0, _ := ret[0].(*ec2.CreateNatGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateNatGateway indicates an expected call of CreateNatGateway.
-func (mr *MockEC2APIMockRecorder) CreateNatGateway(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNatGateway", reflect.TypeOf((*MockEC2API)(nil).CreateNatGateway), arg0)
-}
-
-// CreateNatGatewayRequest mocks base method.
-func (m *MockEC2API) CreateNatGatewayRequest(arg0 *ec2.CreateNatGatewayInput) (*request.Request, *ec2.CreateNatGatewayOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateNatGatewayRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateNatGatewayOutput)
-	return ret0, ret1
-}
-
-// CreateNatGatewayRequest indicates an expected call of CreateNatGatewayRequest.
-func (mr *MockEC2APIMockRecorder) CreateNatGatewayRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNatGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNatGatewayRequest), arg0)
-}
-
-// CreateNatGatewayWithContext mocks base method.
-func (m *MockEC2API) CreateNatGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateNatGatewayInput, arg2 ...request.Option) (*ec2.CreateNatGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateNatGatewayWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateNatGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateNatGatewayWithContext indicates an expected call of CreateNatGatewayWithContext.
-func (mr *MockEC2APIMockRecorder) CreateNatGatewayWithContext(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, "CreateNatGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateNatGatewayWithContext), varargs...)
-}
-
-// CreateNetworkAcl mocks base method.
-func (m *MockEC2API) CreateNetworkAcl(arg0 *ec2.CreateNetworkAclInput) (*ec2.CreateNetworkAclOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateNetworkAcl", arg0)
-	ret0, _ := ret[0].(*ec2.CreateNetworkAclOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateNetworkAcl indicates an expected call of CreateNetworkAcl.
-func (mr *MockEC2APIMockRecorder) CreateNetworkAcl(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAcl", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAcl), arg0)
-}
-
-// CreateNetworkAclEntry mocks base method.
-func (m *MockEC2API) CreateNetworkAclEntry(arg0 *ec2.CreateNetworkAclEntryInput) (*ec2.CreateNetworkAclEntryOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateNetworkAclEntry", arg0)
-	ret0, _ := ret[0].(*ec2.CreateNetworkAclEntryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateNetworkAclEntry indicates an expected call of CreateNetworkAclEntry.
-func (mr *MockEC2APIMockRecorder) CreateNetworkAclEntry(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAclEntry", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAclEntry), arg0)
-}
-
-// CreateNetworkAclEntryRequest mocks base method.
-func (m *MockEC2API) CreateNetworkAclEntryRequest(arg0 *ec2.CreateNetworkAclEntryInput) (*request.Request, *ec2.CreateNetworkAclEntryOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateNetworkAclEntryRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateNetworkAclEntryOutput)
-	return ret0, ret1
-}
-
-// CreateNetworkAclEntryRequest indicates an expected call of CreateNetworkAclEntryRequest.
-func (mr *MockEC2APIMockRecorder) CreateNetworkAclEntryRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAclEntryRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAclEntryRequest), arg0)
-}
-
-// CreateNetworkAclEntryWithContext mocks base method.
-func (m *MockEC2API) CreateNetworkAclEntryWithContext(arg0 context.Context, arg1 *ec2.CreateNetworkAclEntryInput, arg2 ...request.Option) (*ec2.CreateNetworkAclEntryOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateNetworkAclEntryWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateNetworkAclEntryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateNetworkAclEntryWithContext indicates an expected call of CreateNetworkAclEntryWithContext.
-func (mr *MockEC2APIMockRecorder) CreateNetworkAclEntryWithContext(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, "CreateNetworkAclEntryWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAclEntryWithContext), varargs...)
-}
-
-// CreateNetworkAclRequest mocks base method.
-func (m *MockEC2API) CreateNetworkAclRequest(arg0 *ec2.CreateNetworkAclInput) (*request.Request, *ec2.CreateNetworkAclOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateNetworkAclRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateNetworkAclOutput)
-	return ret0, ret1
-}
-
-// CreateNetworkAclRequest indicates an expected call of CreateNetworkAclRequest.
-func (mr *MockEC2APIMockRecorder) CreateNetworkAclRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAclRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAclRequest), arg0)
-}
-
-// CreateNetworkAclWithContext mocks base method.
-func (m *MockEC2API) CreateNetworkAclWithContext(arg0 context.Context, arg1 *ec2.CreateNetworkAclInput, arg2 ...request.Option) (*ec2.CreateNetworkAclOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateNetworkAclWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateNetworkAclOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateNetworkAclWithContext indicates an expected call of CreateNetworkAclWithContext.
-func (mr *MockEC2APIMockRecorder) CreateNetworkAclWithContext(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, "CreateNetworkAclWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAclWithContext), varargs...)
-}
-
-// CreateNetworkInsightsAccessScope mocks base method.
-func (m *MockEC2API) CreateNetworkInsightsAccessScope(arg0 *ec2.CreateNetworkInsightsAccessScopeInput) (*ec2.CreateNetworkInsightsAccessScopeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateNetworkInsightsAccessScope", arg0)
-	ret0, _ := ret[0].(*ec2.CreateNetworkInsightsAccessScopeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateNetworkInsightsAccessScope indicates an expected call of CreateNetworkInsightsAccessScope.
-func (mr *MockEC2APIMockRecorder) CreateNetworkInsightsAccessScope(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInsightsAccessScope", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInsightsAccessScope), arg0)
-}
-
-// CreateNetworkInsightsAccessScopeRequest mocks base method.
-func (m *MockEC2API) CreateNetworkInsightsAccessScopeRequest(arg0 *ec2.CreateNetworkInsightsAccessScopeInput) (*request.Request, *ec2.CreateNetworkInsightsAccessScopeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateNetworkInsightsAccessScopeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateNetworkInsightsAccessScopeOutput)
-	return ret0, ret1
-}
-
-// CreateNetworkInsightsAccessScopeRequest indicates an expected call of CreateNetworkInsightsAccessScopeRequest.
-func (mr *MockEC2APIMockRecorder) CreateNetworkInsightsAccessScopeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInsightsAccessScopeRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInsightsAccessScopeRequest), arg0)
-}
-
-// CreateNetworkInsightsAccessScopeWithContext mocks base method.
-func (m *MockEC2API) CreateNetworkInsightsAccessScopeWithContext(arg0 context.Context, arg1 *ec2.CreateNetworkInsightsAccessScopeInput, arg2 ...request.Option) (*ec2.CreateNetworkInsightsAccessScopeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateNetworkInsightsAccessScopeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateNetworkInsightsAccessScopeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateNetworkInsightsAccessScopeWithContext indicates an expected call of CreateNetworkInsightsAccessScopeWithContext.
-func (mr *MockEC2APIMockRecorder) CreateNetworkInsightsAccessScopeWithContext(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, "CreateNetworkInsightsAccessScopeWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInsightsAccessScopeWithContext), varargs...)
-}
-
-// CreateNetworkInsightsPath mocks base method.
-func (m *MockEC2API) CreateNetworkInsightsPath(arg0 *ec2.CreateNetworkInsightsPathInput) (*ec2.CreateNetworkInsightsPathOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateNetworkInsightsPath", arg0)
-	ret0, _ := ret[0].(*ec2.CreateNetworkInsightsPathOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateNetworkInsightsPath indicates an expected call of CreateNetworkInsightsPath.
-func (mr *MockEC2APIMockRecorder) CreateNetworkInsightsPath(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInsightsPath", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInsightsPath), arg0)
-}
-
-// CreateNetworkInsightsPathRequest mocks base method.
-func (m *MockEC2API) CreateNetworkInsightsPathRequest(arg0 *ec2.CreateNetworkInsightsPathInput) (*request.Request, *ec2.CreateNetworkInsightsPathOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateNetworkInsightsPathRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateNetworkInsightsPathOutput)
-	return ret0, ret1
-}
-
-// CreateNetworkInsightsPathRequest indicates an expected call of CreateNetworkInsightsPathRequest.
-func (mr *MockEC2APIMockRecorder) CreateNetworkInsightsPathRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInsightsPathRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInsightsPathRequest), arg0)
-}
-
-// CreateNetworkInsightsPathWithContext mocks base method.
-func (m *MockEC2API) CreateNetworkInsightsPathWithContext(arg0 context.Context, arg1 *ec2.CreateNetworkInsightsPathInput, arg2 ...request.Option) (*ec2.CreateNetworkInsightsPathOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateNetworkInsightsPathWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateNetworkInsightsPathOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateNetworkInsightsPathWithContext indicates an expected call of CreateNetworkInsightsPathWithContext.
-func (mr *MockEC2APIMockRecorder) CreateNetworkInsightsPathWithContext(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, "CreateNetworkInsightsPathWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInsightsPathWithContext), varargs...)
-}
-
-// CreateNetworkInterface mocks base method.
-func (m *MockEC2API) CreateNetworkInterface(arg0 *ec2.CreateNetworkInterfaceInput) (*ec2.CreateNetworkInterfaceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateNetworkInterface", arg0)
-	ret0, _ := ret[0].(*ec2.CreateNetworkInterfaceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateNetworkInterface indicates an expected call of CreateNetworkInterface.
-func (mr *MockEC2APIMockRecorder) CreateNetworkInterface(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterface", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterface), arg0)
-}
-
-// CreateNetworkInterfacePermission mocks base method.
-func (m *MockEC2API) CreateNetworkInterfacePermission(arg0 *ec2.CreateNetworkInterfacePermissionInput) (*ec2.CreateNetworkInterfacePermissionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateNetworkInterfacePermission", arg0)
-	ret0, _ := ret[0].(*ec2.CreateNetworkInterfacePermissionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateNetworkInterfacePermission indicates an expected call of CreateNetworkInterfacePermission.
-func (mr *MockEC2APIMockRecorder) CreateNetworkInterfacePermission(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfacePermission", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterfacePermission), arg0)
-}
-
-// CreateNetworkInterfacePermissionRequest mocks base method.
-func (m *MockEC2API) CreateNetworkInterfacePermissionRequest(arg0 *ec2.CreateNetworkInterfacePermissionInput) (*request.Request, *ec2.CreateNetworkInterfacePermissionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateNetworkInterfacePermissionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateNetworkInterfacePermissionOutput)
-	return ret0, ret1
-}
-
-// CreateNetworkInterfacePermissionRequest indicates an expected call of CreateNetworkInterfacePermissionRequest.
-func (mr *MockEC2APIMockRecorder) CreateNetworkInterfacePermissionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfacePermissionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterfacePermissionRequest), arg0)
-}
-
-// CreateNetworkInterfacePermissionWithContext mocks base method.
-func (m *MockEC2API) CreateNetworkInterfacePermissionWithContext(arg0 context.Context, arg1 *ec2.CreateNetworkInterfacePermissionInput, arg2 ...request.Option) (*ec2.CreateNetworkInterfacePermissionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateNetworkInterfacePermissionWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateNetworkInterfacePermissionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateNetworkInterfacePermissionWithContext indicates an expected call of CreateNetworkInterfacePermissionWithContext.
-func (mr *MockEC2APIMockRecorder) CreateNetworkInterfacePermissionWithContext(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, "CreateNetworkInterfacePermissionWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterfacePermissionWithContext), varargs...)
-}
-
-// CreateNetworkInterfaceRequest mocks base method.
-func (m *MockEC2API) CreateNetworkInterfaceRequest(arg0 *ec2.CreateNetworkInterfaceInput) (*request.Request, *ec2.CreateNetworkInterfaceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateNetworkInterfaceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateNetworkInterfaceOutput)
-	return ret0, ret1
-}
-
-// CreateNetworkInterfaceRequest indicates an expected call of CreateNetworkInterfaceRequest.
-func (mr *MockEC2APIMockRecorder) CreateNetworkInterfaceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterfaceRequest), arg0)
-}
-
-// CreateNetworkInterfaceWithContext mocks base method.
-func (m *MockEC2API) CreateNetworkInterfaceWithContext(arg0 context.Context, arg1 *ec2.CreateNetworkInterfaceInput, arg2 ...request.Option) (*ec2.CreateNetworkInterfaceOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateNetworkInterfaceWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateNetworkInterfaceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateNetworkInterfaceWithContext indicates an expected call of CreateNetworkInterfaceWithContext.
-func (mr *MockEC2APIMockRecorder) CreateNetworkInterfaceWithContext(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, "CreateNetworkInterfaceWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterfaceWithContext), varargs...)
-}
-
-// CreatePlacementGroup mocks base method.
-func (m *MockEC2API) CreatePlacementGroup(arg0 *ec2.CreatePlacementGroupInput) (*ec2.CreatePlacementGroupOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreatePlacementGroup", arg0)
-	ret0, _ := ret[0].(*ec2.CreatePlacementGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreatePlacementGroup indicates an expected call of CreatePlacementGroup.
-func (mr *MockEC2APIMockRecorder) CreatePlacementGroup(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlacementGroup", reflect.TypeOf((*MockEC2API)(nil).CreatePlacementGroup), arg0)
-}
-
-// CreatePlacementGroupRequest mocks base method.
-func (m *MockEC2API) CreatePlacementGroupRequest(arg0 *ec2.CreatePlacementGroupInput) (*request.Request, *ec2.CreatePlacementGroupOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreatePlacementGroupRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreatePlacementGroupOutput)
-	return ret0, ret1
-}
-
-// CreatePlacementGroupRequest indicates an expected call of CreatePlacementGroupRequest.
-func (mr *MockEC2APIMockRecorder) CreatePlacementGroupRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlacementGroupRequest", reflect.TypeOf((*MockEC2API)(nil).CreatePlacementGroupRequest), arg0)
-}
-
-// CreatePlacementGroupWithContext mocks base method.
-func (m *MockEC2API) CreatePlacementGroupWithContext(arg0 context.Context, arg1 *ec2.CreatePlacementGroupInput, arg2 ...request.Option) (*ec2.CreatePlacementGroupOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreatePlacementGroupWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreatePlacementGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreatePlacementGroupWithContext indicates an expected call of CreatePlacementGroupWithContext.
-func (mr *MockEC2APIMockRecorder) CreatePlacementGroupWithContext(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, "CreatePlacementGroupWithContext", reflect.TypeOf((*MockEC2API)(nil).CreatePlacementGroupWithContext), varargs...)
-}
-
-// CreatePublicIpv4Pool mocks base method.
-func (m *MockEC2API) CreatePublicIpv4Pool(arg0 *ec2.CreatePublicIpv4PoolInput) (*ec2.CreatePublicIpv4PoolOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreatePublicIpv4Pool", arg0)
-	ret0, _ := ret[0].(*ec2.CreatePublicIpv4PoolOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreatePublicIpv4Pool indicates an expected call of CreatePublicIpv4Pool.
-func (mr *MockEC2APIMockRecorder) CreatePublicIpv4Pool(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePublicIpv4Pool", reflect.TypeOf((*MockEC2API)(nil).CreatePublicIpv4Pool), arg0)
-}
-
-// CreatePublicIpv4PoolRequest mocks base method.
-func (m *MockEC2API) CreatePublicIpv4PoolRequest(arg0 *ec2.CreatePublicIpv4PoolInput) (*request.Request, *ec2.CreatePublicIpv4PoolOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreatePublicIpv4PoolRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreatePublicIpv4PoolOutput)
-	return ret0, ret1
-}
-
-// CreatePublicIpv4PoolRequest indicates an expected call of CreatePublicIpv4PoolRequest.
-func (mr *MockEC2APIMockRecorder) CreatePublicIpv4PoolRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePublicIpv4PoolRequest", reflect.TypeOf((*MockEC2API)(nil).CreatePublicIpv4PoolRequest), arg0)
-}
-
-// CreatePublicIpv4PoolWithContext mocks base method.
-func (m *MockEC2API) CreatePublicIpv4PoolWithContext(arg0 context.Context, arg1 *ec2.CreatePublicIpv4PoolInput, arg2 ...request.Option) (*ec2.CreatePublicIpv4PoolOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreatePublicIpv4PoolWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreatePublicIpv4PoolOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreatePublicIpv4PoolWithContext indicates an expected call of CreatePublicIpv4PoolWithContext.
-func (mr *MockEC2APIMockRecorder) CreatePublicIpv4PoolWithContext(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, "CreatePublicIpv4PoolWithContext", reflect.TypeOf((*MockEC2API)(nil).CreatePublicIpv4PoolWithContext), varargs...)
-}
-
-// CreateReplaceRootVolumeTask mocks base method.
-func (m *MockEC2API) CreateReplaceRootVolumeTask(arg0 *ec2.CreateReplaceRootVolumeTaskInput) (*ec2.CreateReplaceRootVolumeTaskOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateReplaceRootVolumeTask", arg0)
-	ret0, _ := ret[0].(*ec2.CreateReplaceRootVolumeTaskOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateReplaceRootVolumeTask indicates an expected call of CreateReplaceRootVolumeTask.
-func (mr *MockEC2APIMockRecorder) CreateReplaceRootVolumeTask(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReplaceRootVolumeTask", reflect.TypeOf((*MockEC2API)(nil).CreateReplaceRootVolumeTask), arg0)
-}
-
-// CreateReplaceRootVolumeTaskRequest mocks base method.
-func (m *MockEC2API) CreateReplaceRootVolumeTaskRequest(arg0 *ec2.CreateReplaceRootVolumeTaskInput) (*request.Request, *ec2.CreateReplaceRootVolumeTaskOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateReplaceRootVolumeTaskRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateReplaceRootVolumeTaskOutput)
-	return ret0, ret1
-}
-
-// CreateReplaceRootVolumeTaskRequest indicates an expected call of CreateReplaceRootVolumeTaskRequest.
-func (mr *MockEC2APIMockRecorder) CreateReplaceRootVolumeTaskRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReplaceRootVolumeTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CreateReplaceRootVolumeTaskRequest), arg0)
-}
-
-// CreateReplaceRootVolumeTaskWithContext mocks base method.
-func (m *MockEC2API) CreateReplaceRootVolumeTaskWithContext(arg0 context.Context, arg1 *ec2.CreateReplaceRootVolumeTaskInput, arg2 ...request.Option) (*ec2.CreateReplaceRootVolumeTaskOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateReplaceRootVolumeTaskWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateReplaceRootVolumeTaskOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateReplaceRootVolumeTaskWithContext indicates an expected call of CreateReplaceRootVolumeTaskWithContext.
-func (mr *MockEC2APIMockRecorder) CreateReplaceRootVolumeTaskWithContext(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, "CreateReplaceRootVolumeTaskWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateReplaceRootVolumeTaskWithContext), varargs...)
-}
-
-// CreateReservedInstancesListing mocks base method.
-func (m *MockEC2API) CreateReservedInstancesListing(arg0 *ec2.CreateReservedInstancesListingInput) (*ec2.CreateReservedInstancesListingOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateReservedInstancesListing", arg0)
-	ret0, _ := ret[0].(*ec2.CreateReservedInstancesListingOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateReservedInstancesListing indicates an expected call of CreateReservedInstancesListing.
-func (mr *MockEC2APIMockRecorder) CreateReservedInstancesListing(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReservedInstancesListing", reflect.TypeOf((*MockEC2API)(nil).CreateReservedInstancesListing), arg0)
-}
-
-// CreateReservedInstancesListingRequest mocks base method.
-func (m *MockEC2API) CreateReservedInstancesListingRequest(arg0 *ec2.CreateReservedInstancesListingInput) (*request.Request, *ec2.CreateReservedInstancesListingOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateReservedInstancesListingRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateReservedInstancesListingOutput)
-	return ret0, ret1
-}
-
-// CreateReservedInstancesListingRequest indicates an expected call of CreateReservedInstancesListingRequest.
-func (mr *MockEC2APIMockRecorder) CreateReservedInstancesListingRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReservedInstancesListingRequest", reflect.TypeOf((*MockEC2API)(nil).CreateReservedInstancesListingRequest), arg0)
-}
-
-// CreateReservedInstancesListingWithContext mocks base method.
-func (m *MockEC2API) CreateReservedInstancesListingWithContext(arg0 context.Context, arg1 *ec2.CreateReservedInstancesListingInput, arg2 ...request.Option) (*ec2.CreateReservedInstancesListingOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateReservedInstancesListingWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateReservedInstancesListingOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateReservedInstancesListingWithContext indicates an expected call of CreateReservedInstancesListingWithContext.
-func (mr *MockEC2APIMockRecorder) CreateReservedInstancesListingWithContext(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, "CreateReservedInstancesListingWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateReservedInstancesListingWithContext), varargs...)
-}
-
-// CreateRestoreImageTask mocks base method.
-func (m *MockEC2API) CreateRestoreImageTask(arg0 *ec2.CreateRestoreImageTaskInput) (*ec2.CreateRestoreImageTaskOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateRestoreImageTask", arg0)
-	ret0, _ := ret[0].(*ec2.CreateRestoreImageTaskOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateRestoreImageTask indicates an expected call of CreateRestoreImageTask.
-func (mr *MockEC2APIMockRecorder) CreateRestoreImageTask(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRestoreImageTask", reflect.TypeOf((*MockEC2API)(nil).CreateRestoreImageTask), arg0)
-}
-
-// CreateRestoreImageTaskRequest mocks base method.
-func (m *MockEC2API) CreateRestoreImageTaskRequest(arg0 *ec2.CreateRestoreImageTaskInput) (*request.Request, *ec2.CreateRestoreImageTaskOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateRestoreImageTaskRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateRestoreImageTaskOutput)
-	return ret0, ret1
-}
-
-// CreateRestoreImageTaskRequest indicates an expected call of CreateRestoreImageTaskRequest.
-func (mr *MockEC2APIMockRecorder) CreateRestoreImageTaskRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRestoreImageTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CreateRestoreImageTaskRequest), arg0)
-}
-
-// CreateRestoreImageTaskWithContext mocks base method.
-func (m *MockEC2API) CreateRestoreImageTaskWithContext(arg0 context.Context, arg1 *ec2.CreateRestoreImageTaskInput, arg2 ...request.Option) (*ec2.CreateRestoreImageTaskOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateRestoreImageTaskWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateRestoreImageTaskOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateRestoreImageTaskWithContext indicates an expected call of CreateRestoreImageTaskWithContext.
-func (mr *MockEC2APIMockRecorder) CreateRestoreImageTaskWithContext(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, "CreateRestoreImageTaskWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateRestoreImageTaskWithContext), varargs...)
-}
-
-// CreateRoute mocks base method.
-func (m *MockEC2API) CreateRoute(arg0 *ec2.CreateRouteInput) (*ec2.CreateRouteOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateRoute", arg0)
-	ret0, _ := ret[0].(*ec2.CreateRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateRoute indicates an expected call of CreateRoute.
-func (mr *MockEC2APIMockRecorder) CreateRoute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRoute", reflect.TypeOf((*MockEC2API)(nil).CreateRoute), arg0)
-}
-
-// CreateRouteRequest mocks base method.
-func (m *MockEC2API) CreateRouteRequest(arg0 *ec2.CreateRouteInput) (*request.Request, *ec2.CreateRouteOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateRouteRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateRouteOutput)
-	return ret0, ret1
-}
-
-// CreateRouteRequest indicates an expected call of CreateRouteRequest.
-func (mr *MockEC2APIMockRecorder) CreateRouteRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateRouteRequest), arg0)
-}
-
-// CreateRouteTable mocks base method.
-func (m *MockEC2API) CreateRouteTable(arg0 *ec2.CreateRouteTableInput) (*ec2.CreateRouteTableOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateRouteTable", arg0)
-	ret0, _ := ret[0].(*ec2.CreateRouteTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateRouteTable indicates an expected call of CreateRouteTable.
-func (mr *MockEC2APIMockRecorder) CreateRouteTable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouteTable", reflect.TypeOf((*MockEC2API)(nil).CreateRouteTable), arg0)
-}
-
-// CreateRouteTableRequest mocks base method.
-func (m *MockEC2API) CreateRouteTableRequest(arg0 *ec2.CreateRouteTableInput) (*request.Request, *ec2.CreateRouteTableOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateRouteTableRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateRouteTableOutput)
-	return ret0, ret1
-}
-
-// CreateRouteTableRequest indicates an expected call of CreateRouteTableRequest.
-func (mr *MockEC2APIMockRecorder) CreateRouteTableRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).CreateRouteTableRequest), arg0)
-}
-
-// CreateRouteTableWithContext mocks base method.
-func (m *MockEC2API) CreateRouteTableWithContext(arg0 context.Context, arg1 *ec2.CreateRouteTableInput, arg2 ...request.Option) (*ec2.CreateRouteTableOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateRouteTableWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateRouteTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateRouteTableWithContext indicates an expected call of CreateRouteTableWithContext.
-func (mr *MockEC2APIMockRecorder) CreateRouteTableWithContext(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, "CreateRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateRouteTableWithContext), varargs...)
-}
-
-// CreateRouteWithContext mocks base method.
-func (m *MockEC2API) CreateRouteWithContext(arg0 context.Context, arg1 *ec2.CreateRouteInput, arg2 ...request.Option) (*ec2.CreateRouteOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateRouteWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateRouteWithContext indicates an expected call of CreateRouteWithContext.
-func (mr *MockEC2APIMockRecorder) CreateRouteWithContext(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, "CreateRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateRouteWithContext), varargs...)
-}
-
-// CreateSecurityGroup mocks base method.
-func (m *MockEC2API) CreateSecurityGroup(arg0 *ec2.CreateSecurityGroupInput) (*ec2.CreateSecurityGroupOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateSecurityGroup", arg0)
-	ret0, _ := ret[0].(*ec2.CreateSecurityGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateSecurityGroup indicates an expected call of CreateSecurityGroup.
-func (mr *MockEC2APIMockRecorder) CreateSecurityGroup(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecurityGroup", reflect.TypeOf((*MockEC2API)(nil).CreateSecurityGroup), arg0)
-}
-
-// CreateSecurityGroupRequest mocks base method.
-func (m *MockEC2API) CreateSecurityGroupRequest(arg0 *ec2.CreateSecurityGroupInput) (*request.Request, *ec2.CreateSecurityGroupOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateSecurityGroupRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateSecurityGroupOutput)
-	return ret0, ret1
-}
-
-// CreateSecurityGroupRequest indicates an expected call of CreateSecurityGroupRequest.
-func (mr *MockEC2APIMockRecorder) CreateSecurityGroupRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecurityGroupRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSecurityGroupRequest), arg0)
-}
-
-// CreateSecurityGroupWithContext mocks base method.
-func (m *MockEC2API) CreateSecurityGroupWithContext(arg0 context.Context, arg1 *ec2.CreateSecurityGroupInput, arg2 ...request.Option) (*ec2.CreateSecurityGroupOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateSecurityGroupWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateSecurityGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateSecurityGroupWithContext indicates an expected call of CreateSecurityGroupWithContext.
-func (mr *MockEC2APIMockRecorder) CreateSecurityGroupWithContext(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, "CreateSecurityGroupWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateSecurityGroupWithContext), varargs...)
-}
-
-// CreateSnapshot mocks base method.
-func (m *MockEC2API) CreateSnapshot(arg0 *ec2.CreateSnapshotInput) (*ec2.Snapshot, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateSnapshot", arg0)
-	ret0, _ := ret[0].(*ec2.Snapshot)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateSnapshot indicates an expected call of CreateSnapshot.
-func (mr *MockEC2APIMockRecorder) CreateSnapshot(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshot", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshot), arg0)
-}
-
-// CreateSnapshotRequest mocks base method.
-func (m *MockEC2API) CreateSnapshotRequest(arg0 *ec2.CreateSnapshotInput) (*request.Request, *ec2.Snapshot) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateSnapshotRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.Snapshot)
-	return ret0, ret1
-}
-
-// CreateSnapshotRequest indicates an expected call of CreateSnapshotRequest.
-func (mr *MockEC2APIMockRecorder) CreateSnapshotRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshotRequest), arg0)
-}
-
-// CreateSnapshotWithContext mocks base method.
-func (m *MockEC2API) CreateSnapshotWithContext(arg0 context.Context, arg1 *ec2.CreateSnapshotInput, arg2 ...request.Option) (*ec2.Snapshot, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateSnapshotWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.Snapshot)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateSnapshotWithContext indicates an expected call of CreateSnapshotWithContext.
-func (mr *MockEC2APIMockRecorder) CreateSnapshotWithContext(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, "CreateSnapshotWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshotWithContext), varargs...)
-}
-
-// CreateSnapshots mocks base method.
-func (m *MockEC2API) CreateSnapshots(arg0 *ec2.CreateSnapshotsInput) (*ec2.CreateSnapshotsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateSnapshots", arg0)
-	ret0, _ := ret[0].(*ec2.CreateSnapshotsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateSnapshots indicates an expected call of CreateSnapshots.
-func (mr *MockEC2APIMockRecorder) CreateSnapshots(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshots", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshots), arg0)
-}
-
-// CreateSnapshotsRequest mocks base method.
-func (m *MockEC2API) CreateSnapshotsRequest(arg0 *ec2.CreateSnapshotsInput) (*request.Request, *ec2.CreateSnapshotsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateSnapshotsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateSnapshotsOutput)
-	return ret0, ret1
-}
-
-// CreateSnapshotsRequest indicates an expected call of CreateSnapshotsRequest.
-func (mr *MockEC2APIMockRecorder) CreateSnapshotsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshotsRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshotsRequest), arg0)
-}
-
-// CreateSnapshotsWithContext mocks base method.
-func (m *MockEC2API) CreateSnapshotsWithContext(arg0 context.Context, arg1 *ec2.CreateSnapshotsInput, arg2 ...request.Option) (*ec2.CreateSnapshotsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateSnapshotsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateSnapshotsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateSnapshotsWithContext indicates an expected call of CreateSnapshotsWithContext.
-func (mr *MockEC2APIMockRecorder) CreateSnapshotsWithContext(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, "CreateSnapshotsWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshotsWithContext), varargs...)
-}
-
-// CreateSpotDatafeedSubscription mocks base method.
-func (m *MockEC2API) CreateSpotDatafeedSubscription(arg0 *ec2.CreateSpotDatafeedSubscriptionInput) (*ec2.CreateSpotDatafeedSubscriptionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateSpotDatafeedSubscription", arg0)
-	ret0, _ := ret[0].(*ec2.CreateSpotDatafeedSubscriptionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateSpotDatafeedSubscription indicates an expected call of CreateSpotDatafeedSubscription.
-func (mr *MockEC2APIMockRecorder) CreateSpotDatafeedSubscription(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSpotDatafeedSubscription", reflect.TypeOf((*MockEC2API)(nil).CreateSpotDatafeedSubscription), arg0)
-}
-
-// CreateSpotDatafeedSubscriptionRequest mocks base method.
-func (m *MockEC2API) CreateSpotDatafeedSubscriptionRequest(arg0 *ec2.CreateSpotDatafeedSubscriptionInput) (*request.Request, *ec2.CreateSpotDatafeedSubscriptionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateSpotDatafeedSubscriptionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateSpotDatafeedSubscriptionOutput)
-	return ret0, ret1
-}
-
-// CreateSpotDatafeedSubscriptionRequest indicates an expected call of CreateSpotDatafeedSubscriptionRequest.
-func (mr *MockEC2APIMockRecorder) CreateSpotDatafeedSubscriptionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSpotDatafeedSubscriptionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSpotDatafeedSubscriptionRequest), arg0)
-}
-
-// CreateSpotDatafeedSubscriptionWithContext mocks base method.
-func (m *MockEC2API) CreateSpotDatafeedSubscriptionWithContext(arg0 context.Context, arg1 *ec2.CreateSpotDatafeedSubscriptionInput, arg2 ...request.Option) (*ec2.CreateSpotDatafeedSubscriptionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateSpotDatafeedSubscriptionWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateSpotDatafeedSubscriptionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateSpotDatafeedSubscriptionWithContext indicates an expected call of CreateSpotDatafeedSubscriptionWithContext.
-func (mr *MockEC2APIMockRecorder) CreateSpotDatafeedSubscriptionWithContext(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, "CreateSpotDatafeedSubscriptionWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateSpotDatafeedSubscriptionWithContext), varargs...)
-}
-
-// CreateStoreImageTask mocks base method.
-func (m *MockEC2API) CreateStoreImageTask(arg0 *ec2.CreateStoreImageTaskInput) (*ec2.CreateStoreImageTaskOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateStoreImageTask", arg0)
-	ret0, _ := ret[0].(*ec2.CreateStoreImageTaskOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateStoreImageTask indicates an expected call of CreateStoreImageTask.
-func (mr *MockEC2APIMockRecorder) CreateStoreImageTask(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStoreImageTask", reflect.TypeOf((*MockEC2API)(nil).CreateStoreImageTask), arg0)
-}
-
-// CreateStoreImageTaskRequest mocks base method.
-func (m *MockEC2API) CreateStoreImageTaskRequest(arg0 *ec2.CreateStoreImageTaskInput) (*request.Request, *ec2.CreateStoreImageTaskOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateStoreImageTaskRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateStoreImageTaskOutput)
-	return ret0, ret1
-}
-
-// CreateStoreImageTaskRequest indicates an expected call of CreateStoreImageTaskRequest.
-func (mr *MockEC2APIMockRecorder) CreateStoreImageTaskRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStoreImageTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CreateStoreImageTaskRequest), arg0)
-}
-
-// CreateStoreImageTaskWithContext mocks base method.
-func (m *MockEC2API) CreateStoreImageTaskWithContext(arg0 context.Context, arg1 *ec2.CreateStoreImageTaskInput, arg2 ...request.Option) (*ec2.CreateStoreImageTaskOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateStoreImageTaskWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateStoreImageTaskOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateStoreImageTaskWithContext indicates an expected call of CreateStoreImageTaskWithContext.
-func (mr *MockEC2APIMockRecorder) CreateStoreImageTaskWithContext(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, "CreateStoreImageTaskWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateStoreImageTaskWithContext), varargs...)
-}
-
-// CreateSubnet mocks base method.
-func (m *MockEC2API) CreateSubnet(arg0 *ec2.CreateSubnetInput) (*ec2.CreateSubnetOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateSubnet", arg0)
-	ret0, _ := ret[0].(*ec2.CreateSubnetOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateSubnet indicates an expected call of CreateSubnet.
-func (mr *MockEC2APIMockRecorder) CreateSubnet(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubnet", reflect.TypeOf((*MockEC2API)(nil).CreateSubnet), arg0)
-}
-
-// CreateSubnetCidrReservation mocks base method.
-func (m *MockEC2API) CreateSubnetCidrReservation(arg0 *ec2.CreateSubnetCidrReservationInput) (*ec2.CreateSubnetCidrReservationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateSubnetCidrReservation", arg0)
-	ret0, _ := ret[0].(*ec2.CreateSubnetCidrReservationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateSubnetCidrReservation indicates an expected call of CreateSubnetCidrReservation.
-func (mr *MockEC2APIMockRecorder) CreateSubnetCidrReservation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubnetCidrReservation", reflect.TypeOf((*MockEC2API)(nil).CreateSubnetCidrReservation), arg0)
-}
-
-// CreateSubnetCidrReservationRequest mocks base method.
-func (m *MockEC2API) CreateSubnetCidrReservationRequest(arg0 *ec2.CreateSubnetCidrReservationInput) (*request.Request, *ec2.CreateSubnetCidrReservationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateSubnetCidrReservationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateSubnetCidrReservationOutput)
-	return ret0, ret1
-}
-
-// CreateSubnetCidrReservationRequest indicates an expected call of CreateSubnetCidrReservationRequest.
-func (mr *MockEC2APIMockRecorder) CreateSubnetCidrReservationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubnetCidrReservationRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSubnetCidrReservationRequest), arg0)
-}
-
-// CreateSubnetCidrReservationWithContext mocks base method.
-func (m *MockEC2API) CreateSubnetCidrReservationWithContext(arg0 context.Context, arg1 *ec2.CreateSubnetCidrReservationInput, arg2 ...request.Option) (*ec2.CreateSubnetCidrReservationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateSubnetCidrReservationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateSubnetCidrReservationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateSubnetCidrReservationWithContext indicates an expected call of CreateSubnetCidrReservationWithContext.
-func (mr *MockEC2APIMockRecorder) CreateSubnetCidrReservationWithContext(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, "CreateSubnetCidrReservationWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateSubnetCidrReservationWithContext), varargs...)
-}
-
-// CreateSubnetRequest mocks base method.
-func (m *MockEC2API) CreateSubnetRequest(arg0 *ec2.CreateSubnetInput) (*request.Request, *ec2.CreateSubnetOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateSubnetRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateSubnetOutput)
-	return ret0, ret1
-}
-
-// CreateSubnetRequest indicates an expected call of CreateSubnetRequest.
-func (mr *MockEC2APIMockRecorder) CreateSubnetRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubnetRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSubnetRequest), arg0)
-}
-
-// CreateSubnetWithContext mocks base method.
-func (m *MockEC2API) CreateSubnetWithContext(arg0 context.Context, arg1 *ec2.CreateSubnetInput, arg2 ...request.Option) (*ec2.CreateSubnetOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateSubnetWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateSubnetOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateSubnetWithContext indicates an expected call of CreateSubnetWithContext.
-func (mr *MockEC2APIMockRecorder) CreateSubnetWithContext(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, "CreateSubnetWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateSubnetWithContext), varargs...)
-}
-
-// CreateTags mocks base method.
-func (m *MockEC2API) CreateTags(arg0 *ec2.CreateTagsInput) (*ec2.CreateTagsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTags", arg0)
-	ret0, _ := ret[0].(*ec2.CreateTagsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTags indicates an expected call of CreateTags.
-func (mr *MockEC2APIMockRecorder) CreateTags(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTags", reflect.TypeOf((*MockEC2API)(nil).CreateTags), arg0)
-}
-
-// CreateTagsRequest mocks base method.
-func (m *MockEC2API) CreateTagsRequest(arg0 *ec2.CreateTagsInput) (*request.Request, *ec2.CreateTagsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTagsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateTagsOutput)
-	return ret0, ret1
-}
-
-// CreateTagsRequest indicates an expected call of CreateTagsRequest.
-func (mr *MockEC2APIMockRecorder) CreateTagsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTagsRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTagsRequest), arg0)
-}
-
-// CreateTagsWithContext mocks base method.
-func (m *MockEC2API) CreateTagsWithContext(arg0 context.Context, arg1 *ec2.CreateTagsInput, arg2 ...request.Option) (*ec2.CreateTagsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateTagsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateTagsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTagsWithContext indicates an expected call of CreateTagsWithContext.
-func (mr *MockEC2APIMockRecorder) CreateTagsWithContext(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, "CreateTagsWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTagsWithContext), varargs...)
-}
-
-// CreateTrafficMirrorFilter mocks base method.
-func (m *MockEC2API) CreateTrafficMirrorFilter(arg0 *ec2.CreateTrafficMirrorFilterInput) (*ec2.CreateTrafficMirrorFilterOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTrafficMirrorFilter", arg0)
-	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTrafficMirrorFilter indicates an expected call of CreateTrafficMirrorFilter.
-func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilter(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilter", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilter), arg0)
-}
-
-// CreateTrafficMirrorFilterRequest mocks base method.
-func (m *MockEC2API) CreateTrafficMirrorFilterRequest(arg0 *ec2.CreateTrafficMirrorFilterInput) (*request.Request, *ec2.CreateTrafficMirrorFilterOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateTrafficMirrorFilterOutput)
-	return ret0, ret1
-}
-
-// CreateTrafficMirrorFilterRequest indicates an expected call of CreateTrafficMirrorFilterRequest.
-func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilterRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterRequest), arg0)
-}
-
-// CreateTrafficMirrorFilterRule mocks base method.
-func (m *MockEC2API) CreateTrafficMirrorFilterRule(arg0 *ec2.CreateTrafficMirrorFilterRuleInput) (*ec2.CreateTrafficMirrorFilterRuleOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRule", arg0)
-	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterRuleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTrafficMirrorFilterRule indicates an expected call of CreateTrafficMirrorFilterRule.
-func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilterRule(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRule", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterRule), arg0)
-}
-
-// CreateTrafficMirrorFilterRuleRequest mocks base method.
-func (m *MockEC2API) CreateTrafficMirrorFilterRuleRequest(arg0 *ec2.CreateTrafficMirrorFilterRuleInput) (*request.Request, *ec2.CreateTrafficMirrorFilterRuleOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRuleRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateTrafficMirrorFilterRuleOutput)
-	return ret0, ret1
-}
-
-// CreateTrafficMirrorFilterRuleRequest indicates an expected call of CreateTrafficMirrorFilterRuleRequest.
-func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilterRuleRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRuleRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterRuleRequest), arg0)
-}
-
-// CreateTrafficMirrorFilterRuleWithContext mocks base method.
-func (m *MockEC2API) CreateTrafficMirrorFilterRuleWithContext(arg0 context.Context, arg1 *ec2.CreateTrafficMirrorFilterRuleInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorFilterRuleOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRuleWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterRuleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTrafficMirrorFilterRuleWithContext indicates an expected call of CreateTrafficMirrorFilterRuleWithContext.
-func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilterRuleWithContext(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, "CreateTrafficMirrorFilterRuleWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterRuleWithContext), varargs...)
-}
-
-// CreateTrafficMirrorFilterWithContext mocks base method.
-func (m *MockEC2API) CreateTrafficMirrorFilterWithContext(arg0 context.Context, arg1 *ec2.CreateTrafficMirrorFilterInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorFilterOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTrafficMirrorFilterWithContext indicates an expected call of CreateTrafficMirrorFilterWithContext.
-func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilterWithContext(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, "CreateTrafficMirrorFilterWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterWithContext), varargs...)
-}
-
-// CreateTrafficMirrorSession mocks base method.
-func (m *MockEC2API) CreateTrafficMirrorSession(arg0 *ec2.CreateTrafficMirrorSessionInput) (*ec2.CreateTrafficMirrorSessionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTrafficMirrorSession", arg0)
-	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorSessionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTrafficMirrorSession indicates an expected call of CreateTrafficMirrorSession.
-func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorSession(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorSession", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorSession), arg0)
-}
-
-// CreateTrafficMirrorSessionRequest mocks base method.
-func (m *MockEC2API) CreateTrafficMirrorSessionRequest(arg0 *ec2.CreateTrafficMirrorSessionInput) (*request.Request, *ec2.CreateTrafficMirrorSessionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTrafficMirrorSessionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateTrafficMirrorSessionOutput)
-	return ret0, ret1
-}
-
-// CreateTrafficMirrorSessionRequest indicates an expected call of CreateTrafficMirrorSessionRequest.
-func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorSessionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorSessionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorSessionRequest), arg0)
-}
-
-// CreateTrafficMirrorSessionWithContext mocks base method.
-func (m *MockEC2API) CreateTrafficMirrorSessionWithContext(arg0 context.Context, arg1 *ec2.CreateTrafficMirrorSessionInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorSessionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateTrafficMirrorSessionWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorSessionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTrafficMirrorSessionWithContext indicates an expected call of CreateTrafficMirrorSessionWithContext.
-func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorSessionWithContext(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, "CreateTrafficMirrorSessionWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorSessionWithContext), varargs...)
-}
-
-// CreateTrafficMirrorTarget mocks base method.
-func (m *MockEC2API) CreateTrafficMirrorTarget(arg0 *ec2.CreateTrafficMirrorTargetInput) (*ec2.CreateTrafficMirrorTargetOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTrafficMirrorTarget", arg0)
-	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorTargetOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTrafficMirrorTarget indicates an expected call of CreateTrafficMirrorTarget.
-func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorTarget(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorTarget", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorTarget), arg0)
-}
-
-// CreateTrafficMirrorTargetRequest mocks base method.
-func (m *MockEC2API) CreateTrafficMirrorTargetRequest(arg0 *ec2.CreateTrafficMirrorTargetInput) (*request.Request, *ec2.CreateTrafficMirrorTargetOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTrafficMirrorTargetRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateTrafficMirrorTargetOutput)
-	return ret0, ret1
-}
-
-// CreateTrafficMirrorTargetRequest indicates an expected call of CreateTrafficMirrorTargetRequest.
-func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorTargetRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorTargetRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorTargetRequest), arg0)
-}
-
-// CreateTrafficMirrorTargetWithContext mocks base method.
-func (m *MockEC2API) CreateTrafficMirrorTargetWithContext(arg0 context.Context, arg1 *ec2.CreateTrafficMirrorTargetInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorTargetOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateTrafficMirrorTargetWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorTargetOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTrafficMirrorTargetWithContext indicates an expected call of CreateTrafficMirrorTargetWithContext.
-func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorTargetWithContext(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, "CreateTrafficMirrorTargetWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorTargetWithContext), varargs...)
-}
-
-// CreateTransitGateway mocks base method.
-func (m *MockEC2API) CreateTransitGateway(arg0 *ec2.CreateTransitGatewayInput) (*ec2.CreateTransitGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTransitGateway", arg0)
-	ret0, _ := ret[0].(*ec2.CreateTransitGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTransitGateway indicates an expected call of CreateTransitGateway.
-func (mr *MockEC2APIMockRecorder) CreateTransitGateway(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGateway", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGateway), arg0)
-}
-
-// CreateTransitGatewayConnect mocks base method.
-func (m *MockEC2API) CreateTransitGatewayConnect(arg0 *ec2.CreateTransitGatewayConnectInput) (*ec2.CreateTransitGatewayConnectOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTransitGatewayConnect", arg0)
-	ret0, _ := ret[0].(*ec2.CreateTransitGatewayConnectOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayConnect indicates an expected call of CreateTransitGatewayConnect.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayConnect(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayConnect", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayConnect), arg0)
-}
-
-// CreateTransitGatewayConnectPeer mocks base method.
-func (m *MockEC2API) CreateTransitGatewayConnectPeer(arg0 *ec2.CreateTransitGatewayConnectPeerInput) (*ec2.CreateTransitGatewayConnectPeerOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTransitGatewayConnectPeer", arg0)
-	ret0, _ := ret[0].(*ec2.CreateTransitGatewayConnectPeerOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayConnectPeer indicates an expected call of CreateTransitGatewayConnectPeer.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayConnectPeer(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayConnectPeer", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayConnectPeer), arg0)
-}
-
-// CreateTransitGatewayConnectPeerRequest mocks base method.
-func (m *MockEC2API) CreateTransitGatewayConnectPeerRequest(arg0 *ec2.CreateTransitGatewayConnectPeerInput) (*request.Request, *ec2.CreateTransitGatewayConnectPeerOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTransitGatewayConnectPeerRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateTransitGatewayConnectPeerOutput)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayConnectPeerRequest indicates an expected call of CreateTransitGatewayConnectPeerRequest.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayConnectPeerRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayConnectPeerRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayConnectPeerRequest), arg0)
-}
-
-// CreateTransitGatewayConnectPeerWithContext mocks base method.
-func (m *MockEC2API) CreateTransitGatewayConnectPeerWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayConnectPeerInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayConnectPeerOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateTransitGatewayConnectPeerWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateTransitGatewayConnectPeerOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayConnectPeerWithContext indicates an expected call of CreateTransitGatewayConnectPeerWithContext.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayConnectPeerWithContext(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, "CreateTransitGatewayConnectPeerWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayConnectPeerWithContext), varargs...)
-}
-
-// CreateTransitGatewayConnectRequest mocks base method.
-func (m *MockEC2API) CreateTransitGatewayConnectRequest(arg0 *ec2.CreateTransitGatewayConnectInput) (*request.Request, *ec2.CreateTransitGatewayConnectOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTransitGatewayConnectRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateTransitGatewayConnectOutput)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayConnectRequest indicates an expected call of CreateTransitGatewayConnectRequest.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayConnectRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayConnectRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayConnectRequest), arg0)
-}
-
-// CreateTransitGatewayConnectWithContext mocks base method.
-func (m *MockEC2API) CreateTransitGatewayConnectWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayConnectInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayConnectOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateTransitGatewayConnectWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateTransitGatewayConnectOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayConnectWithContext indicates an expected call of CreateTransitGatewayConnectWithContext.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayConnectWithContext(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, "CreateTransitGatewayConnectWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayConnectWithContext), varargs...)
-}
-
-// CreateTransitGatewayMulticastDomain mocks base method.
-func (m *MockEC2API) CreateTransitGatewayMulticastDomain(arg0 *ec2.CreateTransitGatewayMulticastDomainInput) (*ec2.CreateTransitGatewayMulticastDomainOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTransitGatewayMulticastDomain", arg0)
-	ret0, _ := ret[0].(*ec2.CreateTransitGatewayMulticastDomainOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayMulticastDomain indicates an expected call of CreateTransitGatewayMulticastDomain.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayMulticastDomain(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayMulticastDomain", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayMulticastDomain), arg0)
-}
-
-// CreateTransitGatewayMulticastDomainRequest mocks base method.
-func (m *MockEC2API) CreateTransitGatewayMulticastDomainRequest(arg0 *ec2.CreateTransitGatewayMulticastDomainInput) (*request.Request, *ec2.CreateTransitGatewayMulticastDomainOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTransitGatewayMulticastDomainRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateTransitGatewayMulticastDomainOutput)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayMulticastDomainRequest indicates an expected call of CreateTransitGatewayMulticastDomainRequest.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayMulticastDomainRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayMulticastDomainRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayMulticastDomainRequest), arg0)
-}
-
-// CreateTransitGatewayMulticastDomainWithContext mocks base method.
-func (m *MockEC2API) CreateTransitGatewayMulticastDomainWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayMulticastDomainInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayMulticastDomainOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateTransitGatewayMulticastDomainWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateTransitGatewayMulticastDomainOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayMulticastDomainWithContext indicates an expected call of CreateTransitGatewayMulticastDomainWithContext.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayMulticastDomainWithContext(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, "CreateTransitGatewayMulticastDomainWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayMulticastDomainWithContext), varargs...)
-}
-
-// CreateTransitGatewayPeeringAttachment mocks base method.
-func (m *MockEC2API) CreateTransitGatewayPeeringAttachment(arg0 *ec2.CreateTransitGatewayPeeringAttachmentInput) (*ec2.CreateTransitGatewayPeeringAttachmentOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTransitGatewayPeeringAttachment", arg0)
-	ret0, _ := ret[0].(*ec2.CreateTransitGatewayPeeringAttachmentOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayPeeringAttachment indicates an expected call of CreateTransitGatewayPeeringAttachment.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPeeringAttachment(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPeeringAttachment", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPeeringAttachment), arg0)
-}
-
-// CreateTransitGatewayPeeringAttachmentRequest mocks base method.
-func (m *MockEC2API) CreateTransitGatewayPeeringAttachmentRequest(arg0 *ec2.CreateTransitGatewayPeeringAttachmentInput) (*request.Request, *ec2.CreateTransitGatewayPeeringAttachmentOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTransitGatewayPeeringAttachmentRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateTransitGatewayPeeringAttachmentOutput)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayPeeringAttachmentRequest indicates an expected call of CreateTransitGatewayPeeringAttachmentRequest.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPeeringAttachmentRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPeeringAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPeeringAttachmentRequest), arg0)
-}
-
-// CreateTransitGatewayPeeringAttachmentWithContext mocks base method.
-func (m *MockEC2API) CreateTransitGatewayPeeringAttachmentWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayPeeringAttachmentInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayPeeringAttachmentOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateTransitGatewayPeeringAttachmentWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateTransitGatewayPeeringAttachmentOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayPeeringAttachmentWithContext indicates an expected call of CreateTransitGatewayPeeringAttachmentWithContext.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPeeringAttachmentWithContext(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, "CreateTransitGatewayPeeringAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPeeringAttachmentWithContext), varargs...)
-}
-
-// CreateTransitGatewayPolicyTable mocks base method.
-func (m *MockEC2API) CreateTransitGatewayPolicyTable(arg0 *ec2.CreateTransitGatewayPolicyTableInput) (*ec2.CreateTransitGatewayPolicyTableOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTransitGatewayPolicyTable", arg0)
-	ret0, _ := ret[0].(*ec2.CreateTransitGatewayPolicyTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayPolicyTable indicates an expected call of CreateTransitGatewayPolicyTable.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPolicyTable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPolicyTable", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPolicyTable), arg0)
-}
-
-// CreateTransitGatewayPolicyTableRequest mocks base method.
-func (m *MockEC2API) CreateTransitGatewayPolicyTableRequest(arg0 *ec2.CreateTransitGatewayPolicyTableInput) (*request.Request, *ec2.CreateTransitGatewayPolicyTableOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTransitGatewayPolicyTableRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateTransitGatewayPolicyTableOutput)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayPolicyTableRequest indicates an expected call of CreateTransitGatewayPolicyTableRequest.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPolicyTableRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPolicyTableRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPolicyTableRequest), arg0)
-}
-
-// CreateTransitGatewayPolicyTableWithContext mocks base method.
-func (m *MockEC2API) CreateTransitGatewayPolicyTableWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayPolicyTableInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayPolicyTableOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateTransitGatewayPolicyTableWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateTransitGatewayPolicyTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayPolicyTableWithContext indicates an expected call of CreateTransitGatewayPolicyTableWithContext.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPolicyTableWithContext(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, "CreateTransitGatewayPolicyTableWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPolicyTableWithContext), varargs...)
-}
-
-// CreateTransitGatewayPrefixListReference mocks base method.
-func (m *MockEC2API) CreateTransitGatewayPrefixListReference(arg0 *ec2.CreateTransitGatewayPrefixListReferenceInput) (*ec2.CreateTransitGatewayPrefixListReferenceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTransitGatewayPrefixListReference", arg0)
-	ret0, _ := ret[0].(*ec2.CreateTransitGatewayPrefixListReferenceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayPrefixListReference indicates an expected call of CreateTransitGatewayPrefixListReference.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPrefixListReference(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPrefixListReference", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPrefixListReference), arg0)
-}
-
-// CreateTransitGatewayPrefixListReferenceRequest mocks base method.
-func (m *MockEC2API) CreateTransitGatewayPrefixListReferenceRequest(arg0 *ec2.CreateTransitGatewayPrefixListReferenceInput) (*request.Request, *ec2.CreateTransitGatewayPrefixListReferenceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTransitGatewayPrefixListReferenceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateTransitGatewayPrefixListReferenceOutput)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayPrefixListReferenceRequest indicates an expected call of CreateTransitGatewayPrefixListReferenceRequest.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPrefixListReferenceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPrefixListReferenceRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPrefixListReferenceRequest), arg0)
-}
-
-// CreateTransitGatewayPrefixListReferenceWithContext mocks base method.
-func (m *MockEC2API) CreateTransitGatewayPrefixListReferenceWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayPrefixListReferenceInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayPrefixListReferenceOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateTransitGatewayPrefixListReferenceWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateTransitGatewayPrefixListReferenceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayPrefixListReferenceWithContext indicates an expected call of CreateTransitGatewayPrefixListReferenceWithContext.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPrefixListReferenceWithContext(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, "CreateTransitGatewayPrefixListReferenceWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPrefixListReferenceWithContext), varargs...)
-}
-
-// CreateTransitGatewayRequest mocks base method.
-func (m *MockEC2API) CreateTransitGatewayRequest(arg0 *ec2.CreateTransitGatewayInput) (*request.Request, *ec2.CreateTransitGatewayOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTransitGatewayRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateTransitGatewayOutput)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayRequest indicates an expected call of CreateTransitGatewayRequest.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRequest), arg0)
-}
-
-// CreateTransitGatewayRoute mocks base method.
-func (m *MockEC2API) CreateTransitGatewayRoute(arg0 *ec2.CreateTransitGatewayRouteInput) (*ec2.CreateTransitGatewayRouteOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTransitGatewayRoute", arg0)
-	ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayRoute indicates an expected call of CreateTransitGatewayRoute.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRoute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRoute), arg0)
-}
-
-// CreateTransitGatewayRouteRequest mocks base method.
-func (m *MockEC2API) CreateTransitGatewayRouteRequest(arg0 *ec2.CreateTransitGatewayRouteInput) (*request.Request, *ec2.CreateTransitGatewayRouteOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTransitGatewayRouteRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateTransitGatewayRouteOutput)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayRouteRequest indicates an expected call of CreateTransitGatewayRouteRequest.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteRequest), arg0)
-}
-
-// CreateTransitGatewayRouteTable mocks base method.
-func (m *MockEC2API) CreateTransitGatewayRouteTable(arg0 *ec2.CreateTransitGatewayRouteTableInput) (*ec2.CreateTransitGatewayRouteTableOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTable", arg0)
-	ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayRouteTable indicates an expected call of CreateTransitGatewayRouteTable.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteTable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteTable), arg0)
-}
-
-// CreateTransitGatewayRouteTableAnnouncement mocks base method.
-func (m *MockEC2API) CreateTransitGatewayRouteTableAnnouncement(arg0 *ec2.CreateTransitGatewayRouteTableAnnouncementInput) (*ec2.CreateTransitGatewayRouteTableAnnouncementOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTableAnnouncement", arg0)
-	ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteTableAnnouncementOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayRouteTableAnnouncement indicates an expected call of CreateTransitGatewayRouteTableAnnouncement.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteTableAnnouncement(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteTableAnnouncement", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteTableAnnouncement), arg0)
-}
-
-// CreateTransitGatewayRouteTableAnnouncementRequest mocks base method.
-func (m *MockEC2API) CreateTransitGatewayRouteTableAnnouncementRequest(arg0 *ec2.CreateTransitGatewayRouteTableAnnouncementInput) (*request.Request, *ec2.CreateTransitGatewayRouteTableAnnouncementOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTableAnnouncementRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateTransitGatewayRouteTableAnnouncementOutput)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayRouteTableAnnouncementRequest indicates an expected call of CreateTransitGatewayRouteTableAnnouncementRequest.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteTableAnnouncementRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteTableAnnouncementRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteTableAnnouncementRequest), arg0)
-}
-
-// CreateTransitGatewayRouteTableAnnouncementWithContext mocks base method.
-func (m *MockEC2API) CreateTransitGatewayRouteTableAnnouncementWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayRouteTableAnnouncementInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayRouteTableAnnouncementOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTableAnnouncementWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteTableAnnouncementOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayRouteTableAnnouncementWithContext indicates an expected call of CreateTransitGatewayRouteTableAnnouncementWithContext.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteTableAnnouncementWithContext(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, "CreateTransitGatewayRouteTableAnnouncementWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteTableAnnouncementWithContext), varargs...)
-}
-
-// CreateTransitGatewayRouteTableRequest mocks base method.
-func (m *MockEC2API) CreateTransitGatewayRouteTableRequest(arg0 *ec2.CreateTransitGatewayRouteTableInput) (*request.Request, *ec2.CreateTransitGatewayRouteTableOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTableRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateTransitGatewayRouteTableOutput)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayRouteTableRequest indicates an expected call of CreateTransitGatewayRouteTableRequest.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteTableRequest), arg0)
-}
-
-// CreateTransitGatewayRouteTableWithContext mocks base method.
-func (m *MockEC2API) CreateTransitGatewayRouteTableWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayRouteTableInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayRouteTableOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTableWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayRouteTableWithContext indicates an expected call of CreateTransitGatewayRouteTableWithContext.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteTableWithContext(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, "CreateTransitGatewayRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteTableWithContext), varargs...)
-}
-
-// CreateTransitGatewayRouteWithContext mocks base method.
-func (m *MockEC2API) CreateTransitGatewayRouteWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayRouteInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayRouteOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateTransitGatewayRouteWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayRouteWithContext indicates an expected call of CreateTransitGatewayRouteWithContext.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteWithContext(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, "CreateTransitGatewayRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteWithContext), varargs...)
-}
-
-// CreateTransitGatewayVpcAttachment mocks base method.
-func (m *MockEC2API) CreateTransitGatewayVpcAttachment(arg0 *ec2.CreateTransitGatewayVpcAttachmentInput) (*ec2.CreateTransitGatewayVpcAttachmentOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTransitGatewayVpcAttachment", arg0)
-	ret0, _ := ret[0].(*ec2.CreateTransitGatewayVpcAttachmentOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayVpcAttachment indicates an expected call of CreateTransitGatewayVpcAttachment.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayVpcAttachment), arg0)
-}
-
-// CreateTransitGatewayVpcAttachmentRequest mocks base method.
-func (m *MockEC2API) CreateTransitGatewayVpcAttachmentRequest(arg0 *ec2.CreateTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.CreateTransitGatewayVpcAttachmentOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateTransitGatewayVpcAttachmentRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateTransitGatewayVpcAttachmentOutput)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayVpcAttachmentRequest indicates an expected call of CreateTransitGatewayVpcAttachmentRequest.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayVpcAttachmentRequest), arg0)
-}
-
-// CreateTransitGatewayVpcAttachmentWithContext mocks base method.
-func (m *MockEC2API) CreateTransitGatewayVpcAttachmentWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayVpcAttachmentOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateTransitGatewayVpcAttachmentWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateTransitGatewayVpcAttachmentOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayVpcAttachmentWithContext indicates an expected call of CreateTransitGatewayVpcAttachmentWithContext.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayVpcAttachmentWithContext(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, "CreateTransitGatewayVpcAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayVpcAttachmentWithContext), varargs...)
-}
-
-// CreateTransitGatewayWithContext mocks base method.
-func (m *MockEC2API) CreateTransitGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateTransitGatewayWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateTransitGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateTransitGatewayWithContext indicates an expected call of CreateTransitGatewayWithContext.
-func (mr *MockEC2APIMockRecorder) CreateTransitGatewayWithContext(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, "CreateTransitGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayWithContext), varargs...)
-}
-
-// CreateVerifiedAccessEndpoint mocks base method.
-func (m *MockEC2API) CreateVerifiedAccessEndpoint(arg0 *ec2.CreateVerifiedAccessEndpointInput) (*ec2.CreateVerifiedAccessEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVerifiedAccessEndpoint", arg0)
-	ret0, _ := ret[0].(*ec2.CreateVerifiedAccessEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVerifiedAccessEndpoint indicates an expected call of CreateVerifiedAccessEndpoint.
-func (mr *MockEC2APIMockRecorder) CreateVerifiedAccessEndpoint(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessEndpoint", reflect.TypeOf((*MockEC2API)(nil).CreateVerifiedAccessEndpoint), arg0)
-}
-
-// CreateVerifiedAccessEndpointRequest mocks base method.
-func (m *MockEC2API) CreateVerifiedAccessEndpointRequest(arg0 *ec2.CreateVerifiedAccessEndpointInput) (*request.Request, *ec2.CreateVerifiedAccessEndpointOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVerifiedAccessEndpointRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateVerifiedAccessEndpointOutput)
-	return ret0, ret1
-}
-
-// CreateVerifiedAccessEndpointRequest indicates an expected call of CreateVerifiedAccessEndpointRequest.
-func (mr *MockEC2APIMockRecorder) CreateVerifiedAccessEndpointRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVerifiedAccessEndpointRequest), arg0)
-}
-
-// CreateVerifiedAccessEndpointWithContext mocks base method.
-func (m *MockEC2API) CreateVerifiedAccessEndpointWithContext(arg0 context.Context, arg1 *ec2.CreateVerifiedAccessEndpointInput, arg2 ...request.Option) (*ec2.CreateVerifiedAccessEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateVerifiedAccessEndpointWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateVerifiedAccessEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVerifiedAccessEndpointWithContext indicates an expected call of CreateVerifiedAccessEndpointWithContext.
-func (mr *MockEC2APIMockRecorder) CreateVerifiedAccessEndpointWithContext(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, "CreateVerifiedAccessEndpointWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVerifiedAccessEndpointWithContext), varargs...)
-}
-
-// CreateVerifiedAccessGroup mocks base method.
-func (m *MockEC2API) CreateVerifiedAccessGroup(arg0 *ec2.CreateVerifiedAccessGroupInput) (*ec2.CreateVerifiedAccessGroupOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVerifiedAccessGroup", arg0)
-	ret0, _ := ret[0].(*ec2.CreateVerifiedAccessGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVerifiedAccessGroup indicates an expected call of CreateVerifiedAccessGroup.
-func (mr *MockEC2APIMockRecorder) CreateVerifiedAccessGroup(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessGroup", reflect.TypeOf((*MockEC2API)(nil).CreateVerifiedAccessGroup), arg0)
-}
-
-// CreateVerifiedAccessGroupRequest mocks base method.
-func (m *MockEC2API) CreateVerifiedAccessGroupRequest(arg0 *ec2.CreateVerifiedAccessGroupInput) (*request.Request, *ec2.CreateVerifiedAccessGroupOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVerifiedAccessGroupRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateVerifiedAccessGroupOutput)
-	return ret0, ret1
-}
-
-// CreateVerifiedAccessGroupRequest indicates an expected call of CreateVerifiedAccessGroupRequest.
-func (mr *MockEC2APIMockRecorder) CreateVerifiedAccessGroupRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessGroupRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVerifiedAccessGroupRequest), arg0)
-}
-
-// CreateVerifiedAccessGroupWithContext mocks base method.
-func (m *MockEC2API) CreateVerifiedAccessGroupWithContext(arg0 context.Context, arg1 *ec2.CreateVerifiedAccessGroupInput, arg2 ...request.Option) (*ec2.CreateVerifiedAccessGroupOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateVerifiedAccessGroupWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateVerifiedAccessGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVerifiedAccessGroupWithContext indicates an expected call of CreateVerifiedAccessGroupWithContext.
-func (mr *MockEC2APIMockRecorder) CreateVerifiedAccessGroupWithContext(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, "CreateVerifiedAccessGroupWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVerifiedAccessGroupWithContext), varargs...)
-}
-
-// CreateVerifiedAccessInstance mocks base method.
-func (m *MockEC2API) CreateVerifiedAccessInstance(arg0 *ec2.CreateVerifiedAccessInstanceInput) (*ec2.CreateVerifiedAccessInstanceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVerifiedAccessInstance", arg0)
-	ret0, _ := ret[0].(*ec2.CreateVerifiedAccessInstanceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVerifiedAccessInstance indicates an expected call of CreateVerifiedAccessInstance.
-func (mr *MockEC2APIMockRecorder) CreateVerifiedAccessInstance(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessInstance", reflect.TypeOf((*MockEC2API)(nil).CreateVerifiedAccessInstance), arg0)
-}
-
-// CreateVerifiedAccessInstanceRequest mocks base method.
-func (m *MockEC2API) CreateVerifiedAccessInstanceRequest(arg0 *ec2.CreateVerifiedAccessInstanceInput) (*request.Request, *ec2.CreateVerifiedAccessInstanceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVerifiedAccessInstanceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateVerifiedAccessInstanceOutput)
-	return ret0, ret1
-}
-
-// CreateVerifiedAccessInstanceRequest indicates an expected call of CreateVerifiedAccessInstanceRequest.
-func (mr *MockEC2APIMockRecorder) CreateVerifiedAccessInstanceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessInstanceRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVerifiedAccessInstanceRequest), arg0)
-}
-
-// CreateVerifiedAccessInstanceWithContext mocks base method.
-func (m *MockEC2API) CreateVerifiedAccessInstanceWithContext(arg0 context.Context, arg1 *ec2.CreateVerifiedAccessInstanceInput, arg2 ...request.Option) (*ec2.CreateVerifiedAccessInstanceOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateVerifiedAccessInstanceWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateVerifiedAccessInstanceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVerifiedAccessInstanceWithContext indicates an expected call of CreateVerifiedAccessInstanceWithContext.
-func (mr *MockEC2APIMockRecorder) CreateVerifiedAccessInstanceWithContext(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, "CreateVerifiedAccessInstanceWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVerifiedAccessInstanceWithContext), varargs...)
-}
-
-// CreateVerifiedAccessTrustProvider mocks base method.
-func (m *MockEC2API) CreateVerifiedAccessTrustProvider(arg0 *ec2.CreateVerifiedAccessTrustProviderInput) (*ec2.CreateVerifiedAccessTrustProviderOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVerifiedAccessTrustProvider", arg0)
-	ret0, _ := ret[0].(*ec2.CreateVerifiedAccessTrustProviderOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVerifiedAccessTrustProvider indicates an expected call of CreateVerifiedAccessTrustProvider.
-func (mr *MockEC2APIMockRecorder) CreateVerifiedAccessTrustProvider(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessTrustProvider", reflect.TypeOf((*MockEC2API)(nil).CreateVerifiedAccessTrustProvider), arg0)
-}
-
-// CreateVerifiedAccessTrustProviderRequest mocks base method.
-func (m *MockEC2API) CreateVerifiedAccessTrustProviderRequest(arg0 *ec2.CreateVerifiedAccessTrustProviderInput) (*request.Request, *ec2.CreateVerifiedAccessTrustProviderOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVerifiedAccessTrustProviderRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateVerifiedAccessTrustProviderOutput)
-	return ret0, ret1
-}
-
-// CreateVerifiedAccessTrustProviderRequest indicates an expected call of CreateVerifiedAccessTrustProviderRequest.
-func (mr *MockEC2APIMockRecorder) CreateVerifiedAccessTrustProviderRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessTrustProviderRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVerifiedAccessTrustProviderRequest), arg0)
-}
-
-// CreateVerifiedAccessTrustProviderWithContext mocks base method.
-func (m *MockEC2API) CreateVerifiedAccessTrustProviderWithContext(arg0 context.Context, arg1 *ec2.CreateVerifiedAccessTrustProviderInput, arg2 ...request.Option) (*ec2.CreateVerifiedAccessTrustProviderOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateVerifiedAccessTrustProviderWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateVerifiedAccessTrustProviderOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVerifiedAccessTrustProviderWithContext indicates an expected call of CreateVerifiedAccessTrustProviderWithContext.
-func (mr *MockEC2APIMockRecorder) CreateVerifiedAccessTrustProviderWithContext(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, "CreateVerifiedAccessTrustProviderWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVerifiedAccessTrustProviderWithContext), varargs...)
-}
-
-// CreateVolume mocks base method.
-func (m *MockEC2API) CreateVolume(arg0 *ec2.CreateVolumeInput) (*ec2.Volume, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVolume", arg0)
-	ret0, _ := ret[0].(*ec2.Volume)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVolume indicates an expected call of CreateVolume.
-func (mr *MockEC2APIMockRecorder) CreateVolume(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolume", reflect.TypeOf((*MockEC2API)(nil).CreateVolume), arg0)
-}
-
-// CreateVolumeRequest mocks base method.
-func (m *MockEC2API) CreateVolumeRequest(arg0 *ec2.CreateVolumeInput) (*request.Request, *ec2.Volume) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVolumeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.Volume)
-	return ret0, ret1
-}
-
-// CreateVolumeRequest indicates an expected call of CreateVolumeRequest.
-func (mr *MockEC2APIMockRecorder) CreateVolumeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVolumeRequest), arg0)
-}
-
-// CreateVolumeWithContext mocks base method.
-func (m *MockEC2API) CreateVolumeWithContext(arg0 context.Context, arg1 *ec2.CreateVolumeInput, arg2 ...request.Option) (*ec2.Volume, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateVolumeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.Volume)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVolumeWithContext indicates an expected call of CreateVolumeWithContext.
-func (mr *MockEC2APIMockRecorder) CreateVolumeWithContext(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, "CreateVolumeWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVolumeWithContext), varargs...)
-}
-
-// CreateVpc mocks base method.
-func (m *MockEC2API) CreateVpc(arg0 *ec2.CreateVpcInput) (*ec2.CreateVpcOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVpc", arg0)
-	ret0, _ := ret[0].(*ec2.CreateVpcOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVpc indicates an expected call of CreateVpc.
-func (mr *MockEC2APIMockRecorder) CreateVpc(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpc", reflect.TypeOf((*MockEC2API)(nil).CreateVpc), arg0)
-}
-
-// CreateVpcEndpoint mocks base method.
-func (m *MockEC2API) CreateVpcEndpoint(arg0 *ec2.CreateVpcEndpointInput) (*ec2.CreateVpcEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVpcEndpoint", arg0)
-	ret0, _ := ret[0].(*ec2.CreateVpcEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVpcEndpoint indicates an expected call of CreateVpcEndpoint.
-func (mr *MockEC2APIMockRecorder) CreateVpcEndpoint(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpoint", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpoint), arg0)
-}
-
-// CreateVpcEndpointConnectionNotification mocks base method.
-func (m *MockEC2API) CreateVpcEndpointConnectionNotification(arg0 *ec2.CreateVpcEndpointConnectionNotificationInput) (*ec2.CreateVpcEndpointConnectionNotificationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVpcEndpointConnectionNotification", arg0)
-	ret0, _ := ret[0].(*ec2.CreateVpcEndpointConnectionNotificationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVpcEndpointConnectionNotification indicates an expected call of CreateVpcEndpointConnectionNotification.
-func (mr *MockEC2APIMockRecorder) CreateVpcEndpointConnectionNotification(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointConnectionNotification", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointConnectionNotification), arg0)
-}
-
-// CreateVpcEndpointConnectionNotificationRequest mocks base method.
-func (m *MockEC2API) CreateVpcEndpointConnectionNotificationRequest(arg0 *ec2.CreateVpcEndpointConnectionNotificationInput) (*request.Request, *ec2.CreateVpcEndpointConnectionNotificationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVpcEndpointConnectionNotificationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateVpcEndpointConnectionNotificationOutput)
-	return ret0, ret1
-}
-
-// CreateVpcEndpointConnectionNotificationRequest indicates an expected call of CreateVpcEndpointConnectionNotificationRequest.
-func (mr *MockEC2APIMockRecorder) CreateVpcEndpointConnectionNotificationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointConnectionNotificationRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointConnectionNotificationRequest), arg0)
-}
-
-// CreateVpcEndpointConnectionNotificationWithContext mocks base method.
-func (m *MockEC2API) CreateVpcEndpointConnectionNotificationWithContext(arg0 context.Context, arg1 *ec2.CreateVpcEndpointConnectionNotificationInput, arg2 ...request.Option) (*ec2.CreateVpcEndpointConnectionNotificationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateVpcEndpointConnectionNotificationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateVpcEndpointConnectionNotificationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVpcEndpointConnectionNotificationWithContext indicates an expected call of CreateVpcEndpointConnectionNotificationWithContext.
-func (mr *MockEC2APIMockRecorder) CreateVpcEndpointConnectionNotificationWithContext(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, "CreateVpcEndpointConnectionNotificationWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointConnectionNotificationWithContext), varargs...)
-}
-
-// CreateVpcEndpointRequest mocks base method.
-func (m *MockEC2API) CreateVpcEndpointRequest(arg0 *ec2.CreateVpcEndpointInput) (*request.Request, *ec2.CreateVpcEndpointOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVpcEndpointRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateVpcEndpointOutput)
-	return ret0, ret1
-}
-
-// CreateVpcEndpointRequest indicates an expected call of CreateVpcEndpointRequest.
-func (mr *MockEC2APIMockRecorder) CreateVpcEndpointRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointRequest), arg0)
-}
-
-// CreateVpcEndpointServiceConfiguration mocks base method.
-func (m *MockEC2API) CreateVpcEndpointServiceConfiguration(arg0 *ec2.CreateVpcEndpointServiceConfigurationInput) (*ec2.CreateVpcEndpointServiceConfigurationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVpcEndpointServiceConfiguration", arg0)
-	ret0, _ := ret[0].(*ec2.CreateVpcEndpointServiceConfigurationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVpcEndpointServiceConfiguration indicates an expected call of CreateVpcEndpointServiceConfiguration.
-func (mr *MockEC2APIMockRecorder) CreateVpcEndpointServiceConfiguration(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointServiceConfiguration", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointServiceConfiguration), arg0)
-}
-
-// CreateVpcEndpointServiceConfigurationRequest mocks base method.
-func (m *MockEC2API) CreateVpcEndpointServiceConfigurationRequest(arg0 *ec2.CreateVpcEndpointServiceConfigurationInput) (*request.Request, *ec2.CreateVpcEndpointServiceConfigurationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVpcEndpointServiceConfigurationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateVpcEndpointServiceConfigurationOutput)
-	return ret0, ret1
-}
-
-// CreateVpcEndpointServiceConfigurationRequest indicates an expected call of CreateVpcEndpointServiceConfigurationRequest.
-func (mr *MockEC2APIMockRecorder) CreateVpcEndpointServiceConfigurationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointServiceConfigurationRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointServiceConfigurationRequest), arg0)
-}
-
-// CreateVpcEndpointServiceConfigurationWithContext mocks base method.
-func (m *MockEC2API) CreateVpcEndpointServiceConfigurationWithContext(arg0 context.Context, arg1 *ec2.CreateVpcEndpointServiceConfigurationInput, arg2 ...request.Option) (*ec2.CreateVpcEndpointServiceConfigurationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateVpcEndpointServiceConfigurationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateVpcEndpointServiceConfigurationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVpcEndpointServiceConfigurationWithContext indicates an expected call of CreateVpcEndpointServiceConfigurationWithContext.
-func (mr *MockEC2APIMockRecorder) CreateVpcEndpointServiceConfigurationWithContext(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, "CreateVpcEndpointServiceConfigurationWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointServiceConfigurationWithContext), varargs...)
-}
-
-// CreateVpcEndpointWithContext mocks base method.
-func (m *MockEC2API) CreateVpcEndpointWithContext(arg0 context.Context, arg1 *ec2.CreateVpcEndpointInput, arg2 ...request.Option) (*ec2.CreateVpcEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateVpcEndpointWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateVpcEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVpcEndpointWithContext indicates an expected call of CreateVpcEndpointWithContext.
-func (mr *MockEC2APIMockRecorder) CreateVpcEndpointWithContext(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, "CreateVpcEndpointWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointWithContext), varargs...)
-}
-
-// CreateVpcPeeringConnection mocks base method.
-func (m *MockEC2API) CreateVpcPeeringConnection(arg0 *ec2.CreateVpcPeeringConnectionInput) (*ec2.CreateVpcPeeringConnectionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVpcPeeringConnection", arg0)
-	ret0, _ := ret[0].(*ec2.CreateVpcPeeringConnectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVpcPeeringConnection indicates an expected call of CreateVpcPeeringConnection.
-func (mr *MockEC2APIMockRecorder) CreateVpcPeeringConnection(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcPeeringConnection", reflect.TypeOf((*MockEC2API)(nil).CreateVpcPeeringConnection), arg0)
-}
-
-// CreateVpcPeeringConnectionRequest mocks base method.
-func (m *MockEC2API) CreateVpcPeeringConnectionRequest(arg0 *ec2.CreateVpcPeeringConnectionInput) (*request.Request, *ec2.CreateVpcPeeringConnectionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVpcPeeringConnectionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateVpcPeeringConnectionOutput)
-	return ret0, ret1
-}
-
-// CreateVpcPeeringConnectionRequest indicates an expected call of CreateVpcPeeringConnectionRequest.
-func (mr *MockEC2APIMockRecorder) CreateVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcPeeringConnectionRequest), arg0)
-}
-
-// CreateVpcPeeringConnectionWithContext mocks base method.
-func (m *MockEC2API) CreateVpcPeeringConnectionWithContext(arg0 context.Context, arg1 *ec2.CreateVpcPeeringConnectionInput, arg2 ...request.Option) (*ec2.CreateVpcPeeringConnectionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateVpcPeeringConnectionWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateVpcPeeringConnectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVpcPeeringConnectionWithContext indicates an expected call of CreateVpcPeeringConnectionWithContext.
-func (mr *MockEC2APIMockRecorder) CreateVpcPeeringConnectionWithContext(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, "CreateVpcPeeringConnectionWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpcPeeringConnectionWithContext), varargs...)
-}
-
-// CreateVpcRequest mocks base method.
-func (m *MockEC2API) CreateVpcRequest(arg0 *ec2.CreateVpcInput) (*request.Request, *ec2.CreateVpcOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVpcRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateVpcOutput)
-	return ret0, ret1
-}
-
-// CreateVpcRequest indicates an expected call of CreateVpcRequest.
-func (mr *MockEC2APIMockRecorder) CreateVpcRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcRequest), arg0)
-}
-
-// CreateVpcWithContext mocks base method.
-func (m *MockEC2API) CreateVpcWithContext(arg0 context.Context, arg1 *ec2.CreateVpcInput, arg2 ...request.Option) (*ec2.CreateVpcOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateVpcWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateVpcOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVpcWithContext indicates an expected call of CreateVpcWithContext.
-func (mr *MockEC2APIMockRecorder) CreateVpcWithContext(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, "CreateVpcWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpcWithContext), varargs...)
-}
-
-// CreateVpnConnection mocks base method.
-func (m *MockEC2API) CreateVpnConnection(arg0 *ec2.CreateVpnConnectionInput) (*ec2.CreateVpnConnectionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVpnConnection", arg0)
-	ret0, _ := ret[0].(*ec2.CreateVpnConnectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVpnConnection indicates an expected call of CreateVpnConnection.
-func (mr *MockEC2APIMockRecorder) CreateVpnConnection(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnection", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnection), arg0)
-}
-
-// CreateVpnConnectionRequest mocks base method.
-func (m *MockEC2API) CreateVpnConnectionRequest(arg0 *ec2.CreateVpnConnectionInput) (*request.Request, *ec2.CreateVpnConnectionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVpnConnectionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateVpnConnectionOutput)
-	return ret0, ret1
-}
-
-// CreateVpnConnectionRequest indicates an expected call of CreateVpnConnectionRequest.
-func (mr *MockEC2APIMockRecorder) CreateVpnConnectionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnectionRequest), arg0)
-}
-
-// CreateVpnConnectionRoute mocks base method.
-func (m *MockEC2API) CreateVpnConnectionRoute(arg0 *ec2.CreateVpnConnectionRouteInput) (*ec2.CreateVpnConnectionRouteOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVpnConnectionRoute", arg0)
-	ret0, _ := ret[0].(*ec2.CreateVpnConnectionRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVpnConnectionRoute indicates an expected call of CreateVpnConnectionRoute.
-func (mr *MockEC2APIMockRecorder) CreateVpnConnectionRoute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnectionRoute", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnectionRoute), arg0)
-}
-
-// CreateVpnConnectionRouteRequest mocks base method.
-func (m *MockEC2API) CreateVpnConnectionRouteRequest(arg0 *ec2.CreateVpnConnectionRouteInput) (*request.Request, *ec2.CreateVpnConnectionRouteOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVpnConnectionRouteRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateVpnConnectionRouteOutput)
-	return ret0, ret1
-}
-
-// CreateVpnConnectionRouteRequest indicates an expected call of CreateVpnConnectionRouteRequest.
-func (mr *MockEC2APIMockRecorder) CreateVpnConnectionRouteRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnectionRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnectionRouteRequest), arg0)
-}
-
-// CreateVpnConnectionRouteWithContext mocks base method.
-func (m *MockEC2API) CreateVpnConnectionRouteWithContext(arg0 context.Context, arg1 *ec2.CreateVpnConnectionRouteInput, arg2 ...request.Option) (*ec2.CreateVpnConnectionRouteOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateVpnConnectionRouteWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateVpnConnectionRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVpnConnectionRouteWithContext indicates an expected call of CreateVpnConnectionRouteWithContext.
-func (mr *MockEC2APIMockRecorder) CreateVpnConnectionRouteWithContext(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, "CreateVpnConnectionRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnectionRouteWithContext), varargs...)
-}
-
-// CreateVpnConnectionWithContext mocks base method.
-func (m *MockEC2API) CreateVpnConnectionWithContext(arg0 context.Context, arg1 *ec2.CreateVpnConnectionInput, arg2 ...request.Option) (*ec2.CreateVpnConnectionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateVpnConnectionWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateVpnConnectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVpnConnectionWithContext indicates an expected call of CreateVpnConnectionWithContext.
-func (mr *MockEC2APIMockRecorder) CreateVpnConnectionWithContext(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, "CreateVpnConnectionWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnectionWithContext), varargs...)
-}
-
-// CreateVpnGateway mocks base method.
-func (m *MockEC2API) CreateVpnGateway(arg0 *ec2.CreateVpnGatewayInput) (*ec2.CreateVpnGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVpnGateway", arg0)
-	ret0, _ := ret[0].(*ec2.CreateVpnGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVpnGateway indicates an expected call of CreateVpnGateway.
-func (mr *MockEC2APIMockRecorder) CreateVpnGateway(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnGateway", reflect.TypeOf((*MockEC2API)(nil).CreateVpnGateway), arg0)
-}
-
-// CreateVpnGatewayRequest mocks base method.
-func (m *MockEC2API) CreateVpnGatewayRequest(arg0 *ec2.CreateVpnGatewayInput) (*request.Request, *ec2.CreateVpnGatewayOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateVpnGatewayRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.CreateVpnGatewayOutput)
-	return ret0, ret1
-}
-
-// CreateVpnGatewayRequest indicates an expected call of CreateVpnGatewayRequest.
-func (mr *MockEC2APIMockRecorder) CreateVpnGatewayRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpnGatewayRequest), arg0)
-}
-
-// CreateVpnGatewayWithContext mocks base method.
-func (m *MockEC2API) CreateVpnGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateVpnGatewayInput, arg2 ...request.Option) (*ec2.CreateVpnGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateVpnGatewayWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.CreateVpnGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateVpnGatewayWithContext indicates an expected call of CreateVpnGatewayWithContext.
-func (mr *MockEC2APIMockRecorder) CreateVpnGatewayWithContext(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, "CreateVpnGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpnGatewayWithContext), varargs...)
-}
-
-// DeleteCarrierGateway mocks base method.
-func (m *MockEC2API) DeleteCarrierGateway(arg0 *ec2.DeleteCarrierGatewayInput) (*ec2.DeleteCarrierGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteCarrierGateway", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteCarrierGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteCarrierGateway indicates an expected call of DeleteCarrierGateway.
-func (mr *MockEC2APIMockRecorder) DeleteCarrierGateway(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCarrierGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteCarrierGateway), arg0)
-}
-
-// DeleteCarrierGatewayRequest mocks base method.
-func (m *MockEC2API) DeleteCarrierGatewayRequest(arg0 *ec2.DeleteCarrierGatewayInput) (*request.Request, *ec2.DeleteCarrierGatewayOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteCarrierGatewayRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteCarrierGatewayOutput)
-	return ret0, ret1
-}
-
-// DeleteCarrierGatewayRequest indicates an expected call of DeleteCarrierGatewayRequest.
-func (mr *MockEC2APIMockRecorder) DeleteCarrierGatewayRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCarrierGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteCarrierGatewayRequest), arg0)
-}
-
-// DeleteCarrierGatewayWithContext mocks base method.
-func (m *MockEC2API) DeleteCarrierGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteCarrierGatewayInput, arg2 ...request.Option) (*ec2.DeleteCarrierGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteCarrierGatewayWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteCarrierGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteCarrierGatewayWithContext indicates an expected call of DeleteCarrierGatewayWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteCarrierGatewayWithContext(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, "DeleteCarrierGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteCarrierGatewayWithContext), varargs...)
-}
-
-// DeleteClientVpnEndpoint mocks base method.
-func (m *MockEC2API) DeleteClientVpnEndpoint(arg0 *ec2.DeleteClientVpnEndpointInput) (*ec2.DeleteClientVpnEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteClientVpnEndpoint", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteClientVpnEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteClientVpnEndpoint indicates an expected call of DeleteClientVpnEndpoint.
-func (mr *MockEC2APIMockRecorder) DeleteClientVpnEndpoint(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnEndpoint", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnEndpoint), arg0)
-}
-
-// DeleteClientVpnEndpointRequest mocks base method.
-func (m *MockEC2API) DeleteClientVpnEndpointRequest(arg0 *ec2.DeleteClientVpnEndpointInput) (*request.Request, *ec2.DeleteClientVpnEndpointOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteClientVpnEndpointRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteClientVpnEndpointOutput)
-	return ret0, ret1
-}
-
-// DeleteClientVpnEndpointRequest indicates an expected call of DeleteClientVpnEndpointRequest.
-func (mr *MockEC2APIMockRecorder) DeleteClientVpnEndpointRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnEndpointRequest), arg0)
-}
-
-// DeleteClientVpnEndpointWithContext mocks base method.
-func (m *MockEC2API) DeleteClientVpnEndpointWithContext(arg0 context.Context, arg1 *ec2.DeleteClientVpnEndpointInput, arg2 ...request.Option) (*ec2.DeleteClientVpnEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteClientVpnEndpointWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteClientVpnEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteClientVpnEndpointWithContext indicates an expected call of DeleteClientVpnEndpointWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteClientVpnEndpointWithContext(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, "DeleteClientVpnEndpointWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnEndpointWithContext), varargs...)
-}
-
-// DeleteClientVpnRoute mocks base method.
-func (m *MockEC2API) DeleteClientVpnRoute(arg0 *ec2.DeleteClientVpnRouteInput) (*ec2.DeleteClientVpnRouteOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteClientVpnRoute", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteClientVpnRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteClientVpnRoute indicates an expected call of DeleteClientVpnRoute.
-func (mr *MockEC2APIMockRecorder) DeleteClientVpnRoute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnRoute), arg0)
-}
-
-// DeleteClientVpnRouteRequest mocks base method.
-func (m *MockEC2API) DeleteClientVpnRouteRequest(arg0 *ec2.DeleteClientVpnRouteInput) (*request.Request, *ec2.DeleteClientVpnRouteOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteClientVpnRouteRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteClientVpnRouteOutput)
-	return ret0, ret1
-}
-
-// DeleteClientVpnRouteRequest indicates an expected call of DeleteClientVpnRouteRequest.
-func (mr *MockEC2APIMockRecorder) DeleteClientVpnRouteRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnRouteRequest), arg0)
-}
-
-// DeleteClientVpnRouteWithContext mocks base method.
-func (m *MockEC2API) DeleteClientVpnRouteWithContext(arg0 context.Context, arg1 *ec2.DeleteClientVpnRouteInput, arg2 ...request.Option) (*ec2.DeleteClientVpnRouteOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteClientVpnRouteWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteClientVpnRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteClientVpnRouteWithContext indicates an expected call of DeleteClientVpnRouteWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteClientVpnRouteWithContext(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, "DeleteClientVpnRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnRouteWithContext), varargs...)
-}
-
-// DeleteCoipCidr mocks base method.
-func (m *MockEC2API) DeleteCoipCidr(arg0 *ec2.DeleteCoipCidrInput) (*ec2.DeleteCoipCidrOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteCoipCidr", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteCoipCidrOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteCoipCidr indicates an expected call of DeleteCoipCidr.
-func (mr *MockEC2APIMockRecorder) DeleteCoipCidr(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCoipCidr", reflect.TypeOf((*MockEC2API)(nil).DeleteCoipCidr), arg0)
-}
-
-// DeleteCoipCidrRequest mocks base method.
-func (m *MockEC2API) DeleteCoipCidrRequest(arg0 *ec2.DeleteCoipCidrInput) (*request.Request, *ec2.DeleteCoipCidrOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteCoipCidrRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteCoipCidrOutput)
-	return ret0, ret1
-}
-
-// DeleteCoipCidrRequest indicates an expected call of DeleteCoipCidrRequest.
-func (mr *MockEC2APIMockRecorder) DeleteCoipCidrRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteCoipCidrRequest), arg0)
-}
-
-// DeleteCoipCidrWithContext mocks base method.
-func (m *MockEC2API) DeleteCoipCidrWithContext(arg0 context.Context, arg1 *ec2.DeleteCoipCidrInput, arg2 ...request.Option) (*ec2.DeleteCoipCidrOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteCoipCidrWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteCoipCidrOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteCoipCidrWithContext indicates an expected call of DeleteCoipCidrWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteCoipCidrWithContext(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, "DeleteCoipCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteCoipCidrWithContext), varargs...)
-}
-
-// DeleteCoipPool mocks base method.
-func (m *MockEC2API) DeleteCoipPool(arg0 *ec2.DeleteCoipPoolInput) (*ec2.DeleteCoipPoolOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteCoipPool", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteCoipPoolOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteCoipPool indicates an expected call of DeleteCoipPool.
-func (mr *MockEC2APIMockRecorder) DeleteCoipPool(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCoipPool", reflect.TypeOf((*MockEC2API)(nil).DeleteCoipPool), arg0)
-}
-
-// DeleteCoipPoolRequest mocks base method.
-func (m *MockEC2API) DeleteCoipPoolRequest(arg0 *ec2.DeleteCoipPoolInput) (*request.Request, *ec2.DeleteCoipPoolOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteCoipPoolRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteCoipPoolOutput)
-	return ret0, ret1
-}
-
-// DeleteCoipPoolRequest indicates an expected call of DeleteCoipPoolRequest.
-func (mr *MockEC2APIMockRecorder) DeleteCoipPoolRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCoipPoolRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteCoipPoolRequest), arg0)
-}
-
-// DeleteCoipPoolWithContext mocks base method.
-func (m *MockEC2API) DeleteCoipPoolWithContext(arg0 context.Context, arg1 *ec2.DeleteCoipPoolInput, arg2 ...request.Option) (*ec2.DeleteCoipPoolOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteCoipPoolWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteCoipPoolOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteCoipPoolWithContext indicates an expected call of DeleteCoipPoolWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteCoipPoolWithContext(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, "DeleteCoipPoolWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteCoipPoolWithContext), varargs...)
-}
-
-// DeleteCustomerGateway mocks base method.
-func (m *MockEC2API) DeleteCustomerGateway(arg0 *ec2.DeleteCustomerGatewayInput) (*ec2.DeleteCustomerGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteCustomerGateway", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteCustomerGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteCustomerGateway indicates an expected call of DeleteCustomerGateway.
-func (mr *MockEC2APIMockRecorder) DeleteCustomerGateway(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomerGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteCustomerGateway), arg0)
-}
-
-// DeleteCustomerGatewayRequest mocks base method.
-func (m *MockEC2API) DeleteCustomerGatewayRequest(arg0 *ec2.DeleteCustomerGatewayInput) (*request.Request, *ec2.DeleteCustomerGatewayOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteCustomerGatewayRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteCustomerGatewayOutput)
-	return ret0, ret1
-}
-
-// DeleteCustomerGatewayRequest indicates an expected call of DeleteCustomerGatewayRequest.
-func (mr *MockEC2APIMockRecorder) DeleteCustomerGatewayRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomerGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteCustomerGatewayRequest), arg0)
-}
-
-// DeleteCustomerGatewayWithContext mocks base method.
-func (m *MockEC2API) DeleteCustomerGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteCustomerGatewayInput, arg2 ...request.Option) (*ec2.DeleteCustomerGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteCustomerGatewayWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteCustomerGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteCustomerGatewayWithContext indicates an expected call of DeleteCustomerGatewayWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteCustomerGatewayWithContext(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, "DeleteCustomerGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteCustomerGatewayWithContext), varargs...)
-}
-
-// DeleteDhcpOptions mocks base method.
-func (m *MockEC2API) DeleteDhcpOptions(arg0 *ec2.DeleteDhcpOptionsInput) (*ec2.DeleteDhcpOptionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteDhcpOptions", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteDhcpOptionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteDhcpOptions indicates an expected call of DeleteDhcpOptions.
-func (mr *MockEC2APIMockRecorder) DeleteDhcpOptions(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDhcpOptions", reflect.TypeOf((*MockEC2API)(nil).DeleteDhcpOptions), arg0)
-}
-
-// DeleteDhcpOptionsRequest mocks base method.
-func (m *MockEC2API) DeleteDhcpOptionsRequest(arg0 *ec2.DeleteDhcpOptionsInput) (*request.Request, *ec2.DeleteDhcpOptionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteDhcpOptionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteDhcpOptionsOutput)
-	return ret0, ret1
-}
-
-// DeleteDhcpOptionsRequest indicates an expected call of DeleteDhcpOptionsRequest.
-func (mr *MockEC2APIMockRecorder) DeleteDhcpOptionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDhcpOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteDhcpOptionsRequest), arg0)
-}
-
-// DeleteDhcpOptionsWithContext mocks base method.
-func (m *MockEC2API) DeleteDhcpOptionsWithContext(arg0 context.Context, arg1 *ec2.DeleteDhcpOptionsInput, arg2 ...request.Option) (*ec2.DeleteDhcpOptionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteDhcpOptionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteDhcpOptionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteDhcpOptionsWithContext indicates an expected call of DeleteDhcpOptionsWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteDhcpOptionsWithContext(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, "DeleteDhcpOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteDhcpOptionsWithContext), varargs...)
-}
-
-// DeleteEgressOnlyInternetGateway mocks base method.
-func (m *MockEC2API) DeleteEgressOnlyInternetGateway(arg0 *ec2.DeleteEgressOnlyInternetGatewayInput) (*ec2.DeleteEgressOnlyInternetGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteEgressOnlyInternetGateway", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteEgressOnlyInternetGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteEgressOnlyInternetGateway indicates an expected call of DeleteEgressOnlyInternetGateway.
-func (mr *MockEC2APIMockRecorder) DeleteEgressOnlyInternetGateway(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEgressOnlyInternetGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteEgressOnlyInternetGateway), arg0)
-}
-
-// DeleteEgressOnlyInternetGatewayRequest mocks base method.
-func (m *MockEC2API) DeleteEgressOnlyInternetGatewayRequest(arg0 *ec2.DeleteEgressOnlyInternetGatewayInput) (*request.Request, *ec2.DeleteEgressOnlyInternetGatewayOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteEgressOnlyInternetGatewayRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteEgressOnlyInternetGatewayOutput)
-	return ret0, ret1
-}
-
-// DeleteEgressOnlyInternetGatewayRequest indicates an expected call of DeleteEgressOnlyInternetGatewayRequest.
-func (mr *MockEC2APIMockRecorder) DeleteEgressOnlyInternetGatewayRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEgressOnlyInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteEgressOnlyInternetGatewayRequest), arg0)
-}
-
-// DeleteEgressOnlyInternetGatewayWithContext mocks base method.
-func (m *MockEC2API) DeleteEgressOnlyInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteEgressOnlyInternetGatewayInput, arg2 ...request.Option) (*ec2.DeleteEgressOnlyInternetGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteEgressOnlyInternetGatewayWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteEgressOnlyInternetGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteEgressOnlyInternetGatewayWithContext indicates an expected call of DeleteEgressOnlyInternetGatewayWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteEgressOnlyInternetGatewayWithContext(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, "DeleteEgressOnlyInternetGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteEgressOnlyInternetGatewayWithContext), varargs...)
-}
-
-// DeleteFleets mocks base method.
-func (m *MockEC2API) DeleteFleets(arg0 *ec2.DeleteFleetsInput) (*ec2.DeleteFleetsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteFleets", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteFleetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteFleets indicates an expected call of DeleteFleets.
-func (mr *MockEC2APIMockRecorder) DeleteFleets(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFleets", reflect.TypeOf((*MockEC2API)(nil).DeleteFleets), arg0)
-}
-
-// DeleteFleetsRequest mocks base method.
-func (m *MockEC2API) DeleteFleetsRequest(arg0 *ec2.DeleteFleetsInput) (*request.Request, *ec2.DeleteFleetsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteFleetsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteFleetsOutput)
-	return ret0, ret1
-}
-
-// DeleteFleetsRequest indicates an expected call of DeleteFleetsRequest.
-func (mr *MockEC2APIMockRecorder) DeleteFleetsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFleetsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteFleetsRequest), arg0)
-}
-
-// DeleteFleetsWithContext mocks base method.
-func (m *MockEC2API) DeleteFleetsWithContext(arg0 context.Context, arg1 *ec2.DeleteFleetsInput, arg2 ...request.Option) (*ec2.DeleteFleetsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteFleetsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteFleetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteFleetsWithContext indicates an expected call of DeleteFleetsWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteFleetsWithContext(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, "DeleteFleetsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteFleetsWithContext), varargs...)
-}
-
-// DeleteFlowLogs mocks base method.
-func (m *MockEC2API) DeleteFlowLogs(arg0 *ec2.DeleteFlowLogsInput) (*ec2.DeleteFlowLogsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteFlowLogs", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteFlowLogsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteFlowLogs indicates an expected call of DeleteFlowLogs.
-func (mr *MockEC2APIMockRecorder) DeleteFlowLogs(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFlowLogs", reflect.TypeOf((*MockEC2API)(nil).DeleteFlowLogs), arg0)
-}
-
-// DeleteFlowLogsRequest mocks base method.
-func (m *MockEC2API) DeleteFlowLogsRequest(arg0 *ec2.DeleteFlowLogsInput) (*request.Request, *ec2.DeleteFlowLogsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteFlowLogsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteFlowLogsOutput)
-	return ret0, ret1
-}
-
-// DeleteFlowLogsRequest indicates an expected call of DeleteFlowLogsRequest.
-func (mr *MockEC2APIMockRecorder) DeleteFlowLogsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFlowLogsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteFlowLogsRequest), arg0)
-}
-
-// DeleteFlowLogsWithContext mocks base method.
-func (m *MockEC2API) DeleteFlowLogsWithContext(arg0 context.Context, arg1 *ec2.DeleteFlowLogsInput, arg2 ...request.Option) (*ec2.DeleteFlowLogsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteFlowLogsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteFlowLogsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteFlowLogsWithContext indicates an expected call of DeleteFlowLogsWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteFlowLogsWithContext(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, "DeleteFlowLogsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteFlowLogsWithContext), varargs...)
-}
-
-// DeleteFpgaImage mocks base method.
-func (m *MockEC2API) DeleteFpgaImage(arg0 *ec2.DeleteFpgaImageInput) (*ec2.DeleteFpgaImageOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteFpgaImage", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteFpgaImageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteFpgaImage indicates an expected call of DeleteFpgaImage.
-func (mr *MockEC2APIMockRecorder) DeleteFpgaImage(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFpgaImage", reflect.TypeOf((*MockEC2API)(nil).DeleteFpgaImage), arg0)
-}
-
-// DeleteFpgaImageRequest mocks base method.
-func (m *MockEC2API) DeleteFpgaImageRequest(arg0 *ec2.DeleteFpgaImageInput) (*request.Request, *ec2.DeleteFpgaImageOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteFpgaImageRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteFpgaImageOutput)
-	return ret0, ret1
-}
-
-// DeleteFpgaImageRequest indicates an expected call of DeleteFpgaImageRequest.
-func (mr *MockEC2APIMockRecorder) DeleteFpgaImageRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFpgaImageRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteFpgaImageRequest), arg0)
-}
-
-// DeleteFpgaImageWithContext mocks base method.
-func (m *MockEC2API) DeleteFpgaImageWithContext(arg0 context.Context, arg1 *ec2.DeleteFpgaImageInput, arg2 ...request.Option) (*ec2.DeleteFpgaImageOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteFpgaImageWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteFpgaImageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteFpgaImageWithContext indicates an expected call of DeleteFpgaImageWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteFpgaImageWithContext(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, "DeleteFpgaImageWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteFpgaImageWithContext), varargs...)
-}
-
-// DeleteInstanceConnectEndpoint mocks base method.
-func (m *MockEC2API) DeleteInstanceConnectEndpoint(arg0 *ec2.DeleteInstanceConnectEndpointInput) (*ec2.DeleteInstanceConnectEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteInstanceConnectEndpoint", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteInstanceConnectEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteInstanceConnectEndpoint indicates an expected call of DeleteInstanceConnectEndpoint.
-func (mr *MockEC2APIMockRecorder) DeleteInstanceConnectEndpoint(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstanceConnectEndpoint", reflect.TypeOf((*MockEC2API)(nil).DeleteInstanceConnectEndpoint), arg0)
-}
-
-// DeleteInstanceConnectEndpointRequest mocks base method.
-func (m *MockEC2API) DeleteInstanceConnectEndpointRequest(arg0 *ec2.DeleteInstanceConnectEndpointInput) (*request.Request, *ec2.DeleteInstanceConnectEndpointOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteInstanceConnectEndpointRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteInstanceConnectEndpointOutput)
-	return ret0, ret1
-}
-
-// DeleteInstanceConnectEndpointRequest indicates an expected call of DeleteInstanceConnectEndpointRequest.
-func (mr *MockEC2APIMockRecorder) DeleteInstanceConnectEndpointRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstanceConnectEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteInstanceConnectEndpointRequest), arg0)
-}
-
-// DeleteInstanceConnectEndpointWithContext mocks base method.
-func (m *MockEC2API) DeleteInstanceConnectEndpointWithContext(arg0 context.Context, arg1 *ec2.DeleteInstanceConnectEndpointInput, arg2 ...request.Option) (*ec2.DeleteInstanceConnectEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteInstanceConnectEndpointWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteInstanceConnectEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteInstanceConnectEndpointWithContext indicates an expected call of DeleteInstanceConnectEndpointWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteInstanceConnectEndpointWithContext(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, "DeleteInstanceConnectEndpointWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteInstanceConnectEndpointWithContext), varargs...)
-}
-
-// DeleteInstanceEventWindow mocks base method.
-func (m *MockEC2API) DeleteInstanceEventWindow(arg0 *ec2.DeleteInstanceEventWindowInput) (*ec2.DeleteInstanceEventWindowOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteInstanceEventWindow", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteInstanceEventWindowOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteInstanceEventWindow indicates an expected call of DeleteInstanceEventWindow.
-func (mr *MockEC2APIMockRecorder) DeleteInstanceEventWindow(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstanceEventWindow", reflect.TypeOf((*MockEC2API)(nil).DeleteInstanceEventWindow), arg0)
-}
-
-// DeleteInstanceEventWindowRequest mocks base method.
-func (m *MockEC2API) DeleteInstanceEventWindowRequest(arg0 *ec2.DeleteInstanceEventWindowInput) (*request.Request, *ec2.DeleteInstanceEventWindowOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteInstanceEventWindowRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteInstanceEventWindowOutput)
-	return ret0, ret1
-}
-
-// DeleteInstanceEventWindowRequest indicates an expected call of DeleteInstanceEventWindowRequest.
-func (mr *MockEC2APIMockRecorder) DeleteInstanceEventWindowRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstanceEventWindowRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteInstanceEventWindowRequest), arg0)
-}
-
-// DeleteInstanceEventWindowWithContext mocks base method.
-func (m *MockEC2API) DeleteInstanceEventWindowWithContext(arg0 context.Context, arg1 *ec2.DeleteInstanceEventWindowInput, arg2 ...request.Option) (*ec2.DeleteInstanceEventWindowOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteInstanceEventWindowWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteInstanceEventWindowOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteInstanceEventWindowWithContext indicates an expected call of DeleteInstanceEventWindowWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteInstanceEventWindowWithContext(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, "DeleteInstanceEventWindowWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteInstanceEventWindowWithContext), varargs...)
-}
-
-// DeleteInternetGateway mocks base method.
-func (m *MockEC2API) DeleteInternetGateway(arg0 *ec2.DeleteInternetGatewayInput) (*ec2.DeleteInternetGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteInternetGateway", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteInternetGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteInternetGateway indicates an expected call of DeleteInternetGateway.
-func (mr *MockEC2APIMockRecorder) DeleteInternetGateway(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInternetGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteInternetGateway), arg0)
-}
-
-// DeleteInternetGatewayRequest mocks base method.
-func (m *MockEC2API) DeleteInternetGatewayRequest(arg0 *ec2.DeleteInternetGatewayInput) (*request.Request, *ec2.DeleteInternetGatewayOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteInternetGatewayRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteInternetGatewayOutput)
-	return ret0, ret1
-}
-
-// DeleteInternetGatewayRequest indicates an expected call of DeleteInternetGatewayRequest.
-func (mr *MockEC2APIMockRecorder) DeleteInternetGatewayRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteInternetGatewayRequest), arg0)
-}
-
-// DeleteInternetGatewayWithContext mocks base method.
-func (m *MockEC2API) DeleteInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteInternetGatewayInput, arg2 ...request.Option) (*ec2.DeleteInternetGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteInternetGatewayWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteInternetGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteInternetGatewayWithContext indicates an expected call of DeleteInternetGatewayWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteInternetGatewayWithContext(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, "DeleteInternetGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteInternetGatewayWithContext), varargs...)
-}
-
-// DeleteIpam mocks base method.
-func (m *MockEC2API) DeleteIpam(arg0 *ec2.DeleteIpamInput) (*ec2.DeleteIpamOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteIpam", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteIpamOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteIpam indicates an expected call of DeleteIpam.
-func (mr *MockEC2APIMockRecorder) DeleteIpam(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpam", reflect.TypeOf((*MockEC2API)(nil).DeleteIpam), arg0)
-}
-
-// DeleteIpamExternalResourceVerificationToken mocks base method.
-func (m *MockEC2API) DeleteIpamExternalResourceVerificationToken(arg0 *ec2.DeleteIpamExternalResourceVerificationTokenInput) (*ec2.DeleteIpamExternalResourceVerificationTokenOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteIpamExternalResourceVerificationToken", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteIpamExternalResourceVerificationTokenOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteIpamExternalResourceVerificationToken indicates an expected call of DeleteIpamExternalResourceVerificationToken.
-func (mr *MockEC2APIMockRecorder) DeleteIpamExternalResourceVerificationToken(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamExternalResourceVerificationToken", reflect.TypeOf((*MockEC2API)(nil).DeleteIpamExternalResourceVerificationToken), arg0)
-}
-
-// DeleteIpamExternalResourceVerificationTokenRequest mocks base method.
-func (m *MockEC2API) DeleteIpamExternalResourceVerificationTokenRequest(arg0 *ec2.DeleteIpamExternalResourceVerificationTokenInput) (*request.Request, *ec2.DeleteIpamExternalResourceVerificationTokenOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteIpamExternalResourceVerificationTokenRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteIpamExternalResourceVerificationTokenOutput)
-	return ret0, ret1
-}
-
-// DeleteIpamExternalResourceVerificationTokenRequest indicates an expected call of DeleteIpamExternalResourceVerificationTokenRequest.
-func (mr *MockEC2APIMockRecorder) DeleteIpamExternalResourceVerificationTokenRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamExternalResourceVerificationTokenRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteIpamExternalResourceVerificationTokenRequest), arg0)
-}
-
-// DeleteIpamExternalResourceVerificationTokenWithContext mocks base method.
-func (m *MockEC2API) DeleteIpamExternalResourceVerificationTokenWithContext(arg0 context.Context, arg1 *ec2.DeleteIpamExternalResourceVerificationTokenInput, arg2 ...request.Option) (*ec2.DeleteIpamExternalResourceVerificationTokenOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteIpamExternalResourceVerificationTokenWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteIpamExternalResourceVerificationTokenOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteIpamExternalResourceVerificationTokenWithContext indicates an expected call of DeleteIpamExternalResourceVerificationTokenWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteIpamExternalResourceVerificationTokenWithContext(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, "DeleteIpamExternalResourceVerificationTokenWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteIpamExternalResourceVerificationTokenWithContext), varargs...)
-}
-
-// DeleteIpamPool mocks base method.
-func (m *MockEC2API) DeleteIpamPool(arg0 *ec2.DeleteIpamPoolInput) (*ec2.DeleteIpamPoolOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteIpamPool", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteIpamPoolOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteIpamPool indicates an expected call of DeleteIpamPool.
-func (mr *MockEC2APIMockRecorder) DeleteIpamPool(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamPool", reflect.TypeOf((*MockEC2API)(nil).DeleteIpamPool), arg0)
-}
-
-// DeleteIpamPoolRequest mocks base method.
-func (m *MockEC2API) DeleteIpamPoolRequest(arg0 *ec2.DeleteIpamPoolInput) (*request.Request, *ec2.DeleteIpamPoolOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteIpamPoolRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteIpamPoolOutput)
-	return ret0, ret1
-}
-
-// DeleteIpamPoolRequest indicates an expected call of DeleteIpamPoolRequest.
-func (mr *MockEC2APIMockRecorder) DeleteIpamPoolRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamPoolRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteIpamPoolRequest), arg0)
-}
-
-// DeleteIpamPoolWithContext mocks base method.
-func (m *MockEC2API) DeleteIpamPoolWithContext(arg0 context.Context, arg1 *ec2.DeleteIpamPoolInput, arg2 ...request.Option) (*ec2.DeleteIpamPoolOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteIpamPoolWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteIpamPoolOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteIpamPoolWithContext indicates an expected call of DeleteIpamPoolWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteIpamPoolWithContext(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, "DeleteIpamPoolWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteIpamPoolWithContext), varargs...)
-}
-
-// DeleteIpamRequest mocks base method.
-func (m *MockEC2API) DeleteIpamRequest(arg0 *ec2.DeleteIpamInput) (*request.Request, *ec2.DeleteIpamOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteIpamRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteIpamOutput)
-	return ret0, ret1
-}
-
-// DeleteIpamRequest indicates an expected call of DeleteIpamRequest.
-func (mr *MockEC2APIMockRecorder) DeleteIpamRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteIpamRequest), arg0)
-}
-
-// DeleteIpamResourceDiscovery mocks base method.
-func (m *MockEC2API) DeleteIpamResourceDiscovery(arg0 *ec2.DeleteIpamResourceDiscoveryInput) (*ec2.DeleteIpamResourceDiscoveryOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteIpamResourceDiscovery", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteIpamResourceDiscoveryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteIpamResourceDiscovery indicates an expected call of DeleteIpamResourceDiscovery.
-func (mr *MockEC2APIMockRecorder) DeleteIpamResourceDiscovery(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamResourceDiscovery", reflect.TypeOf((*MockEC2API)(nil).DeleteIpamResourceDiscovery), arg0)
-}
-
-// DeleteIpamResourceDiscoveryRequest mocks base method.
-func (m *MockEC2API) DeleteIpamResourceDiscoveryRequest(arg0 *ec2.DeleteIpamResourceDiscoveryInput) (*request.Request, *ec2.DeleteIpamResourceDiscoveryOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteIpamResourceDiscoveryRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteIpamResourceDiscoveryOutput)
-	return ret0, ret1
-}
-
-// DeleteIpamResourceDiscoveryRequest indicates an expected call of DeleteIpamResourceDiscoveryRequest.
-func (mr *MockEC2APIMockRecorder) DeleteIpamResourceDiscoveryRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamResourceDiscoveryRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteIpamResourceDiscoveryRequest), arg0)
-}
-
-// DeleteIpamResourceDiscoveryWithContext mocks base method.
-func (m *MockEC2API) DeleteIpamResourceDiscoveryWithContext(arg0 context.Context, arg1 *ec2.DeleteIpamResourceDiscoveryInput, arg2 ...request.Option) (*ec2.DeleteIpamResourceDiscoveryOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteIpamResourceDiscoveryWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteIpamResourceDiscoveryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteIpamResourceDiscoveryWithContext indicates an expected call of DeleteIpamResourceDiscoveryWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteIpamResourceDiscoveryWithContext(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, "DeleteIpamResourceDiscoveryWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteIpamResourceDiscoveryWithContext), varargs...)
-}
-
-// DeleteIpamScope mocks base method.
-func (m *MockEC2API) DeleteIpamScope(arg0 *ec2.DeleteIpamScopeInput) (*ec2.DeleteIpamScopeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteIpamScope", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteIpamScopeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteIpamScope indicates an expected call of DeleteIpamScope.
-func (mr *MockEC2APIMockRecorder) DeleteIpamScope(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamScope", reflect.TypeOf((*MockEC2API)(nil).DeleteIpamScope), arg0)
-}
-
-// DeleteIpamScopeRequest mocks base method.
-func (m *MockEC2API) DeleteIpamScopeRequest(arg0 *ec2.DeleteIpamScopeInput) (*request.Request, *ec2.DeleteIpamScopeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteIpamScopeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteIpamScopeOutput)
-	return ret0, ret1
-}
-
-// DeleteIpamScopeRequest indicates an expected call of DeleteIpamScopeRequest.
-func (mr *MockEC2APIMockRecorder) DeleteIpamScopeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamScopeRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteIpamScopeRequest), arg0)
-}
-
-// DeleteIpamScopeWithContext mocks base method.
-func (m *MockEC2API) DeleteIpamScopeWithContext(arg0 context.Context, arg1 *ec2.DeleteIpamScopeInput, arg2 ...request.Option) (*ec2.DeleteIpamScopeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteIpamScopeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteIpamScopeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteIpamScopeWithContext indicates an expected call of DeleteIpamScopeWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteIpamScopeWithContext(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, "DeleteIpamScopeWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteIpamScopeWithContext), varargs...)
-}
-
-// DeleteIpamWithContext mocks base method.
-func (m *MockEC2API) DeleteIpamWithContext(arg0 context.Context, arg1 *ec2.DeleteIpamInput, arg2 ...request.Option) (*ec2.DeleteIpamOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteIpamWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteIpamOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteIpamWithContext indicates an expected call of DeleteIpamWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteIpamWithContext(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, "DeleteIpamWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteIpamWithContext), varargs...)
-}
-
-// DeleteKeyPair mocks base method.
-func (m *MockEC2API) DeleteKeyPair(arg0 *ec2.DeleteKeyPairInput) (*ec2.DeleteKeyPairOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteKeyPair", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteKeyPairOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteKeyPair indicates an expected call of DeleteKeyPair.
-func (mr *MockEC2APIMockRecorder) DeleteKeyPair(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKeyPair", reflect.TypeOf((*MockEC2API)(nil).DeleteKeyPair), arg0)
-}
-
-// DeleteKeyPairRequest mocks base method.
-func (m *MockEC2API) DeleteKeyPairRequest(arg0 *ec2.DeleteKeyPairInput) (*request.Request, *ec2.DeleteKeyPairOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteKeyPairRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteKeyPairOutput)
-	return ret0, ret1
-}
-
-// DeleteKeyPairRequest indicates an expected call of DeleteKeyPairRequest.
-func (mr *MockEC2APIMockRecorder) DeleteKeyPairRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKeyPairRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteKeyPairRequest), arg0)
-}
-
-// DeleteKeyPairWithContext mocks base method.
-func (m *MockEC2API) DeleteKeyPairWithContext(arg0 context.Context, arg1 *ec2.DeleteKeyPairInput, arg2 ...request.Option) (*ec2.DeleteKeyPairOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteKeyPairWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteKeyPairOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteKeyPairWithContext indicates an expected call of DeleteKeyPairWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteKeyPairWithContext(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, "DeleteKeyPairWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteKeyPairWithContext), varargs...)
-}
-
-// DeleteLaunchTemplate mocks base method.
-func (m *MockEC2API) DeleteLaunchTemplate(arg0 *ec2.DeleteLaunchTemplateInput) (*ec2.DeleteLaunchTemplateOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLaunchTemplate", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteLaunchTemplateOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteLaunchTemplate indicates an expected call of DeleteLaunchTemplate.
-func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplate(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplate", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplate), arg0)
-}
-
-// DeleteLaunchTemplateRequest mocks base method.
-func (m *MockEC2API) DeleteLaunchTemplateRequest(arg0 *ec2.DeleteLaunchTemplateInput) (*request.Request, *ec2.DeleteLaunchTemplateOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLaunchTemplateRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteLaunchTemplateOutput)
-	return ret0, ret1
-}
-
-// DeleteLaunchTemplateRequest indicates an expected call of DeleteLaunchTemplateRequest.
-func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplateRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplateRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplateRequest), arg0)
-}
-
-// DeleteLaunchTemplateVersions mocks base method.
-func (m *MockEC2API) DeleteLaunchTemplateVersions(arg0 *ec2.DeleteLaunchTemplateVersionsInput) (*ec2.DeleteLaunchTemplateVersionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLaunchTemplateVersions", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteLaunchTemplateVersionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteLaunchTemplateVersions indicates an expected call of DeleteLaunchTemplateVersions.
-func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplateVersions(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplateVersions", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplateVersions), arg0)
-}
-
-// DeleteLaunchTemplateVersionsRequest mocks base method.
-func (m *MockEC2API) DeleteLaunchTemplateVersionsRequest(arg0 *ec2.DeleteLaunchTemplateVersionsInput) (*request.Request, *ec2.DeleteLaunchTemplateVersionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLaunchTemplateVersionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteLaunchTemplateVersionsOutput)
-	return ret0, ret1
-}
-
-// DeleteLaunchTemplateVersionsRequest indicates an expected call of DeleteLaunchTemplateVersionsRequest.
-func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplateVersionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplateVersionsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplateVersionsRequest), arg0)
-}
-
-// DeleteLaunchTemplateVersionsWithContext mocks base method.
-func (m *MockEC2API) DeleteLaunchTemplateVersionsWithContext(arg0 context.Context, arg1 *ec2.DeleteLaunchTemplateVersionsInput, arg2 ...request.Option) (*ec2.DeleteLaunchTemplateVersionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteLaunchTemplateVersionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteLaunchTemplateVersionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteLaunchTemplateVersionsWithContext indicates an expected call of DeleteLaunchTemplateVersionsWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplateVersionsWithContext(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, "DeleteLaunchTemplateVersionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplateVersionsWithContext), varargs...)
-}
-
-// DeleteLaunchTemplateWithContext mocks base method.
-func (m *MockEC2API) DeleteLaunchTemplateWithContext(arg0 context.Context, arg1 *ec2.DeleteLaunchTemplateInput, arg2 ...request.Option) (*ec2.DeleteLaunchTemplateOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteLaunchTemplateWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteLaunchTemplateOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteLaunchTemplateWithContext indicates an expected call of DeleteLaunchTemplateWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplateWithContext(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, "DeleteLaunchTemplateWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplateWithContext), varargs...)
-}
-
-// DeleteLocalGatewayRoute mocks base method.
-func (m *MockEC2API) DeleteLocalGatewayRoute(arg0 *ec2.DeleteLocalGatewayRouteInput) (*ec2.DeleteLocalGatewayRouteOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLocalGatewayRoute", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteLocalGatewayRoute indicates an expected call of DeleteLocalGatewayRoute.
-func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRoute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRoute), arg0)
-}
-
-// DeleteLocalGatewayRouteRequest mocks base method.
-func (m *MockEC2API) DeleteLocalGatewayRouteRequest(arg0 *ec2.DeleteLocalGatewayRouteInput) (*request.Request, *ec2.DeleteLocalGatewayRouteOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteLocalGatewayRouteOutput)
-	return ret0, ret1
-}
-
-// DeleteLocalGatewayRouteRequest indicates an expected call of DeleteLocalGatewayRouteRequest.
-func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRouteRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteRequest), arg0)
-}
-
-// DeleteLocalGatewayRouteTable mocks base method.
-func (m *MockEC2API) DeleteLocalGatewayRouteTable(arg0 *ec2.DeleteLocalGatewayRouteTableInput) (*ec2.DeleteLocalGatewayRouteTableOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTable", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteLocalGatewayRouteTable indicates an expected call of DeleteLocalGatewayRouteTable.
-func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRouteTable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteTable), arg0)
-}
-
-// DeleteLocalGatewayRouteTableRequest mocks base method.
-func (m *MockEC2API) DeleteLocalGatewayRouteTableRequest(arg0 *ec2.DeleteLocalGatewayRouteTableInput) (*request.Request, *ec2.DeleteLocalGatewayRouteTableOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteLocalGatewayRouteTableOutput)
-	return ret0, ret1
-}
-
-// DeleteLocalGatewayRouteTableRequest indicates an expected call of DeleteLocalGatewayRouteTableRequest.
-func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRouteTableRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteTableRequest), arg0)
-}
-
-// DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation mocks base method.
-func (m *MockEC2API) DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation(arg0 *ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput) (*ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation indicates an expected call of DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation.
-func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation), arg0)
-}
-
-// DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest mocks base method.
-func (m *MockEC2API) DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest(arg0 *ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput) (*request.Request, *ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput)
-	return ret0, ret1
-}
-
-// DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest indicates an expected call of DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest.
-func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest), arg0)
-}
-
-// DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext mocks base method.
-func (m *MockEC2API) DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext(arg0 context.Context, arg1 *ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput, arg2 ...request.Option) (*ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext indicates an expected call of DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext(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, "DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext), varargs...)
-}
-
-// DeleteLocalGatewayRouteTableVpcAssociation mocks base method.
-func (m *MockEC2API) DeleteLocalGatewayRouteTableVpcAssociation(arg0 *ec2.DeleteLocalGatewayRouteTableVpcAssociationInput) (*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableVpcAssociation", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteLocalGatewayRouteTableVpcAssociation indicates an expected call of DeleteLocalGatewayRouteTableVpcAssociation.
-func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRouteTableVpcAssociation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteTableVpcAssociation", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteTableVpcAssociation), arg0)
-}
-
-// DeleteLocalGatewayRouteTableVpcAssociationRequest mocks base method.
-func (m *MockEC2API) DeleteLocalGatewayRouteTableVpcAssociationRequest(arg0 *ec2.DeleteLocalGatewayRouteTableVpcAssociationInput) (*request.Request, *ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableVpcAssociationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput)
-	return ret0, ret1
-}
-
-// DeleteLocalGatewayRouteTableVpcAssociationRequest indicates an expected call of DeleteLocalGatewayRouteTableVpcAssociationRequest.
-func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRouteTableVpcAssociationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteTableVpcAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteTableVpcAssociationRequest), arg0)
-}
-
-// DeleteLocalGatewayRouteTableVpcAssociationWithContext mocks base method.
-func (m *MockEC2API) DeleteLocalGatewayRouteTableVpcAssociationWithContext(arg0 context.Context, arg1 *ec2.DeleteLocalGatewayRouteTableVpcAssociationInput, arg2 ...request.Option) (*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableVpcAssociationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteLocalGatewayRouteTableVpcAssociationWithContext indicates an expected call of DeleteLocalGatewayRouteTableVpcAssociationWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRouteTableVpcAssociationWithContext(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, "DeleteLocalGatewayRouteTableVpcAssociationWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteTableVpcAssociationWithContext), varargs...)
-}
-
-// DeleteLocalGatewayRouteTableWithContext mocks base method.
-func (m *MockEC2API) DeleteLocalGatewayRouteTableWithContext(arg0 context.Context, arg1 *ec2.DeleteLocalGatewayRouteTableInput, arg2 ...request.Option) (*ec2.DeleteLocalGatewayRouteTableOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteLocalGatewayRouteTableWithContext indicates an expected call of DeleteLocalGatewayRouteTableWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRouteTableWithContext(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, "DeleteLocalGatewayRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteTableWithContext), varargs...)
-}
-
-// DeleteLocalGatewayRouteWithContext mocks base method.
-func (m *MockEC2API) DeleteLocalGatewayRouteWithContext(arg0 context.Context, arg1 *ec2.DeleteLocalGatewayRouteInput, arg2 ...request.Option) (*ec2.DeleteLocalGatewayRouteOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteLocalGatewayRouteWithContext indicates an expected call of DeleteLocalGatewayRouteWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRouteWithContext(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, "DeleteLocalGatewayRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteWithContext), varargs...)
-}
-
-// DeleteManagedPrefixList mocks base method.
-func (m *MockEC2API) DeleteManagedPrefixList(arg0 *ec2.DeleteManagedPrefixListInput) (*ec2.DeleteManagedPrefixListOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteManagedPrefixList", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteManagedPrefixListOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteManagedPrefixList indicates an expected call of DeleteManagedPrefixList.
-func (mr *MockEC2APIMockRecorder) DeleteManagedPrefixList(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteManagedPrefixList", reflect.TypeOf((*MockEC2API)(nil).DeleteManagedPrefixList), arg0)
-}
-
-// DeleteManagedPrefixListRequest mocks base method.
-func (m *MockEC2API) DeleteManagedPrefixListRequest(arg0 *ec2.DeleteManagedPrefixListInput) (*request.Request, *ec2.DeleteManagedPrefixListOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteManagedPrefixListRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteManagedPrefixListOutput)
-	return ret0, ret1
-}
-
-// DeleteManagedPrefixListRequest indicates an expected call of DeleteManagedPrefixListRequest.
-func (mr *MockEC2APIMockRecorder) DeleteManagedPrefixListRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteManagedPrefixListRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteManagedPrefixListRequest), arg0)
-}
-
-// DeleteManagedPrefixListWithContext mocks base method.
-func (m *MockEC2API) DeleteManagedPrefixListWithContext(arg0 context.Context, arg1 *ec2.DeleteManagedPrefixListInput, arg2 ...request.Option) (*ec2.DeleteManagedPrefixListOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteManagedPrefixListWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteManagedPrefixListOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteManagedPrefixListWithContext indicates an expected call of DeleteManagedPrefixListWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteManagedPrefixListWithContext(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, "DeleteManagedPrefixListWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteManagedPrefixListWithContext), varargs...)
-}
-
-// DeleteNatGateway mocks base method.
-func (m *MockEC2API) DeleteNatGateway(arg0 *ec2.DeleteNatGatewayInput) (*ec2.DeleteNatGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteNatGateway", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteNatGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteNatGateway indicates an expected call of DeleteNatGateway.
-func (mr *MockEC2APIMockRecorder) DeleteNatGateway(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNatGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteNatGateway), arg0)
-}
-
-// DeleteNatGatewayRequest mocks base method.
-func (m *MockEC2API) DeleteNatGatewayRequest(arg0 *ec2.DeleteNatGatewayInput) (*request.Request, *ec2.DeleteNatGatewayOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteNatGatewayRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteNatGatewayOutput)
-	return ret0, ret1
-}
-
-// DeleteNatGatewayRequest indicates an expected call of DeleteNatGatewayRequest.
-func (mr *MockEC2APIMockRecorder) DeleteNatGatewayRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNatGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNatGatewayRequest), arg0)
-}
-
-// DeleteNatGatewayWithContext mocks base method.
-func (m *MockEC2API) DeleteNatGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteNatGatewayInput, arg2 ...request.Option) (*ec2.DeleteNatGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteNatGatewayWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteNatGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteNatGatewayWithContext indicates an expected call of DeleteNatGatewayWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteNatGatewayWithContext(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, "DeleteNatGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteNatGatewayWithContext), varargs...)
-}
-
-// DeleteNetworkAcl mocks base method.
-func (m *MockEC2API) DeleteNetworkAcl(arg0 *ec2.DeleteNetworkAclInput) (*ec2.DeleteNetworkAclOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteNetworkAcl", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteNetworkAclOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteNetworkAcl indicates an expected call of DeleteNetworkAcl.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkAcl(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAcl", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAcl), arg0)
-}
-
-// DeleteNetworkAclEntry mocks base method.
-func (m *MockEC2API) DeleteNetworkAclEntry(arg0 *ec2.DeleteNetworkAclEntryInput) (*ec2.DeleteNetworkAclEntryOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteNetworkAclEntry", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteNetworkAclEntryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteNetworkAclEntry indicates an expected call of DeleteNetworkAclEntry.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkAclEntry(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAclEntry", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAclEntry), arg0)
-}
-
-// DeleteNetworkAclEntryRequest mocks base method.
-func (m *MockEC2API) DeleteNetworkAclEntryRequest(arg0 *ec2.DeleteNetworkAclEntryInput) (*request.Request, *ec2.DeleteNetworkAclEntryOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteNetworkAclEntryRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteNetworkAclEntryOutput)
-	return ret0, ret1
-}
-
-// DeleteNetworkAclEntryRequest indicates an expected call of DeleteNetworkAclEntryRequest.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkAclEntryRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAclEntryRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAclEntryRequest), arg0)
-}
-
-// DeleteNetworkAclEntryWithContext mocks base method.
-func (m *MockEC2API) DeleteNetworkAclEntryWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkAclEntryInput, arg2 ...request.Option) (*ec2.DeleteNetworkAclEntryOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteNetworkAclEntryWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteNetworkAclEntryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteNetworkAclEntryWithContext indicates an expected call of DeleteNetworkAclEntryWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkAclEntryWithContext(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, "DeleteNetworkAclEntryWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAclEntryWithContext), varargs...)
-}
-
-// DeleteNetworkAclRequest mocks base method.
-func (m *MockEC2API) DeleteNetworkAclRequest(arg0 *ec2.DeleteNetworkAclInput) (*request.Request, *ec2.DeleteNetworkAclOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteNetworkAclRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteNetworkAclOutput)
-	return ret0, ret1
-}
-
-// DeleteNetworkAclRequest indicates an expected call of DeleteNetworkAclRequest.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkAclRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAclRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAclRequest), arg0)
-}
-
-// DeleteNetworkAclWithContext mocks base method.
-func (m *MockEC2API) DeleteNetworkAclWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkAclInput, arg2 ...request.Option) (*ec2.DeleteNetworkAclOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteNetworkAclWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteNetworkAclOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteNetworkAclWithContext indicates an expected call of DeleteNetworkAclWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkAclWithContext(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, "DeleteNetworkAclWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAclWithContext), varargs...)
-}
-
-// DeleteNetworkInsightsAccessScope mocks base method.
-func (m *MockEC2API) DeleteNetworkInsightsAccessScope(arg0 *ec2.DeleteNetworkInsightsAccessScopeInput) (*ec2.DeleteNetworkInsightsAccessScopeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteNetworkInsightsAccessScope", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsAccessScopeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteNetworkInsightsAccessScope indicates an expected call of DeleteNetworkInsightsAccessScope.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsAccessScope(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsAccessScope", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsAccessScope), arg0)
-}
-
-// DeleteNetworkInsightsAccessScopeAnalysis mocks base method.
-func (m *MockEC2API) DeleteNetworkInsightsAccessScopeAnalysis(arg0 *ec2.DeleteNetworkInsightsAccessScopeAnalysisInput) (*ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteNetworkInsightsAccessScopeAnalysis", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteNetworkInsightsAccessScopeAnalysis indicates an expected call of DeleteNetworkInsightsAccessScopeAnalysis.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsAccessScopeAnalysis(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsAccessScopeAnalysis", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsAccessScopeAnalysis), arg0)
-}
-
-// DeleteNetworkInsightsAccessScopeAnalysisRequest mocks base method.
-func (m *MockEC2API) DeleteNetworkInsightsAccessScopeAnalysisRequest(arg0 *ec2.DeleteNetworkInsightsAccessScopeAnalysisInput) (*request.Request, *ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteNetworkInsightsAccessScopeAnalysisRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput)
-	return ret0, ret1
-}
-
-// DeleteNetworkInsightsAccessScopeAnalysisRequest indicates an expected call of DeleteNetworkInsightsAccessScopeAnalysisRequest.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsAccessScopeAnalysisRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsAccessScopeAnalysisRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsAccessScopeAnalysisRequest), arg0)
-}
-
-// DeleteNetworkInsightsAccessScopeAnalysisWithContext mocks base method.
-func (m *MockEC2API) DeleteNetworkInsightsAccessScopeAnalysisWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkInsightsAccessScopeAnalysisInput, arg2 ...request.Option) (*ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteNetworkInsightsAccessScopeAnalysisWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteNetworkInsightsAccessScopeAnalysisWithContext indicates an expected call of DeleteNetworkInsightsAccessScopeAnalysisWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsAccessScopeAnalysisWithContext(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, "DeleteNetworkInsightsAccessScopeAnalysisWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsAccessScopeAnalysisWithContext), varargs...)
-}
-
-// DeleteNetworkInsightsAccessScopeRequest mocks base method.
-func (m *MockEC2API) DeleteNetworkInsightsAccessScopeRequest(arg0 *ec2.DeleteNetworkInsightsAccessScopeInput) (*request.Request, *ec2.DeleteNetworkInsightsAccessScopeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteNetworkInsightsAccessScopeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteNetworkInsightsAccessScopeOutput)
-	return ret0, ret1
-}
-
-// DeleteNetworkInsightsAccessScopeRequest indicates an expected call of DeleteNetworkInsightsAccessScopeRequest.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsAccessScopeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsAccessScopeRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsAccessScopeRequest), arg0)
-}
-
-// DeleteNetworkInsightsAccessScopeWithContext mocks base method.
-func (m *MockEC2API) DeleteNetworkInsightsAccessScopeWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkInsightsAccessScopeInput, arg2 ...request.Option) (*ec2.DeleteNetworkInsightsAccessScopeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteNetworkInsightsAccessScopeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsAccessScopeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteNetworkInsightsAccessScopeWithContext indicates an expected call of DeleteNetworkInsightsAccessScopeWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsAccessScopeWithContext(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, "DeleteNetworkInsightsAccessScopeWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsAccessScopeWithContext), varargs...)
-}
-
-// DeleteNetworkInsightsAnalysis mocks base method.
-func (m *MockEC2API) DeleteNetworkInsightsAnalysis(arg0 *ec2.DeleteNetworkInsightsAnalysisInput) (*ec2.DeleteNetworkInsightsAnalysisOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteNetworkInsightsAnalysis", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsAnalysisOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteNetworkInsightsAnalysis indicates an expected call of DeleteNetworkInsightsAnalysis.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsAnalysis(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsAnalysis", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsAnalysis), arg0)
-}
-
-// DeleteNetworkInsightsAnalysisRequest mocks base method.
-func (m *MockEC2API) DeleteNetworkInsightsAnalysisRequest(arg0 *ec2.DeleteNetworkInsightsAnalysisInput) (*request.Request, *ec2.DeleteNetworkInsightsAnalysisOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteNetworkInsightsAnalysisRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteNetworkInsightsAnalysisOutput)
-	return ret0, ret1
-}
-
-// DeleteNetworkInsightsAnalysisRequest indicates an expected call of DeleteNetworkInsightsAnalysisRequest.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsAnalysisRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsAnalysisRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsAnalysisRequest), arg0)
-}
-
-// DeleteNetworkInsightsAnalysisWithContext mocks base method.
-func (m *MockEC2API) DeleteNetworkInsightsAnalysisWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkInsightsAnalysisInput, arg2 ...request.Option) (*ec2.DeleteNetworkInsightsAnalysisOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteNetworkInsightsAnalysisWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsAnalysisOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteNetworkInsightsAnalysisWithContext indicates an expected call of DeleteNetworkInsightsAnalysisWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsAnalysisWithContext(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, "DeleteNetworkInsightsAnalysisWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsAnalysisWithContext), varargs...)
-}
-
-// DeleteNetworkInsightsPath mocks base method.
-func (m *MockEC2API) DeleteNetworkInsightsPath(arg0 *ec2.DeleteNetworkInsightsPathInput) (*ec2.DeleteNetworkInsightsPathOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteNetworkInsightsPath", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsPathOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteNetworkInsightsPath indicates an expected call of DeleteNetworkInsightsPath.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsPath(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsPath", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsPath), arg0)
-}
-
-// DeleteNetworkInsightsPathRequest mocks base method.
-func (m *MockEC2API) DeleteNetworkInsightsPathRequest(arg0 *ec2.DeleteNetworkInsightsPathInput) (*request.Request, *ec2.DeleteNetworkInsightsPathOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteNetworkInsightsPathRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteNetworkInsightsPathOutput)
-	return ret0, ret1
-}
-
-// DeleteNetworkInsightsPathRequest indicates an expected call of DeleteNetworkInsightsPathRequest.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsPathRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsPathRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsPathRequest), arg0)
-}
-
-// DeleteNetworkInsightsPathWithContext mocks base method.
-func (m *MockEC2API) DeleteNetworkInsightsPathWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkInsightsPathInput, arg2 ...request.Option) (*ec2.DeleteNetworkInsightsPathOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteNetworkInsightsPathWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsPathOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteNetworkInsightsPathWithContext indicates an expected call of DeleteNetworkInsightsPathWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsPathWithContext(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, "DeleteNetworkInsightsPathWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsPathWithContext), varargs...)
-}
-
-// DeleteNetworkInterface mocks base method.
-func (m *MockEC2API) DeleteNetworkInterface(arg0 *ec2.DeleteNetworkInterfaceInput) (*ec2.DeleteNetworkInterfaceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteNetworkInterface", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteNetworkInterfaceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteNetworkInterface indicates an expected call of DeleteNetworkInterface.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkInterface(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterface", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterface), arg0)
-}
-
-// DeleteNetworkInterfacePermission mocks base method.
-func (m *MockEC2API) DeleteNetworkInterfacePermission(arg0 *ec2.DeleteNetworkInterfacePermissionInput) (*ec2.DeleteNetworkInterfacePermissionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteNetworkInterfacePermission", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteNetworkInterfacePermissionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteNetworkInterfacePermission indicates an expected call of DeleteNetworkInterfacePermission.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkInterfacePermission(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterfacePermission", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterfacePermission), arg0)
-}
-
-// DeleteNetworkInterfacePermissionRequest mocks base method.
-func (m *MockEC2API) DeleteNetworkInterfacePermissionRequest(arg0 *ec2.DeleteNetworkInterfacePermissionInput) (*request.Request, *ec2.DeleteNetworkInterfacePermissionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteNetworkInterfacePermissionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteNetworkInterfacePermissionOutput)
-	return ret0, ret1
-}
-
-// DeleteNetworkInterfacePermissionRequest indicates an expected call of DeleteNetworkInterfacePermissionRequest.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkInterfacePermissionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterfacePermissionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterfacePermissionRequest), arg0)
-}
-
-// DeleteNetworkInterfacePermissionWithContext mocks base method.
-func (m *MockEC2API) DeleteNetworkInterfacePermissionWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkInterfacePermissionInput, arg2 ...request.Option) (*ec2.DeleteNetworkInterfacePermissionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteNetworkInterfacePermissionWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteNetworkInterfacePermissionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteNetworkInterfacePermissionWithContext indicates an expected call of DeleteNetworkInterfacePermissionWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkInterfacePermissionWithContext(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, "DeleteNetworkInterfacePermissionWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterfacePermissionWithContext), varargs...)
-}
-
-// DeleteNetworkInterfaceRequest mocks base method.
-func (m *MockEC2API) DeleteNetworkInterfaceRequest(arg0 *ec2.DeleteNetworkInterfaceInput) (*request.Request, *ec2.DeleteNetworkInterfaceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteNetworkInterfaceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteNetworkInterfaceOutput)
-	return ret0, ret1
-}
-
-// DeleteNetworkInterfaceRequest indicates an expected call of DeleteNetworkInterfaceRequest.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkInterfaceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterfaceRequest), arg0)
-}
-
-// DeleteNetworkInterfaceWithContext mocks base method.
-func (m *MockEC2API) DeleteNetworkInterfaceWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkInterfaceInput, arg2 ...request.Option) (*ec2.DeleteNetworkInterfaceOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteNetworkInterfaceWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteNetworkInterfaceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteNetworkInterfaceWithContext indicates an expected call of DeleteNetworkInterfaceWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteNetworkInterfaceWithContext(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, "DeleteNetworkInterfaceWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterfaceWithContext), varargs...)
-}
-
-// DeletePlacementGroup mocks base method.
-func (m *MockEC2API) DeletePlacementGroup(arg0 *ec2.DeletePlacementGroupInput) (*ec2.DeletePlacementGroupOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeletePlacementGroup", arg0)
-	ret0, _ := ret[0].(*ec2.DeletePlacementGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeletePlacementGroup indicates an expected call of DeletePlacementGroup.
-func (mr *MockEC2APIMockRecorder) DeletePlacementGroup(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePlacementGroup", reflect.TypeOf((*MockEC2API)(nil).DeletePlacementGroup), arg0)
-}
-
-// DeletePlacementGroupRequest mocks base method.
-func (m *MockEC2API) DeletePlacementGroupRequest(arg0 *ec2.DeletePlacementGroupInput) (*request.Request, *ec2.DeletePlacementGroupOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeletePlacementGroupRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeletePlacementGroupOutput)
-	return ret0, ret1
-}
-
-// DeletePlacementGroupRequest indicates an expected call of DeletePlacementGroupRequest.
-func (mr *MockEC2APIMockRecorder) DeletePlacementGroupRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePlacementGroupRequest", reflect.TypeOf((*MockEC2API)(nil).DeletePlacementGroupRequest), arg0)
-}
-
-// DeletePlacementGroupWithContext mocks base method.
-func (m *MockEC2API) DeletePlacementGroupWithContext(arg0 context.Context, arg1 *ec2.DeletePlacementGroupInput, arg2 ...request.Option) (*ec2.DeletePlacementGroupOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeletePlacementGroupWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeletePlacementGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeletePlacementGroupWithContext indicates an expected call of DeletePlacementGroupWithContext.
-func (mr *MockEC2APIMockRecorder) DeletePlacementGroupWithContext(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, "DeletePlacementGroupWithContext", reflect.TypeOf((*MockEC2API)(nil).DeletePlacementGroupWithContext), varargs...)
-}
-
-// DeletePublicIpv4Pool mocks base method.
-func (m *MockEC2API) DeletePublicIpv4Pool(arg0 *ec2.DeletePublicIpv4PoolInput) (*ec2.DeletePublicIpv4PoolOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeletePublicIpv4Pool", arg0)
-	ret0, _ := ret[0].(*ec2.DeletePublicIpv4PoolOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeletePublicIpv4Pool indicates an expected call of DeletePublicIpv4Pool.
-func (mr *MockEC2APIMockRecorder) DeletePublicIpv4Pool(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePublicIpv4Pool", reflect.TypeOf((*MockEC2API)(nil).DeletePublicIpv4Pool), arg0)
-}
-
-// DeletePublicIpv4PoolRequest mocks base method.
-func (m *MockEC2API) DeletePublicIpv4PoolRequest(arg0 *ec2.DeletePublicIpv4PoolInput) (*request.Request, *ec2.DeletePublicIpv4PoolOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeletePublicIpv4PoolRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeletePublicIpv4PoolOutput)
-	return ret0, ret1
-}
-
-// DeletePublicIpv4PoolRequest indicates an expected call of DeletePublicIpv4PoolRequest.
-func (mr *MockEC2APIMockRecorder) DeletePublicIpv4PoolRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePublicIpv4PoolRequest", reflect.TypeOf((*MockEC2API)(nil).DeletePublicIpv4PoolRequest), arg0)
-}
-
-// DeletePublicIpv4PoolWithContext mocks base method.
-func (m *MockEC2API) DeletePublicIpv4PoolWithContext(arg0 context.Context, arg1 *ec2.DeletePublicIpv4PoolInput, arg2 ...request.Option) (*ec2.DeletePublicIpv4PoolOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeletePublicIpv4PoolWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeletePublicIpv4PoolOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeletePublicIpv4PoolWithContext indicates an expected call of DeletePublicIpv4PoolWithContext.
-func (mr *MockEC2APIMockRecorder) DeletePublicIpv4PoolWithContext(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, "DeletePublicIpv4PoolWithContext", reflect.TypeOf((*MockEC2API)(nil).DeletePublicIpv4PoolWithContext), varargs...)
-}
-
-// DeleteQueuedReservedInstances mocks base method.
-func (m *MockEC2API) DeleteQueuedReservedInstances(arg0 *ec2.DeleteQueuedReservedInstancesInput) (*ec2.DeleteQueuedReservedInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteQueuedReservedInstances", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteQueuedReservedInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteQueuedReservedInstances indicates an expected call of DeleteQueuedReservedInstances.
-func (mr *MockEC2APIMockRecorder) DeleteQueuedReservedInstances(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueuedReservedInstances", reflect.TypeOf((*MockEC2API)(nil).DeleteQueuedReservedInstances), arg0)
-}
-
-// DeleteQueuedReservedInstancesRequest mocks base method.
-func (m *MockEC2API) DeleteQueuedReservedInstancesRequest(arg0 *ec2.DeleteQueuedReservedInstancesInput) (*request.Request, *ec2.DeleteQueuedReservedInstancesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteQueuedReservedInstancesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteQueuedReservedInstancesOutput)
-	return ret0, ret1
-}
-
-// DeleteQueuedReservedInstancesRequest indicates an expected call of DeleteQueuedReservedInstancesRequest.
-func (mr *MockEC2APIMockRecorder) DeleteQueuedReservedInstancesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueuedReservedInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteQueuedReservedInstancesRequest), arg0)
-}
-
-// DeleteQueuedReservedInstancesWithContext mocks base method.
-func (m *MockEC2API) DeleteQueuedReservedInstancesWithContext(arg0 context.Context, arg1 *ec2.DeleteQueuedReservedInstancesInput, arg2 ...request.Option) (*ec2.DeleteQueuedReservedInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteQueuedReservedInstancesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteQueuedReservedInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteQueuedReservedInstancesWithContext indicates an expected call of DeleteQueuedReservedInstancesWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteQueuedReservedInstancesWithContext(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, "DeleteQueuedReservedInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteQueuedReservedInstancesWithContext), varargs...)
-}
-
-// DeleteRoute mocks base method.
-func (m *MockEC2API) DeleteRoute(arg0 *ec2.DeleteRouteInput) (*ec2.DeleteRouteOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteRoute", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteRoute indicates an expected call of DeleteRoute.
-func (mr *MockEC2APIMockRecorder) DeleteRoute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteRoute), arg0)
-}
-
-// DeleteRouteRequest mocks base method.
-func (m *MockEC2API) DeleteRouteRequest(arg0 *ec2.DeleteRouteInput) (*request.Request, *ec2.DeleteRouteOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteRouteRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteRouteOutput)
-	return ret0, ret1
-}
-
-// DeleteRouteRequest indicates an expected call of DeleteRouteRequest.
-func (mr *MockEC2APIMockRecorder) DeleteRouteRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteRouteRequest), arg0)
-}
-
-// DeleteRouteTable mocks base method.
-func (m *MockEC2API) DeleteRouteTable(arg0 *ec2.DeleteRouteTableInput) (*ec2.DeleteRouteTableOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteRouteTable", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteRouteTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteRouteTable indicates an expected call of DeleteRouteTable.
-func (mr *MockEC2APIMockRecorder) DeleteRouteTable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouteTable", reflect.TypeOf((*MockEC2API)(nil).DeleteRouteTable), arg0)
-}
-
-// DeleteRouteTableRequest mocks base method.
-func (m *MockEC2API) DeleteRouteTableRequest(arg0 *ec2.DeleteRouteTableInput) (*request.Request, *ec2.DeleteRouteTableOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteRouteTableRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteRouteTableOutput)
-	return ret0, ret1
-}
-
-// DeleteRouteTableRequest indicates an expected call of DeleteRouteTableRequest.
-func (mr *MockEC2APIMockRecorder) DeleteRouteTableRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteRouteTableRequest), arg0)
-}
-
-// DeleteRouteTableWithContext mocks base method.
-func (m *MockEC2API) DeleteRouteTableWithContext(arg0 context.Context, arg1 *ec2.DeleteRouteTableInput, arg2 ...request.Option) (*ec2.DeleteRouteTableOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteRouteTableWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteRouteTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteRouteTableWithContext indicates an expected call of DeleteRouteTableWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteRouteTableWithContext(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, "DeleteRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteRouteTableWithContext), varargs...)
-}
-
-// DeleteRouteWithContext mocks base method.
-func (m *MockEC2API) DeleteRouteWithContext(arg0 context.Context, arg1 *ec2.DeleteRouteInput, arg2 ...request.Option) (*ec2.DeleteRouteOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteRouteWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteRouteWithContext indicates an expected call of DeleteRouteWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteRouteWithContext(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, "DeleteRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteRouteWithContext), varargs...)
-}
-
-// DeleteSecurityGroup mocks base method.
-func (m *MockEC2API) DeleteSecurityGroup(arg0 *ec2.DeleteSecurityGroupInput) (*ec2.DeleteSecurityGroupOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteSecurityGroup", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteSecurityGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteSecurityGroup indicates an expected call of DeleteSecurityGroup.
-func (mr *MockEC2APIMockRecorder) DeleteSecurityGroup(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroup", reflect.TypeOf((*MockEC2API)(nil).DeleteSecurityGroup), arg0)
-}
-
-// DeleteSecurityGroupRequest mocks base method.
-func (m *MockEC2API) DeleteSecurityGroupRequest(arg0 *ec2.DeleteSecurityGroupInput) (*request.Request, *ec2.DeleteSecurityGroupOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteSecurityGroupRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteSecurityGroupOutput)
-	return ret0, ret1
-}
-
-// DeleteSecurityGroupRequest indicates an expected call of DeleteSecurityGroupRequest.
-func (mr *MockEC2APIMockRecorder) DeleteSecurityGroupRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroupRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteSecurityGroupRequest), arg0)
-}
-
-// DeleteSecurityGroupWithContext mocks base method.
-func (m *MockEC2API) DeleteSecurityGroupWithContext(arg0 context.Context, arg1 *ec2.DeleteSecurityGroupInput, arg2 ...request.Option) (*ec2.DeleteSecurityGroupOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteSecurityGroupWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteSecurityGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteSecurityGroupWithContext indicates an expected call of DeleteSecurityGroupWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteSecurityGroupWithContext(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, "DeleteSecurityGroupWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteSecurityGroupWithContext), varargs...)
-}
-
-// DeleteSnapshot mocks base method.
-func (m *MockEC2API) DeleteSnapshot(arg0 *ec2.DeleteSnapshotInput) (*ec2.DeleteSnapshotOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteSnapshot", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteSnapshotOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteSnapshot indicates an expected call of DeleteSnapshot.
-func (mr *MockEC2APIMockRecorder) DeleteSnapshot(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshot", reflect.TypeOf((*MockEC2API)(nil).DeleteSnapshot), arg0)
-}
-
-// DeleteSnapshotRequest mocks base method.
-func (m *MockEC2API) DeleteSnapshotRequest(arg0 *ec2.DeleteSnapshotInput) (*request.Request, *ec2.DeleteSnapshotOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteSnapshotRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteSnapshotOutput)
-	return ret0, ret1
-}
-
-// DeleteSnapshotRequest indicates an expected call of DeleteSnapshotRequest.
-func (mr *MockEC2APIMockRecorder) DeleteSnapshotRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteSnapshotRequest), arg0)
-}
-
-// DeleteSnapshotWithContext mocks base method.
-func (m *MockEC2API) DeleteSnapshotWithContext(arg0 context.Context, arg1 *ec2.DeleteSnapshotInput, arg2 ...request.Option) (*ec2.DeleteSnapshotOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteSnapshotWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteSnapshotOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteSnapshotWithContext indicates an expected call of DeleteSnapshotWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteSnapshotWithContext(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, "DeleteSnapshotWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteSnapshotWithContext), varargs...)
-}
-
-// DeleteSpotDatafeedSubscription mocks base method.
-func (m *MockEC2API) DeleteSpotDatafeedSubscription(arg0 *ec2.DeleteSpotDatafeedSubscriptionInput) (*ec2.DeleteSpotDatafeedSubscriptionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteSpotDatafeedSubscription", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteSpotDatafeedSubscriptionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteSpotDatafeedSubscription indicates an expected call of DeleteSpotDatafeedSubscription.
-func (mr *MockEC2APIMockRecorder) DeleteSpotDatafeedSubscription(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSpotDatafeedSubscription", reflect.TypeOf((*MockEC2API)(nil).DeleteSpotDatafeedSubscription), arg0)
-}
-
-// DeleteSpotDatafeedSubscriptionRequest mocks base method.
-func (m *MockEC2API) DeleteSpotDatafeedSubscriptionRequest(arg0 *ec2.DeleteSpotDatafeedSubscriptionInput) (*request.Request, *ec2.DeleteSpotDatafeedSubscriptionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteSpotDatafeedSubscriptionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteSpotDatafeedSubscriptionOutput)
-	return ret0, ret1
-}
-
-// DeleteSpotDatafeedSubscriptionRequest indicates an expected call of DeleteSpotDatafeedSubscriptionRequest.
-func (mr *MockEC2APIMockRecorder) DeleteSpotDatafeedSubscriptionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSpotDatafeedSubscriptionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteSpotDatafeedSubscriptionRequest), arg0)
-}
-
-// DeleteSpotDatafeedSubscriptionWithContext mocks base method.
-func (m *MockEC2API) DeleteSpotDatafeedSubscriptionWithContext(arg0 context.Context, arg1 *ec2.DeleteSpotDatafeedSubscriptionInput, arg2 ...request.Option) (*ec2.DeleteSpotDatafeedSubscriptionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteSpotDatafeedSubscriptionWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteSpotDatafeedSubscriptionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteSpotDatafeedSubscriptionWithContext indicates an expected call of DeleteSpotDatafeedSubscriptionWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteSpotDatafeedSubscriptionWithContext(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, "DeleteSpotDatafeedSubscriptionWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteSpotDatafeedSubscriptionWithContext), varargs...)
-}
-
-// DeleteSubnet mocks base method.
-func (m *MockEC2API) DeleteSubnet(arg0 *ec2.DeleteSubnetInput) (*ec2.DeleteSubnetOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteSubnet", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteSubnetOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteSubnet indicates an expected call of DeleteSubnet.
-func (mr *MockEC2APIMockRecorder) DeleteSubnet(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubnet", reflect.TypeOf((*MockEC2API)(nil).DeleteSubnet), arg0)
-}
-
-// DeleteSubnetCidrReservation mocks base method.
-func (m *MockEC2API) DeleteSubnetCidrReservation(arg0 *ec2.DeleteSubnetCidrReservationInput) (*ec2.DeleteSubnetCidrReservationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteSubnetCidrReservation", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteSubnetCidrReservationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteSubnetCidrReservation indicates an expected call of DeleteSubnetCidrReservation.
-func (mr *MockEC2APIMockRecorder) DeleteSubnetCidrReservation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubnetCidrReservation", reflect.TypeOf((*MockEC2API)(nil).DeleteSubnetCidrReservation), arg0)
-}
-
-// DeleteSubnetCidrReservationRequest mocks base method.
-func (m *MockEC2API) DeleteSubnetCidrReservationRequest(arg0 *ec2.DeleteSubnetCidrReservationInput) (*request.Request, *ec2.DeleteSubnetCidrReservationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteSubnetCidrReservationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteSubnetCidrReservationOutput)
-	return ret0, ret1
-}
-
-// DeleteSubnetCidrReservationRequest indicates an expected call of DeleteSubnetCidrReservationRequest.
-func (mr *MockEC2APIMockRecorder) DeleteSubnetCidrReservationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubnetCidrReservationRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteSubnetCidrReservationRequest), arg0)
-}
-
-// DeleteSubnetCidrReservationWithContext mocks base method.
-func (m *MockEC2API) DeleteSubnetCidrReservationWithContext(arg0 context.Context, arg1 *ec2.DeleteSubnetCidrReservationInput, arg2 ...request.Option) (*ec2.DeleteSubnetCidrReservationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteSubnetCidrReservationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteSubnetCidrReservationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteSubnetCidrReservationWithContext indicates an expected call of DeleteSubnetCidrReservationWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteSubnetCidrReservationWithContext(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, "DeleteSubnetCidrReservationWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteSubnetCidrReservationWithContext), varargs...)
-}
-
-// DeleteSubnetRequest mocks base method.
-func (m *MockEC2API) DeleteSubnetRequest(arg0 *ec2.DeleteSubnetInput) (*request.Request, *ec2.DeleteSubnetOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteSubnetRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteSubnetOutput)
-	return ret0, ret1
-}
-
-// DeleteSubnetRequest indicates an expected call of DeleteSubnetRequest.
-func (mr *MockEC2APIMockRecorder) DeleteSubnetRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubnetRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteSubnetRequest), arg0)
-}
-
-// DeleteSubnetWithContext mocks base method.
-func (m *MockEC2API) DeleteSubnetWithContext(arg0 context.Context, arg1 *ec2.DeleteSubnetInput, arg2 ...request.Option) (*ec2.DeleteSubnetOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteSubnetWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteSubnetOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteSubnetWithContext indicates an expected call of DeleteSubnetWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteSubnetWithContext(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, "DeleteSubnetWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteSubnetWithContext), varargs...)
-}
-
-// DeleteTags mocks base method.
-func (m *MockEC2API) DeleteTags(arg0 *ec2.DeleteTagsInput) (*ec2.DeleteTagsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTags", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteTagsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTags indicates an expected call of DeleteTags.
-func (mr *MockEC2APIMockRecorder) DeleteTags(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTags", reflect.TypeOf((*MockEC2API)(nil).DeleteTags), arg0)
-}
-
-// DeleteTagsRequest mocks base method.
-func (m *MockEC2API) DeleteTagsRequest(arg0 *ec2.DeleteTagsInput) (*request.Request, *ec2.DeleteTagsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTagsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteTagsOutput)
-	return ret0, ret1
-}
-
-// DeleteTagsRequest indicates an expected call of DeleteTagsRequest.
-func (mr *MockEC2APIMockRecorder) DeleteTagsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTagsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTagsRequest), arg0)
-}
-
-// DeleteTagsWithContext mocks base method.
-func (m *MockEC2API) DeleteTagsWithContext(arg0 context.Context, arg1 *ec2.DeleteTagsInput, arg2 ...request.Option) (*ec2.DeleteTagsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteTagsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteTagsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTagsWithContext indicates an expected call of DeleteTagsWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTagsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTagsWithContext), varargs...)
-}
-
-// DeleteTrafficMirrorFilter mocks base method.
-func (m *MockEC2API) DeleteTrafficMirrorFilter(arg0 *ec2.DeleteTrafficMirrorFilterInput) (*ec2.DeleteTrafficMirrorFilterOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilter", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorFilterOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTrafficMirrorFilter indicates an expected call of DeleteTrafficMirrorFilter.
-func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorFilter(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilter", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilter), arg0)
-}
-
-// DeleteTrafficMirrorFilterRequest mocks base method.
-func (m *MockEC2API) DeleteTrafficMirrorFilterRequest(arg0 *ec2.DeleteTrafficMirrorFilterInput) (*request.Request, *ec2.DeleteTrafficMirrorFilterOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteTrafficMirrorFilterOutput)
-	return ret0, ret1
-}
-
-// DeleteTrafficMirrorFilterRequest indicates an expected call of DeleteTrafficMirrorFilterRequest.
-func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorFilterRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilterRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilterRequest), arg0)
-}
-
-// DeleteTrafficMirrorFilterRule mocks base method.
-func (m *MockEC2API) DeleteTrafficMirrorFilterRule(arg0 *ec2.DeleteTrafficMirrorFilterRuleInput) (*ec2.DeleteTrafficMirrorFilterRuleOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterRule", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorFilterRuleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTrafficMirrorFilterRule indicates an expected call of DeleteTrafficMirrorFilterRule.
-func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorFilterRule(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilterRule", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilterRule), arg0)
-}
-
-// DeleteTrafficMirrorFilterRuleRequest mocks base method.
-func (m *MockEC2API) DeleteTrafficMirrorFilterRuleRequest(arg0 *ec2.DeleteTrafficMirrorFilterRuleInput) (*request.Request, *ec2.DeleteTrafficMirrorFilterRuleOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterRuleRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteTrafficMirrorFilterRuleOutput)
-	return ret0, ret1
-}
-
-// DeleteTrafficMirrorFilterRuleRequest indicates an expected call of DeleteTrafficMirrorFilterRuleRequest.
-func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorFilterRuleRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilterRuleRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilterRuleRequest), arg0)
-}
-
-// DeleteTrafficMirrorFilterRuleWithContext mocks base method.
-func (m *MockEC2API) DeleteTrafficMirrorFilterRuleWithContext(arg0 context.Context, arg1 *ec2.DeleteTrafficMirrorFilterRuleInput, arg2 ...request.Option) (*ec2.DeleteTrafficMirrorFilterRuleOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterRuleWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorFilterRuleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTrafficMirrorFilterRuleWithContext indicates an expected call of DeleteTrafficMirrorFilterRuleWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorFilterRuleWithContext(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, "DeleteTrafficMirrorFilterRuleWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilterRuleWithContext), varargs...)
-}
-
-// DeleteTrafficMirrorFilterWithContext mocks base method.
-func (m *MockEC2API) DeleteTrafficMirrorFilterWithContext(arg0 context.Context, arg1 *ec2.DeleteTrafficMirrorFilterInput, arg2 ...request.Option) (*ec2.DeleteTrafficMirrorFilterOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorFilterOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTrafficMirrorFilterWithContext indicates an expected call of DeleteTrafficMirrorFilterWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorFilterWithContext(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, "DeleteTrafficMirrorFilterWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilterWithContext), varargs...)
-}
-
-// DeleteTrafficMirrorSession mocks base method.
-func (m *MockEC2API) DeleteTrafficMirrorSession(arg0 *ec2.DeleteTrafficMirrorSessionInput) (*ec2.DeleteTrafficMirrorSessionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTrafficMirrorSession", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorSessionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTrafficMirrorSession indicates an expected call of DeleteTrafficMirrorSession.
-func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorSession(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorSession", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorSession), arg0)
-}
-
-// DeleteTrafficMirrorSessionRequest mocks base method.
-func (m *MockEC2API) DeleteTrafficMirrorSessionRequest(arg0 *ec2.DeleteTrafficMirrorSessionInput) (*request.Request, *ec2.DeleteTrafficMirrorSessionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTrafficMirrorSessionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteTrafficMirrorSessionOutput)
-	return ret0, ret1
-}
-
-// DeleteTrafficMirrorSessionRequest indicates an expected call of DeleteTrafficMirrorSessionRequest.
-func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorSessionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorSessionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorSessionRequest), arg0)
-}
-
-// DeleteTrafficMirrorSessionWithContext mocks base method.
-func (m *MockEC2API) DeleteTrafficMirrorSessionWithContext(arg0 context.Context, arg1 *ec2.DeleteTrafficMirrorSessionInput, arg2 ...request.Option) (*ec2.DeleteTrafficMirrorSessionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteTrafficMirrorSessionWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorSessionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTrafficMirrorSessionWithContext indicates an expected call of DeleteTrafficMirrorSessionWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorSessionWithContext(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, "DeleteTrafficMirrorSessionWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorSessionWithContext), varargs...)
-}
-
-// DeleteTrafficMirrorTarget mocks base method.
-func (m *MockEC2API) DeleteTrafficMirrorTarget(arg0 *ec2.DeleteTrafficMirrorTargetInput) (*ec2.DeleteTrafficMirrorTargetOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTrafficMirrorTarget", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorTargetOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTrafficMirrorTarget indicates an expected call of DeleteTrafficMirrorTarget.
-func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorTarget(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorTarget", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorTarget), arg0)
-}
-
-// DeleteTrafficMirrorTargetRequest mocks base method.
-func (m *MockEC2API) DeleteTrafficMirrorTargetRequest(arg0 *ec2.DeleteTrafficMirrorTargetInput) (*request.Request, *ec2.DeleteTrafficMirrorTargetOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTrafficMirrorTargetRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteTrafficMirrorTargetOutput)
-	return ret0, ret1
-}
-
-// DeleteTrafficMirrorTargetRequest indicates an expected call of DeleteTrafficMirrorTargetRequest.
-func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorTargetRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorTargetRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorTargetRequest), arg0)
-}
-
-// DeleteTrafficMirrorTargetWithContext mocks base method.
-func (m *MockEC2API) DeleteTrafficMirrorTargetWithContext(arg0 context.Context, arg1 *ec2.DeleteTrafficMirrorTargetInput, arg2 ...request.Option) (*ec2.DeleteTrafficMirrorTargetOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteTrafficMirrorTargetWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorTargetOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTrafficMirrorTargetWithContext indicates an expected call of DeleteTrafficMirrorTargetWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorTargetWithContext(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, "DeleteTrafficMirrorTargetWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorTargetWithContext), varargs...)
-}
-
-// DeleteTransitGateway mocks base method.
-func (m *MockEC2API) DeleteTransitGateway(arg0 *ec2.DeleteTransitGatewayInput) (*ec2.DeleteTransitGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTransitGateway", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTransitGateway indicates an expected call of DeleteTransitGateway.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGateway(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGateway), arg0)
-}
-
-// DeleteTransitGatewayConnect mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayConnect(arg0 *ec2.DeleteTransitGatewayConnectInput) (*ec2.DeleteTransitGatewayConnectOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayConnect", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayConnectOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayConnect indicates an expected call of DeleteTransitGatewayConnect.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayConnect(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayConnect", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayConnect), arg0)
-}
-
-// DeleteTransitGatewayConnectPeer mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayConnectPeer(arg0 *ec2.DeleteTransitGatewayConnectPeerInput) (*ec2.DeleteTransitGatewayConnectPeerOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayConnectPeer", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayConnectPeerOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayConnectPeer indicates an expected call of DeleteTransitGatewayConnectPeer.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayConnectPeer(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayConnectPeer", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayConnectPeer), arg0)
-}
-
-// DeleteTransitGatewayConnectPeerRequest mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayConnectPeerRequest(arg0 *ec2.DeleteTransitGatewayConnectPeerInput) (*request.Request, *ec2.DeleteTransitGatewayConnectPeerOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayConnectPeerRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteTransitGatewayConnectPeerOutput)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayConnectPeerRequest indicates an expected call of DeleteTransitGatewayConnectPeerRequest.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayConnectPeerRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayConnectPeerRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayConnectPeerRequest), arg0)
-}
-
-// DeleteTransitGatewayConnectPeerWithContext mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayConnectPeerWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayConnectPeerInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayConnectPeerOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayConnectPeerWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayConnectPeerOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayConnectPeerWithContext indicates an expected call of DeleteTransitGatewayConnectPeerWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayConnectPeerWithContext(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, "DeleteTransitGatewayConnectPeerWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayConnectPeerWithContext), varargs...)
-}
-
-// DeleteTransitGatewayConnectRequest mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayConnectRequest(arg0 *ec2.DeleteTransitGatewayConnectInput) (*request.Request, *ec2.DeleteTransitGatewayConnectOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayConnectRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteTransitGatewayConnectOutput)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayConnectRequest indicates an expected call of DeleteTransitGatewayConnectRequest.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayConnectRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayConnectRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayConnectRequest), arg0)
-}
-
-// DeleteTransitGatewayConnectWithContext mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayConnectWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayConnectInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayConnectOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayConnectWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayConnectOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayConnectWithContext indicates an expected call of DeleteTransitGatewayConnectWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayConnectWithContext(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, "DeleteTransitGatewayConnectWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayConnectWithContext), varargs...)
-}
-
-// DeleteTransitGatewayMulticastDomain mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayMulticastDomain(arg0 *ec2.DeleteTransitGatewayMulticastDomainInput) (*ec2.DeleteTransitGatewayMulticastDomainOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayMulticastDomain", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayMulticastDomainOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayMulticastDomain indicates an expected call of DeleteTransitGatewayMulticastDomain.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayMulticastDomain(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayMulticastDomain", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayMulticastDomain), arg0)
-}
-
-// DeleteTransitGatewayMulticastDomainRequest mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayMulticastDomainRequest(arg0 *ec2.DeleteTransitGatewayMulticastDomainInput) (*request.Request, *ec2.DeleteTransitGatewayMulticastDomainOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayMulticastDomainRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteTransitGatewayMulticastDomainOutput)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayMulticastDomainRequest indicates an expected call of DeleteTransitGatewayMulticastDomainRequest.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayMulticastDomainRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayMulticastDomainRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayMulticastDomainRequest), arg0)
-}
-
-// DeleteTransitGatewayMulticastDomainWithContext mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayMulticastDomainWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayMulticastDomainInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayMulticastDomainOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayMulticastDomainWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayMulticastDomainOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayMulticastDomainWithContext indicates an expected call of DeleteTransitGatewayMulticastDomainWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayMulticastDomainWithContext(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, "DeleteTransitGatewayMulticastDomainWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayMulticastDomainWithContext), varargs...)
-}
-
-// DeleteTransitGatewayPeeringAttachment mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayPeeringAttachment(arg0 *ec2.DeleteTransitGatewayPeeringAttachmentInput) (*ec2.DeleteTransitGatewayPeeringAttachmentOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayPeeringAttachment", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayPeeringAttachmentOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayPeeringAttachment indicates an expected call of DeleteTransitGatewayPeeringAttachment.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayPeeringAttachment(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPeeringAttachment", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayPeeringAttachment), arg0)
-}
-
-// DeleteTransitGatewayPeeringAttachmentRequest mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayPeeringAttachmentRequest(arg0 *ec2.DeleteTransitGatewayPeeringAttachmentInput) (*request.Request, *ec2.DeleteTransitGatewayPeeringAttachmentOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayPeeringAttachmentRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteTransitGatewayPeeringAttachmentOutput)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayPeeringAttachmentRequest indicates an expected call of DeleteTransitGatewayPeeringAttachmentRequest.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayPeeringAttachmentRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPeeringAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayPeeringAttachmentRequest), arg0)
-}
-
-// DeleteTransitGatewayPeeringAttachmentWithContext mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayPeeringAttachmentWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayPeeringAttachmentInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayPeeringAttachmentOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayPeeringAttachmentWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayPeeringAttachmentOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayPeeringAttachmentWithContext indicates an expected call of DeleteTransitGatewayPeeringAttachmentWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayPeeringAttachmentWithContext(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, "DeleteTransitGatewayPeeringAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayPeeringAttachmentWithContext), varargs...)
-}
-
-// DeleteTransitGatewayPolicyTable mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayPolicyTable(arg0 *ec2.DeleteTransitGatewayPolicyTableInput) (*ec2.DeleteTransitGatewayPolicyTableOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayPolicyTable", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayPolicyTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayPolicyTable indicates an expected call of DeleteTransitGatewayPolicyTable.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayPolicyTable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPolicyTable", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayPolicyTable), arg0)
-}
-
-// DeleteTransitGatewayPolicyTableRequest mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayPolicyTableRequest(arg0 *ec2.DeleteTransitGatewayPolicyTableInput) (*request.Request, *ec2.DeleteTransitGatewayPolicyTableOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayPolicyTableRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteTransitGatewayPolicyTableOutput)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayPolicyTableRequest indicates an expected call of DeleteTransitGatewayPolicyTableRequest.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayPolicyTableRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPolicyTableRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayPolicyTableRequest), arg0)
-}
-
-// DeleteTransitGatewayPolicyTableWithContext mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayPolicyTableWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayPolicyTableInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayPolicyTableOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayPolicyTableWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayPolicyTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayPolicyTableWithContext indicates an expected call of DeleteTransitGatewayPolicyTableWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayPolicyTableWithContext(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, "DeleteTransitGatewayPolicyTableWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayPolicyTableWithContext), varargs...)
-}
-
-// DeleteTransitGatewayPrefixListReference mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayPrefixListReference(arg0 *ec2.DeleteTransitGatewayPrefixListReferenceInput) (*ec2.DeleteTransitGatewayPrefixListReferenceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayPrefixListReference", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayPrefixListReferenceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayPrefixListReference indicates an expected call of DeleteTransitGatewayPrefixListReference.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayPrefixListReference(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPrefixListReference", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayPrefixListReference), arg0)
-}
-
-// DeleteTransitGatewayPrefixListReferenceRequest mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayPrefixListReferenceRequest(arg0 *ec2.DeleteTransitGatewayPrefixListReferenceInput) (*request.Request, *ec2.DeleteTransitGatewayPrefixListReferenceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayPrefixListReferenceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteTransitGatewayPrefixListReferenceOutput)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayPrefixListReferenceRequest indicates an expected call of DeleteTransitGatewayPrefixListReferenceRequest.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayPrefixListReferenceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPrefixListReferenceRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayPrefixListReferenceRequest), arg0)
-}
-
-// DeleteTransitGatewayPrefixListReferenceWithContext mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayPrefixListReferenceWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayPrefixListReferenceInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayPrefixListReferenceOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayPrefixListReferenceWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayPrefixListReferenceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayPrefixListReferenceWithContext indicates an expected call of DeleteTransitGatewayPrefixListReferenceWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayPrefixListReferenceWithContext(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, "DeleteTransitGatewayPrefixListReferenceWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayPrefixListReferenceWithContext), varargs...)
-}
-
-// DeleteTransitGatewayRequest mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayRequest(arg0 *ec2.DeleteTransitGatewayInput) (*request.Request, *ec2.DeleteTransitGatewayOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteTransitGatewayOutput)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayRequest indicates an expected call of DeleteTransitGatewayRequest.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRequest), arg0)
-}
-
-// DeleteTransitGatewayRoute mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayRoute(arg0 *ec2.DeleteTransitGatewayRouteInput) (*ec2.DeleteTransitGatewayRouteOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayRoute", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayRoute indicates an expected call of DeleteTransitGatewayRoute.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRoute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRoute), arg0)
-}
-
-// DeleteTransitGatewayRouteRequest mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayRouteRequest(arg0 *ec2.DeleteTransitGatewayRouteInput) (*request.Request, *ec2.DeleteTransitGatewayRouteOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteTransitGatewayRouteOutput)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayRouteRequest indicates an expected call of DeleteTransitGatewayRouteRequest.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRouteRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteRequest), arg0)
-}
-
-// DeleteTransitGatewayRouteTable mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayRouteTable(arg0 *ec2.DeleteTransitGatewayRouteTableInput) (*ec2.DeleteTransitGatewayRouteTableOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTable", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayRouteTable indicates an expected call of DeleteTransitGatewayRouteTable.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRouteTable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteTable), arg0)
-}
-
-// DeleteTransitGatewayRouteTableAnnouncement mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayRouteTableAnnouncement(arg0 *ec2.DeleteTransitGatewayRouteTableAnnouncementInput) (*ec2.DeleteTransitGatewayRouteTableAnnouncementOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTableAnnouncement", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteTableAnnouncementOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayRouteTableAnnouncement indicates an expected call of DeleteTransitGatewayRouteTableAnnouncement.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRouteTableAnnouncement(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteTableAnnouncement", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteTableAnnouncement), arg0)
-}
-
-// DeleteTransitGatewayRouteTableAnnouncementRequest mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayRouteTableAnnouncementRequest(arg0 *ec2.DeleteTransitGatewayRouteTableAnnouncementInput) (*request.Request, *ec2.DeleteTransitGatewayRouteTableAnnouncementOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTableAnnouncementRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteTransitGatewayRouteTableAnnouncementOutput)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayRouteTableAnnouncementRequest indicates an expected call of DeleteTransitGatewayRouteTableAnnouncementRequest.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRouteTableAnnouncementRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteTableAnnouncementRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteTableAnnouncementRequest), arg0)
-}
-
-// DeleteTransitGatewayRouteTableAnnouncementWithContext mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayRouteTableAnnouncementWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayRouteTableAnnouncementInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayRouteTableAnnouncementOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTableAnnouncementWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteTableAnnouncementOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayRouteTableAnnouncementWithContext indicates an expected call of DeleteTransitGatewayRouteTableAnnouncementWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRouteTableAnnouncementWithContext(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, "DeleteTransitGatewayRouteTableAnnouncementWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteTableAnnouncementWithContext), varargs...)
-}
-
-// DeleteTransitGatewayRouteTableRequest mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayRouteTableRequest(arg0 *ec2.DeleteTransitGatewayRouteTableInput) (*request.Request, *ec2.DeleteTransitGatewayRouteTableOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTableRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteTransitGatewayRouteTableOutput)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayRouteTableRequest indicates an expected call of DeleteTransitGatewayRouteTableRequest.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteTableRequest), arg0)
-}
-
-// DeleteTransitGatewayRouteTableWithContext mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayRouteTableWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayRouteTableInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayRouteTableOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTableWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayRouteTableWithContext indicates an expected call of DeleteTransitGatewayRouteTableWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRouteTableWithContext(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, "DeleteTransitGatewayRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteTableWithContext), varargs...)
-}
-
-// DeleteTransitGatewayRouteWithContext mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayRouteWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayRouteInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayRouteOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayRouteWithContext indicates an expected call of DeleteTransitGatewayRouteWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRouteWithContext(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, "DeleteTransitGatewayRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteWithContext), varargs...)
-}
-
-// DeleteTransitGatewayVpcAttachment mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayVpcAttachment(arg0 *ec2.DeleteTransitGatewayVpcAttachmentInput) (*ec2.DeleteTransitGatewayVpcAttachmentOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayVpcAttachment", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayVpcAttachmentOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayVpcAttachment indicates an expected call of DeleteTransitGatewayVpcAttachment.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayVpcAttachment), arg0)
-}
-
-// DeleteTransitGatewayVpcAttachmentRequest mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayVpcAttachmentRequest(arg0 *ec2.DeleteTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.DeleteTransitGatewayVpcAttachmentOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayVpcAttachmentRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteTransitGatewayVpcAttachmentOutput)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayVpcAttachmentRequest indicates an expected call of DeleteTransitGatewayVpcAttachmentRequest.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayVpcAttachmentRequest), arg0)
-}
-
-// DeleteTransitGatewayVpcAttachmentWithContext mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayVpcAttachmentWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayVpcAttachmentOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayVpcAttachmentWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayVpcAttachmentOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayVpcAttachmentWithContext indicates an expected call of DeleteTransitGatewayVpcAttachmentWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayVpcAttachmentWithContext(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, "DeleteTransitGatewayVpcAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayVpcAttachmentWithContext), varargs...)
-}
-
-// DeleteTransitGatewayWithContext mocks base method.
-func (m *MockEC2API) DeleteTransitGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteTransitGatewayWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteTransitGatewayWithContext indicates an expected call of DeleteTransitGatewayWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayWithContext(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, "DeleteTransitGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayWithContext), varargs...)
-}
-
-// DeleteVerifiedAccessEndpoint mocks base method.
-func (m *MockEC2API) DeleteVerifiedAccessEndpoint(arg0 *ec2.DeleteVerifiedAccessEndpointInput) (*ec2.DeleteVerifiedAccessEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVerifiedAccessEndpoint", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVerifiedAccessEndpoint indicates an expected call of DeleteVerifiedAccessEndpoint.
-func (mr *MockEC2APIMockRecorder) DeleteVerifiedAccessEndpoint(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessEndpoint", reflect.TypeOf((*MockEC2API)(nil).DeleteVerifiedAccessEndpoint), arg0)
-}
-
-// DeleteVerifiedAccessEndpointRequest mocks base method.
-func (m *MockEC2API) DeleteVerifiedAccessEndpointRequest(arg0 *ec2.DeleteVerifiedAccessEndpointInput) (*request.Request, *ec2.DeleteVerifiedAccessEndpointOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVerifiedAccessEndpointRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteVerifiedAccessEndpointOutput)
-	return ret0, ret1
-}
-
-// DeleteVerifiedAccessEndpointRequest indicates an expected call of DeleteVerifiedAccessEndpointRequest.
-func (mr *MockEC2APIMockRecorder) DeleteVerifiedAccessEndpointRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVerifiedAccessEndpointRequest), arg0)
-}
-
-// DeleteVerifiedAccessEndpointWithContext mocks base method.
-func (m *MockEC2API) DeleteVerifiedAccessEndpointWithContext(arg0 context.Context, arg1 *ec2.DeleteVerifiedAccessEndpointInput, arg2 ...request.Option) (*ec2.DeleteVerifiedAccessEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteVerifiedAccessEndpointWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVerifiedAccessEndpointWithContext indicates an expected call of DeleteVerifiedAccessEndpointWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteVerifiedAccessEndpointWithContext(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, "DeleteVerifiedAccessEndpointWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVerifiedAccessEndpointWithContext), varargs...)
-}
-
-// DeleteVerifiedAccessGroup mocks base method.
-func (m *MockEC2API) DeleteVerifiedAccessGroup(arg0 *ec2.DeleteVerifiedAccessGroupInput) (*ec2.DeleteVerifiedAccessGroupOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVerifiedAccessGroup", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVerifiedAccessGroup indicates an expected call of DeleteVerifiedAccessGroup.
-func (mr *MockEC2APIMockRecorder) DeleteVerifiedAccessGroup(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessGroup", reflect.TypeOf((*MockEC2API)(nil).DeleteVerifiedAccessGroup), arg0)
-}
-
-// DeleteVerifiedAccessGroupRequest mocks base method.
-func (m *MockEC2API) DeleteVerifiedAccessGroupRequest(arg0 *ec2.DeleteVerifiedAccessGroupInput) (*request.Request, *ec2.DeleteVerifiedAccessGroupOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVerifiedAccessGroupRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteVerifiedAccessGroupOutput)
-	return ret0, ret1
-}
-
-// DeleteVerifiedAccessGroupRequest indicates an expected call of DeleteVerifiedAccessGroupRequest.
-func (mr *MockEC2APIMockRecorder) DeleteVerifiedAccessGroupRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessGroupRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVerifiedAccessGroupRequest), arg0)
-}
-
-// DeleteVerifiedAccessGroupWithContext mocks base method.
-func (m *MockEC2API) DeleteVerifiedAccessGroupWithContext(arg0 context.Context, arg1 *ec2.DeleteVerifiedAccessGroupInput, arg2 ...request.Option) (*ec2.DeleteVerifiedAccessGroupOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteVerifiedAccessGroupWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVerifiedAccessGroupWithContext indicates an expected call of DeleteVerifiedAccessGroupWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteVerifiedAccessGroupWithContext(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, "DeleteVerifiedAccessGroupWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVerifiedAccessGroupWithContext), varargs...)
-}
-
-// DeleteVerifiedAccessInstance mocks base method.
-func (m *MockEC2API) DeleteVerifiedAccessInstance(arg0 *ec2.DeleteVerifiedAccessInstanceInput) (*ec2.DeleteVerifiedAccessInstanceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVerifiedAccessInstance", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessInstanceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVerifiedAccessInstance indicates an expected call of DeleteVerifiedAccessInstance.
-func (mr *MockEC2APIMockRecorder) DeleteVerifiedAccessInstance(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessInstance", reflect.TypeOf((*MockEC2API)(nil).DeleteVerifiedAccessInstance), arg0)
-}
-
-// DeleteVerifiedAccessInstanceRequest mocks base method.
-func (m *MockEC2API) DeleteVerifiedAccessInstanceRequest(arg0 *ec2.DeleteVerifiedAccessInstanceInput) (*request.Request, *ec2.DeleteVerifiedAccessInstanceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVerifiedAccessInstanceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteVerifiedAccessInstanceOutput)
-	return ret0, ret1
-}
-
-// DeleteVerifiedAccessInstanceRequest indicates an expected call of DeleteVerifiedAccessInstanceRequest.
-func (mr *MockEC2APIMockRecorder) DeleteVerifiedAccessInstanceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessInstanceRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVerifiedAccessInstanceRequest), arg0)
-}
-
-// DeleteVerifiedAccessInstanceWithContext mocks base method.
-func (m *MockEC2API) DeleteVerifiedAccessInstanceWithContext(arg0 context.Context, arg1 *ec2.DeleteVerifiedAccessInstanceInput, arg2 ...request.Option) (*ec2.DeleteVerifiedAccessInstanceOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteVerifiedAccessInstanceWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessInstanceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVerifiedAccessInstanceWithContext indicates an expected call of DeleteVerifiedAccessInstanceWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteVerifiedAccessInstanceWithContext(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, "DeleteVerifiedAccessInstanceWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVerifiedAccessInstanceWithContext), varargs...)
-}
-
-// DeleteVerifiedAccessTrustProvider mocks base method.
-func (m *MockEC2API) DeleteVerifiedAccessTrustProvider(arg0 *ec2.DeleteVerifiedAccessTrustProviderInput) (*ec2.DeleteVerifiedAccessTrustProviderOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVerifiedAccessTrustProvider", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessTrustProviderOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVerifiedAccessTrustProvider indicates an expected call of DeleteVerifiedAccessTrustProvider.
-func (mr *MockEC2APIMockRecorder) DeleteVerifiedAccessTrustProvider(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessTrustProvider", reflect.TypeOf((*MockEC2API)(nil).DeleteVerifiedAccessTrustProvider), arg0)
-}
-
-// DeleteVerifiedAccessTrustProviderRequest mocks base method.
-func (m *MockEC2API) DeleteVerifiedAccessTrustProviderRequest(arg0 *ec2.DeleteVerifiedAccessTrustProviderInput) (*request.Request, *ec2.DeleteVerifiedAccessTrustProviderOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVerifiedAccessTrustProviderRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteVerifiedAccessTrustProviderOutput)
-	return ret0, ret1
-}
-
-// DeleteVerifiedAccessTrustProviderRequest indicates an expected call of DeleteVerifiedAccessTrustProviderRequest.
-func (mr *MockEC2APIMockRecorder) DeleteVerifiedAccessTrustProviderRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessTrustProviderRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVerifiedAccessTrustProviderRequest), arg0)
-}
-
-// DeleteVerifiedAccessTrustProviderWithContext mocks base method.
-func (m *MockEC2API) DeleteVerifiedAccessTrustProviderWithContext(arg0 context.Context, arg1 *ec2.DeleteVerifiedAccessTrustProviderInput, arg2 ...request.Option) (*ec2.DeleteVerifiedAccessTrustProviderOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteVerifiedAccessTrustProviderWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessTrustProviderOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVerifiedAccessTrustProviderWithContext indicates an expected call of DeleteVerifiedAccessTrustProviderWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteVerifiedAccessTrustProviderWithContext(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, "DeleteVerifiedAccessTrustProviderWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVerifiedAccessTrustProviderWithContext), varargs...)
-}
-
-// DeleteVolume mocks base method.
-func (m *MockEC2API) DeleteVolume(arg0 *ec2.DeleteVolumeInput) (*ec2.DeleteVolumeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVolume", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteVolumeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVolume indicates an expected call of DeleteVolume.
-func (mr *MockEC2APIMockRecorder) DeleteVolume(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVolume", reflect.TypeOf((*MockEC2API)(nil).DeleteVolume), arg0)
-}
-
-// DeleteVolumeRequest mocks base method.
-func (m *MockEC2API) DeleteVolumeRequest(arg0 *ec2.DeleteVolumeInput) (*request.Request, *ec2.DeleteVolumeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVolumeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteVolumeOutput)
-	return ret0, ret1
-}
-
-// DeleteVolumeRequest indicates an expected call of DeleteVolumeRequest.
-func (mr *MockEC2APIMockRecorder) DeleteVolumeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVolumeRequest), arg0)
-}
-
-// DeleteVolumeWithContext mocks base method.
-func (m *MockEC2API) DeleteVolumeWithContext(arg0 context.Context, arg1 *ec2.DeleteVolumeInput, arg2 ...request.Option) (*ec2.DeleteVolumeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteVolumeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteVolumeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVolumeWithContext indicates an expected call of DeleteVolumeWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteVolumeWithContext(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, "DeleteVolumeWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVolumeWithContext), varargs...)
-}
-
-// DeleteVpc mocks base method.
-func (m *MockEC2API) DeleteVpc(arg0 *ec2.DeleteVpcInput) (*ec2.DeleteVpcOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVpc", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteVpcOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVpc indicates an expected call of DeleteVpc.
-func (mr *MockEC2APIMockRecorder) DeleteVpc(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpc", reflect.TypeOf((*MockEC2API)(nil).DeleteVpc), arg0)
-}
-
-// DeleteVpcEndpointConnectionNotifications mocks base method.
-func (m *MockEC2API) DeleteVpcEndpointConnectionNotifications(arg0 *ec2.DeleteVpcEndpointConnectionNotificationsInput) (*ec2.DeleteVpcEndpointConnectionNotificationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVpcEndpointConnectionNotifications", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteVpcEndpointConnectionNotificationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVpcEndpointConnectionNotifications indicates an expected call of DeleteVpcEndpointConnectionNotifications.
-func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointConnectionNotifications(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointConnectionNotifications", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointConnectionNotifications), arg0)
-}
-
-// DeleteVpcEndpointConnectionNotificationsRequest mocks base method.
-func (m *MockEC2API) DeleteVpcEndpointConnectionNotificationsRequest(arg0 *ec2.DeleteVpcEndpointConnectionNotificationsInput) (*request.Request, *ec2.DeleteVpcEndpointConnectionNotificationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVpcEndpointConnectionNotificationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteVpcEndpointConnectionNotificationsOutput)
-	return ret0, ret1
-}
-
-// DeleteVpcEndpointConnectionNotificationsRequest indicates an expected call of DeleteVpcEndpointConnectionNotificationsRequest.
-func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointConnectionNotificationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointConnectionNotificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointConnectionNotificationsRequest), arg0)
-}
-
-// DeleteVpcEndpointConnectionNotificationsWithContext mocks base method.
-func (m *MockEC2API) DeleteVpcEndpointConnectionNotificationsWithContext(arg0 context.Context, arg1 *ec2.DeleteVpcEndpointConnectionNotificationsInput, arg2 ...request.Option) (*ec2.DeleteVpcEndpointConnectionNotificationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteVpcEndpointConnectionNotificationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteVpcEndpointConnectionNotificationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVpcEndpointConnectionNotificationsWithContext indicates an expected call of DeleteVpcEndpointConnectionNotificationsWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointConnectionNotificationsWithContext(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, "DeleteVpcEndpointConnectionNotificationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointConnectionNotificationsWithContext), varargs...)
-}
-
-// DeleteVpcEndpointServiceConfigurations mocks base method.
-func (m *MockEC2API) DeleteVpcEndpointServiceConfigurations(arg0 *ec2.DeleteVpcEndpointServiceConfigurationsInput) (*ec2.DeleteVpcEndpointServiceConfigurationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVpcEndpointServiceConfigurations", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteVpcEndpointServiceConfigurationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVpcEndpointServiceConfigurations indicates an expected call of DeleteVpcEndpointServiceConfigurations.
-func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointServiceConfigurations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointServiceConfigurations", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointServiceConfigurations), arg0)
-}
-
-// DeleteVpcEndpointServiceConfigurationsRequest mocks base method.
-func (m *MockEC2API) DeleteVpcEndpointServiceConfigurationsRequest(arg0 *ec2.DeleteVpcEndpointServiceConfigurationsInput) (*request.Request, *ec2.DeleteVpcEndpointServiceConfigurationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVpcEndpointServiceConfigurationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteVpcEndpointServiceConfigurationsOutput)
-	return ret0, ret1
-}
-
-// DeleteVpcEndpointServiceConfigurationsRequest indicates an expected call of DeleteVpcEndpointServiceConfigurationsRequest.
-func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointServiceConfigurationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointServiceConfigurationsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointServiceConfigurationsRequest), arg0)
-}
-
-// DeleteVpcEndpointServiceConfigurationsWithContext mocks base method.
-func (m *MockEC2API) DeleteVpcEndpointServiceConfigurationsWithContext(arg0 context.Context, arg1 *ec2.DeleteVpcEndpointServiceConfigurationsInput, arg2 ...request.Option) (*ec2.DeleteVpcEndpointServiceConfigurationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteVpcEndpointServiceConfigurationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteVpcEndpointServiceConfigurationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVpcEndpointServiceConfigurationsWithContext indicates an expected call of DeleteVpcEndpointServiceConfigurationsWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointServiceConfigurationsWithContext(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, "DeleteVpcEndpointServiceConfigurationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointServiceConfigurationsWithContext), varargs...)
-}
-
-// DeleteVpcEndpoints mocks base method.
-func (m *MockEC2API) DeleteVpcEndpoints(arg0 *ec2.DeleteVpcEndpointsInput) (*ec2.DeleteVpcEndpointsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVpcEndpoints", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteVpcEndpointsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVpcEndpoints indicates an expected call of DeleteVpcEndpoints.
-func (mr *MockEC2APIMockRecorder) DeleteVpcEndpoints(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpoints", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpoints), arg0)
-}
-
-// DeleteVpcEndpointsRequest mocks base method.
-func (m *MockEC2API) DeleteVpcEndpointsRequest(arg0 *ec2.DeleteVpcEndpointsInput) (*request.Request, *ec2.DeleteVpcEndpointsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVpcEndpointsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteVpcEndpointsOutput)
-	return ret0, ret1
-}
-
-// DeleteVpcEndpointsRequest indicates an expected call of DeleteVpcEndpointsRequest.
-func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointsRequest), arg0)
-}
-
-// DeleteVpcEndpointsWithContext mocks base method.
-func (m *MockEC2API) DeleteVpcEndpointsWithContext(arg0 context.Context, arg1 *ec2.DeleteVpcEndpointsInput, arg2 ...request.Option) (*ec2.DeleteVpcEndpointsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteVpcEndpointsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteVpcEndpointsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVpcEndpointsWithContext indicates an expected call of DeleteVpcEndpointsWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointsWithContext(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, "DeleteVpcEndpointsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointsWithContext), varargs...)
-}
-
-// DeleteVpcPeeringConnection mocks base method.
-func (m *MockEC2API) DeleteVpcPeeringConnection(arg0 *ec2.DeleteVpcPeeringConnectionInput) (*ec2.DeleteVpcPeeringConnectionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVpcPeeringConnection", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteVpcPeeringConnectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVpcPeeringConnection indicates an expected call of DeleteVpcPeeringConnection.
-func (mr *MockEC2APIMockRecorder) DeleteVpcPeeringConnection(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcPeeringConnection", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcPeeringConnection), arg0)
-}
-
-// DeleteVpcPeeringConnectionRequest mocks base method.
-func (m *MockEC2API) DeleteVpcPeeringConnectionRequest(arg0 *ec2.DeleteVpcPeeringConnectionInput) (*request.Request, *ec2.DeleteVpcPeeringConnectionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVpcPeeringConnectionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteVpcPeeringConnectionOutput)
-	return ret0, ret1
-}
-
-// DeleteVpcPeeringConnectionRequest indicates an expected call of DeleteVpcPeeringConnectionRequest.
-func (mr *MockEC2APIMockRecorder) DeleteVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcPeeringConnectionRequest), arg0)
-}
-
-// DeleteVpcPeeringConnectionWithContext mocks base method.
-func (m *MockEC2API) DeleteVpcPeeringConnectionWithContext(arg0 context.Context, arg1 *ec2.DeleteVpcPeeringConnectionInput, arg2 ...request.Option) (*ec2.DeleteVpcPeeringConnectionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteVpcPeeringConnectionWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteVpcPeeringConnectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVpcPeeringConnectionWithContext indicates an expected call of DeleteVpcPeeringConnectionWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteVpcPeeringConnectionWithContext(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, "DeleteVpcPeeringConnectionWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcPeeringConnectionWithContext), varargs...)
-}
-
-// DeleteVpcRequest mocks base method.
-func (m *MockEC2API) DeleteVpcRequest(arg0 *ec2.DeleteVpcInput) (*request.Request, *ec2.DeleteVpcOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVpcRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteVpcOutput)
-	return ret0, ret1
-}
-
-// DeleteVpcRequest indicates an expected call of DeleteVpcRequest.
-func (mr *MockEC2APIMockRecorder) DeleteVpcRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcRequest), arg0)
-}
-
-// DeleteVpcWithContext mocks base method.
-func (m *MockEC2API) DeleteVpcWithContext(arg0 context.Context, arg1 *ec2.DeleteVpcInput, arg2 ...request.Option) (*ec2.DeleteVpcOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteVpcWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteVpcOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVpcWithContext indicates an expected call of DeleteVpcWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteVpcWithContext(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, "DeleteVpcWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcWithContext), varargs...)
-}
-
-// DeleteVpnConnection mocks base method.
-func (m *MockEC2API) DeleteVpnConnection(arg0 *ec2.DeleteVpnConnectionInput) (*ec2.DeleteVpnConnectionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVpnConnection", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteVpnConnectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVpnConnection indicates an expected call of DeleteVpnConnection.
-func (mr *MockEC2APIMockRecorder) DeleteVpnConnection(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnection", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnection), arg0)
-}
-
-// DeleteVpnConnectionRequest mocks base method.
-func (m *MockEC2API) DeleteVpnConnectionRequest(arg0 *ec2.DeleteVpnConnectionInput) (*request.Request, *ec2.DeleteVpnConnectionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVpnConnectionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteVpnConnectionOutput)
-	return ret0, ret1
-}
-
-// DeleteVpnConnectionRequest indicates an expected call of DeleteVpnConnectionRequest.
-func (mr *MockEC2APIMockRecorder) DeleteVpnConnectionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnectionRequest), arg0)
-}
-
-// DeleteVpnConnectionRoute mocks base method.
-func (m *MockEC2API) DeleteVpnConnectionRoute(arg0 *ec2.DeleteVpnConnectionRouteInput) (*ec2.DeleteVpnConnectionRouteOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVpnConnectionRoute", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteVpnConnectionRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVpnConnectionRoute indicates an expected call of DeleteVpnConnectionRoute.
-func (mr *MockEC2APIMockRecorder) DeleteVpnConnectionRoute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnectionRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnectionRoute), arg0)
-}
-
-// DeleteVpnConnectionRouteRequest mocks base method.
-func (m *MockEC2API) DeleteVpnConnectionRouteRequest(arg0 *ec2.DeleteVpnConnectionRouteInput) (*request.Request, *ec2.DeleteVpnConnectionRouteOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVpnConnectionRouteRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteVpnConnectionRouteOutput)
-	return ret0, ret1
-}
-
-// DeleteVpnConnectionRouteRequest indicates an expected call of DeleteVpnConnectionRouteRequest.
-func (mr *MockEC2APIMockRecorder) DeleteVpnConnectionRouteRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnectionRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnectionRouteRequest), arg0)
-}
-
-// DeleteVpnConnectionRouteWithContext mocks base method.
-func (m *MockEC2API) DeleteVpnConnectionRouteWithContext(arg0 context.Context, arg1 *ec2.DeleteVpnConnectionRouteInput, arg2 ...request.Option) (*ec2.DeleteVpnConnectionRouteOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteVpnConnectionRouteWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteVpnConnectionRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVpnConnectionRouteWithContext indicates an expected call of DeleteVpnConnectionRouteWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteVpnConnectionRouteWithContext(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, "DeleteVpnConnectionRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnectionRouteWithContext), varargs...)
-}
-
-// DeleteVpnConnectionWithContext mocks base method.
-func (m *MockEC2API) DeleteVpnConnectionWithContext(arg0 context.Context, arg1 *ec2.DeleteVpnConnectionInput, arg2 ...request.Option) (*ec2.DeleteVpnConnectionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteVpnConnectionWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteVpnConnectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVpnConnectionWithContext indicates an expected call of DeleteVpnConnectionWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteVpnConnectionWithContext(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, "DeleteVpnConnectionWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnectionWithContext), varargs...)
-}
-
-// DeleteVpnGateway mocks base method.
-func (m *MockEC2API) DeleteVpnGateway(arg0 *ec2.DeleteVpnGatewayInput) (*ec2.DeleteVpnGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVpnGateway", arg0)
-	ret0, _ := ret[0].(*ec2.DeleteVpnGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVpnGateway indicates an expected call of DeleteVpnGateway.
-func (mr *MockEC2APIMockRecorder) DeleteVpnGateway(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnGateway), arg0)
-}
-
-// DeleteVpnGatewayRequest mocks base method.
-func (m *MockEC2API) DeleteVpnGatewayRequest(arg0 *ec2.DeleteVpnGatewayInput) (*request.Request, *ec2.DeleteVpnGatewayOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteVpnGatewayRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeleteVpnGatewayOutput)
-	return ret0, ret1
-}
-
-// DeleteVpnGatewayRequest indicates an expected call of DeleteVpnGatewayRequest.
-func (mr *MockEC2APIMockRecorder) DeleteVpnGatewayRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnGatewayRequest), arg0)
-}
-
-// DeleteVpnGatewayWithContext mocks base method.
-func (m *MockEC2API) DeleteVpnGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteVpnGatewayInput, arg2 ...request.Option) (*ec2.DeleteVpnGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteVpnGatewayWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeleteVpnGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteVpnGatewayWithContext indicates an expected call of DeleteVpnGatewayWithContext.
-func (mr *MockEC2APIMockRecorder) DeleteVpnGatewayWithContext(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, "DeleteVpnGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnGatewayWithContext), varargs...)
-}
-
-// DeprovisionByoipCidr mocks base method.
-func (m *MockEC2API) DeprovisionByoipCidr(arg0 *ec2.DeprovisionByoipCidrInput) (*ec2.DeprovisionByoipCidrOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeprovisionByoipCidr", arg0)
-	ret0, _ := ret[0].(*ec2.DeprovisionByoipCidrOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeprovisionByoipCidr indicates an expected call of DeprovisionByoipCidr.
-func (mr *MockEC2APIMockRecorder) DeprovisionByoipCidr(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionByoipCidr", reflect.TypeOf((*MockEC2API)(nil).DeprovisionByoipCidr), arg0)
-}
-
-// DeprovisionByoipCidrRequest mocks base method.
-func (m *MockEC2API) DeprovisionByoipCidrRequest(arg0 *ec2.DeprovisionByoipCidrInput) (*request.Request, *ec2.DeprovisionByoipCidrOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeprovisionByoipCidrRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeprovisionByoipCidrOutput)
-	return ret0, ret1
-}
-
-// DeprovisionByoipCidrRequest indicates an expected call of DeprovisionByoipCidrRequest.
-func (mr *MockEC2APIMockRecorder) DeprovisionByoipCidrRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionByoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).DeprovisionByoipCidrRequest), arg0)
-}
-
-// DeprovisionByoipCidrWithContext mocks base method.
-func (m *MockEC2API) DeprovisionByoipCidrWithContext(arg0 context.Context, arg1 *ec2.DeprovisionByoipCidrInput, arg2 ...request.Option) (*ec2.DeprovisionByoipCidrOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeprovisionByoipCidrWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeprovisionByoipCidrOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeprovisionByoipCidrWithContext indicates an expected call of DeprovisionByoipCidrWithContext.
-func (mr *MockEC2APIMockRecorder) DeprovisionByoipCidrWithContext(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, "DeprovisionByoipCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).DeprovisionByoipCidrWithContext), varargs...)
-}
-
-// DeprovisionIpamByoasn mocks base method.
-func (m *MockEC2API) DeprovisionIpamByoasn(arg0 *ec2.DeprovisionIpamByoasnInput) (*ec2.DeprovisionIpamByoasnOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeprovisionIpamByoasn", arg0)
-	ret0, _ := ret[0].(*ec2.DeprovisionIpamByoasnOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeprovisionIpamByoasn indicates an expected call of DeprovisionIpamByoasn.
-func (mr *MockEC2APIMockRecorder) DeprovisionIpamByoasn(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionIpamByoasn", reflect.TypeOf((*MockEC2API)(nil).DeprovisionIpamByoasn), arg0)
-}
-
-// DeprovisionIpamByoasnRequest mocks base method.
-func (m *MockEC2API) DeprovisionIpamByoasnRequest(arg0 *ec2.DeprovisionIpamByoasnInput) (*request.Request, *ec2.DeprovisionIpamByoasnOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeprovisionIpamByoasnRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeprovisionIpamByoasnOutput)
-	return ret0, ret1
-}
-
-// DeprovisionIpamByoasnRequest indicates an expected call of DeprovisionIpamByoasnRequest.
-func (mr *MockEC2APIMockRecorder) DeprovisionIpamByoasnRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionIpamByoasnRequest", reflect.TypeOf((*MockEC2API)(nil).DeprovisionIpamByoasnRequest), arg0)
-}
-
-// DeprovisionIpamByoasnWithContext mocks base method.
-func (m *MockEC2API) DeprovisionIpamByoasnWithContext(arg0 context.Context, arg1 *ec2.DeprovisionIpamByoasnInput, arg2 ...request.Option) (*ec2.DeprovisionIpamByoasnOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeprovisionIpamByoasnWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeprovisionIpamByoasnOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeprovisionIpamByoasnWithContext indicates an expected call of DeprovisionIpamByoasnWithContext.
-func (mr *MockEC2APIMockRecorder) DeprovisionIpamByoasnWithContext(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, "DeprovisionIpamByoasnWithContext", reflect.TypeOf((*MockEC2API)(nil).DeprovisionIpamByoasnWithContext), varargs...)
-}
-
-// DeprovisionIpamPoolCidr mocks base method.
-func (m *MockEC2API) DeprovisionIpamPoolCidr(arg0 *ec2.DeprovisionIpamPoolCidrInput) (*ec2.DeprovisionIpamPoolCidrOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeprovisionIpamPoolCidr", arg0)
-	ret0, _ := ret[0].(*ec2.DeprovisionIpamPoolCidrOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeprovisionIpamPoolCidr indicates an expected call of DeprovisionIpamPoolCidr.
-func (mr *MockEC2APIMockRecorder) DeprovisionIpamPoolCidr(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionIpamPoolCidr", reflect.TypeOf((*MockEC2API)(nil).DeprovisionIpamPoolCidr), arg0)
-}
-
-// DeprovisionIpamPoolCidrRequest mocks base method.
-func (m *MockEC2API) DeprovisionIpamPoolCidrRequest(arg0 *ec2.DeprovisionIpamPoolCidrInput) (*request.Request, *ec2.DeprovisionIpamPoolCidrOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeprovisionIpamPoolCidrRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeprovisionIpamPoolCidrOutput)
-	return ret0, ret1
-}
-
-// DeprovisionIpamPoolCidrRequest indicates an expected call of DeprovisionIpamPoolCidrRequest.
-func (mr *MockEC2APIMockRecorder) DeprovisionIpamPoolCidrRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionIpamPoolCidrRequest", reflect.TypeOf((*MockEC2API)(nil).DeprovisionIpamPoolCidrRequest), arg0)
-}
-
-// DeprovisionIpamPoolCidrWithContext mocks base method.
-func (m *MockEC2API) DeprovisionIpamPoolCidrWithContext(arg0 context.Context, arg1 *ec2.DeprovisionIpamPoolCidrInput, arg2 ...request.Option) (*ec2.DeprovisionIpamPoolCidrOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeprovisionIpamPoolCidrWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeprovisionIpamPoolCidrOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeprovisionIpamPoolCidrWithContext indicates an expected call of DeprovisionIpamPoolCidrWithContext.
-func (mr *MockEC2APIMockRecorder) DeprovisionIpamPoolCidrWithContext(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, "DeprovisionIpamPoolCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).DeprovisionIpamPoolCidrWithContext), varargs...)
-}
-
-// DeprovisionPublicIpv4PoolCidr mocks base method.
-func (m *MockEC2API) DeprovisionPublicIpv4PoolCidr(arg0 *ec2.DeprovisionPublicIpv4PoolCidrInput) (*ec2.DeprovisionPublicIpv4PoolCidrOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeprovisionPublicIpv4PoolCidr", arg0)
-	ret0, _ := ret[0].(*ec2.DeprovisionPublicIpv4PoolCidrOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeprovisionPublicIpv4PoolCidr indicates an expected call of DeprovisionPublicIpv4PoolCidr.
-func (mr *MockEC2APIMockRecorder) DeprovisionPublicIpv4PoolCidr(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionPublicIpv4PoolCidr", reflect.TypeOf((*MockEC2API)(nil).DeprovisionPublicIpv4PoolCidr), arg0)
-}
-
-// DeprovisionPublicIpv4PoolCidrRequest mocks base method.
-func (m *MockEC2API) DeprovisionPublicIpv4PoolCidrRequest(arg0 *ec2.DeprovisionPublicIpv4PoolCidrInput) (*request.Request, *ec2.DeprovisionPublicIpv4PoolCidrOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeprovisionPublicIpv4PoolCidrRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeprovisionPublicIpv4PoolCidrOutput)
-	return ret0, ret1
-}
-
-// DeprovisionPublicIpv4PoolCidrRequest indicates an expected call of DeprovisionPublicIpv4PoolCidrRequest.
-func (mr *MockEC2APIMockRecorder) DeprovisionPublicIpv4PoolCidrRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionPublicIpv4PoolCidrRequest", reflect.TypeOf((*MockEC2API)(nil).DeprovisionPublicIpv4PoolCidrRequest), arg0)
-}
-
-// DeprovisionPublicIpv4PoolCidrWithContext mocks base method.
-func (m *MockEC2API) DeprovisionPublicIpv4PoolCidrWithContext(arg0 context.Context, arg1 *ec2.DeprovisionPublicIpv4PoolCidrInput, arg2 ...request.Option) (*ec2.DeprovisionPublicIpv4PoolCidrOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeprovisionPublicIpv4PoolCidrWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeprovisionPublicIpv4PoolCidrOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeprovisionPublicIpv4PoolCidrWithContext indicates an expected call of DeprovisionPublicIpv4PoolCidrWithContext.
-func (mr *MockEC2APIMockRecorder) DeprovisionPublicIpv4PoolCidrWithContext(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, "DeprovisionPublicIpv4PoolCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).DeprovisionPublicIpv4PoolCidrWithContext), varargs...)
-}
-
-// DeregisterImage mocks base method.
-func (m *MockEC2API) DeregisterImage(arg0 *ec2.DeregisterImageInput) (*ec2.DeregisterImageOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeregisterImage", arg0)
-	ret0, _ := ret[0].(*ec2.DeregisterImageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeregisterImage indicates an expected call of DeregisterImage.
-func (mr *MockEC2APIMockRecorder) DeregisterImage(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterImage", reflect.TypeOf((*MockEC2API)(nil).DeregisterImage), arg0)
-}
-
-// DeregisterImageRequest mocks base method.
-func (m *MockEC2API) DeregisterImageRequest(arg0 *ec2.DeregisterImageInput) (*request.Request, *ec2.DeregisterImageOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeregisterImageRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeregisterImageOutput)
-	return ret0, ret1
-}
-
-// DeregisterImageRequest indicates an expected call of DeregisterImageRequest.
-func (mr *MockEC2APIMockRecorder) DeregisterImageRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterImageRequest", reflect.TypeOf((*MockEC2API)(nil).DeregisterImageRequest), arg0)
-}
-
-// DeregisterImageWithContext mocks base method.
-func (m *MockEC2API) DeregisterImageWithContext(arg0 context.Context, arg1 *ec2.DeregisterImageInput, arg2 ...request.Option) (*ec2.DeregisterImageOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeregisterImageWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeregisterImageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeregisterImageWithContext indicates an expected call of DeregisterImageWithContext.
-func (mr *MockEC2APIMockRecorder) DeregisterImageWithContext(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, "DeregisterImageWithContext", reflect.TypeOf((*MockEC2API)(nil).DeregisterImageWithContext), varargs...)
-}
-
-// DeregisterInstanceEventNotificationAttributes mocks base method.
-func (m *MockEC2API) DeregisterInstanceEventNotificationAttributes(arg0 *ec2.DeregisterInstanceEventNotificationAttributesInput) (*ec2.DeregisterInstanceEventNotificationAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeregisterInstanceEventNotificationAttributes", arg0)
-	ret0, _ := ret[0].(*ec2.DeregisterInstanceEventNotificationAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeregisterInstanceEventNotificationAttributes indicates an expected call of DeregisterInstanceEventNotificationAttributes.
-func (mr *MockEC2APIMockRecorder) DeregisterInstanceEventNotificationAttributes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterInstanceEventNotificationAttributes", reflect.TypeOf((*MockEC2API)(nil).DeregisterInstanceEventNotificationAttributes), arg0)
-}
-
-// DeregisterInstanceEventNotificationAttributesRequest mocks base method.
-func (m *MockEC2API) DeregisterInstanceEventNotificationAttributesRequest(arg0 *ec2.DeregisterInstanceEventNotificationAttributesInput) (*request.Request, *ec2.DeregisterInstanceEventNotificationAttributesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeregisterInstanceEventNotificationAttributesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeregisterInstanceEventNotificationAttributesOutput)
-	return ret0, ret1
-}
-
-// DeregisterInstanceEventNotificationAttributesRequest indicates an expected call of DeregisterInstanceEventNotificationAttributesRequest.
-func (mr *MockEC2APIMockRecorder) DeregisterInstanceEventNotificationAttributesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterInstanceEventNotificationAttributesRequest", reflect.TypeOf((*MockEC2API)(nil).DeregisterInstanceEventNotificationAttributesRequest), arg0)
-}
-
-// DeregisterInstanceEventNotificationAttributesWithContext mocks base method.
-func (m *MockEC2API) DeregisterInstanceEventNotificationAttributesWithContext(arg0 context.Context, arg1 *ec2.DeregisterInstanceEventNotificationAttributesInput, arg2 ...request.Option) (*ec2.DeregisterInstanceEventNotificationAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeregisterInstanceEventNotificationAttributesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeregisterInstanceEventNotificationAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeregisterInstanceEventNotificationAttributesWithContext indicates an expected call of DeregisterInstanceEventNotificationAttributesWithContext.
-func (mr *MockEC2APIMockRecorder) DeregisterInstanceEventNotificationAttributesWithContext(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, "DeregisterInstanceEventNotificationAttributesWithContext", reflect.TypeOf((*MockEC2API)(nil).DeregisterInstanceEventNotificationAttributesWithContext), varargs...)
-}
-
-// DeregisterTransitGatewayMulticastGroupMembers mocks base method.
-func (m *MockEC2API) DeregisterTransitGatewayMulticastGroupMembers(arg0 *ec2.DeregisterTransitGatewayMulticastGroupMembersInput) (*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupMembers", arg0)
-	ret0, _ := ret[0].(*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeregisterTransitGatewayMulticastGroupMembers indicates an expected call of DeregisterTransitGatewayMulticastGroupMembers.
-func (mr *MockEC2APIMockRecorder) DeregisterTransitGatewayMulticastGroupMembers(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTransitGatewayMulticastGroupMembers", reflect.TypeOf((*MockEC2API)(nil).DeregisterTransitGatewayMulticastGroupMembers), arg0)
-}
-
-// DeregisterTransitGatewayMulticastGroupMembersRequest mocks base method.
-func (m *MockEC2API) DeregisterTransitGatewayMulticastGroupMembersRequest(arg0 *ec2.DeregisterTransitGatewayMulticastGroupMembersInput) (*request.Request, *ec2.DeregisterTransitGatewayMulticastGroupMembersOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupMembersRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput)
-	return ret0, ret1
-}
-
-// DeregisterTransitGatewayMulticastGroupMembersRequest indicates an expected call of DeregisterTransitGatewayMulticastGroupMembersRequest.
-func (mr *MockEC2APIMockRecorder) DeregisterTransitGatewayMulticastGroupMembersRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTransitGatewayMulticastGroupMembersRequest", reflect.TypeOf((*MockEC2API)(nil).DeregisterTransitGatewayMulticastGroupMembersRequest), arg0)
-}
-
-// DeregisterTransitGatewayMulticastGroupMembersWithContext mocks base method.
-func (m *MockEC2API) DeregisterTransitGatewayMulticastGroupMembersWithContext(arg0 context.Context, arg1 *ec2.DeregisterTransitGatewayMulticastGroupMembersInput, arg2 ...request.Option) (*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupMembersWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeregisterTransitGatewayMulticastGroupMembersWithContext indicates an expected call of DeregisterTransitGatewayMulticastGroupMembersWithContext.
-func (mr *MockEC2APIMockRecorder) DeregisterTransitGatewayMulticastGroupMembersWithContext(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, "DeregisterTransitGatewayMulticastGroupMembersWithContext", reflect.TypeOf((*MockEC2API)(nil).DeregisterTransitGatewayMulticastGroupMembersWithContext), varargs...)
-}
-
-// DeregisterTransitGatewayMulticastGroupSources mocks base method.
-func (m *MockEC2API) DeregisterTransitGatewayMulticastGroupSources(arg0 *ec2.DeregisterTransitGatewayMulticastGroupSourcesInput) (*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupSources", arg0)
-	ret0, _ := ret[0].(*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeregisterTransitGatewayMulticastGroupSources indicates an expected call of DeregisterTransitGatewayMulticastGroupSources.
-func (mr *MockEC2APIMockRecorder) DeregisterTransitGatewayMulticastGroupSources(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTransitGatewayMulticastGroupSources", reflect.TypeOf((*MockEC2API)(nil).DeregisterTransitGatewayMulticastGroupSources), arg0)
-}
-
-// DeregisterTransitGatewayMulticastGroupSourcesRequest mocks base method.
-func (m *MockEC2API) DeregisterTransitGatewayMulticastGroupSourcesRequest(arg0 *ec2.DeregisterTransitGatewayMulticastGroupSourcesInput) (*request.Request, *ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupSourcesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput)
-	return ret0, ret1
-}
-
-// DeregisterTransitGatewayMulticastGroupSourcesRequest indicates an expected call of DeregisterTransitGatewayMulticastGroupSourcesRequest.
-func (mr *MockEC2APIMockRecorder) DeregisterTransitGatewayMulticastGroupSourcesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTransitGatewayMulticastGroupSourcesRequest", reflect.TypeOf((*MockEC2API)(nil).DeregisterTransitGatewayMulticastGroupSourcesRequest), arg0)
-}
-
-// DeregisterTransitGatewayMulticastGroupSourcesWithContext mocks base method.
-func (m *MockEC2API) DeregisterTransitGatewayMulticastGroupSourcesWithContext(arg0 context.Context, arg1 *ec2.DeregisterTransitGatewayMulticastGroupSourcesInput, arg2 ...request.Option) (*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupSourcesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeregisterTransitGatewayMulticastGroupSourcesWithContext indicates an expected call of DeregisterTransitGatewayMulticastGroupSourcesWithContext.
-func (mr *MockEC2APIMockRecorder) DeregisterTransitGatewayMulticastGroupSourcesWithContext(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, "DeregisterTransitGatewayMulticastGroupSourcesWithContext", reflect.TypeOf((*MockEC2API)(nil).DeregisterTransitGatewayMulticastGroupSourcesWithContext), varargs...)
-}
-
-// DescribeAccountAttributes mocks base method.
-func (m *MockEC2API) DescribeAccountAttributes(arg0 *ec2.DescribeAccountAttributesInput) (*ec2.DescribeAccountAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAccountAttributes", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeAccountAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAccountAttributes indicates an expected call of DescribeAccountAttributes.
-func (mr *MockEC2APIMockRecorder) DescribeAccountAttributes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountAttributes", reflect.TypeOf((*MockEC2API)(nil).DescribeAccountAttributes), arg0)
-}
-
-// DescribeAccountAttributesRequest mocks base method.
-func (m *MockEC2API) DescribeAccountAttributesRequest(arg0 *ec2.DescribeAccountAttributesInput) (*request.Request, *ec2.DescribeAccountAttributesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAccountAttributesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeAccountAttributesOutput)
-	return ret0, ret1
-}
-
-// DescribeAccountAttributesRequest indicates an expected call of DescribeAccountAttributesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeAccountAttributesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountAttributesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAccountAttributesRequest), arg0)
-}
-
-// DescribeAccountAttributesWithContext mocks base method.
-func (m *MockEC2API) DescribeAccountAttributesWithContext(arg0 context.Context, arg1 *ec2.DescribeAccountAttributesInput, arg2 ...request.Option) (*ec2.DescribeAccountAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeAccountAttributesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeAccountAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAccountAttributesWithContext indicates an expected call of DescribeAccountAttributesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeAccountAttributesWithContext(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, "DescribeAccountAttributesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeAccountAttributesWithContext), varargs...)
-}
-
-// DescribeAddressTransfers mocks base method.
-func (m *MockEC2API) DescribeAddressTransfers(arg0 *ec2.DescribeAddressTransfersInput) (*ec2.DescribeAddressTransfersOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAddressTransfers", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeAddressTransfersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAddressTransfers indicates an expected call of DescribeAddressTransfers.
-func (mr *MockEC2APIMockRecorder) DescribeAddressTransfers(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressTransfers", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressTransfers), arg0)
-}
-
-// DescribeAddressTransfersPages mocks base method.
-func (m *MockEC2API) DescribeAddressTransfersPages(arg0 *ec2.DescribeAddressTransfersInput, arg1 func(*ec2.DescribeAddressTransfersOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAddressTransfersPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeAddressTransfersPages indicates an expected call of DescribeAddressTransfersPages.
-func (mr *MockEC2APIMockRecorder) DescribeAddressTransfersPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressTransfersPages", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressTransfersPages), arg0, arg1)
-}
-
-// DescribeAddressTransfersPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeAddressTransfersPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeAddressTransfersInput, arg2 func(*ec2.DescribeAddressTransfersOutput, 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, "DescribeAddressTransfersPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeAddressTransfersPagesWithContext indicates an expected call of DescribeAddressTransfersPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeAddressTransfersPagesWithContext(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, "DescribeAddressTransfersPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressTransfersPagesWithContext), varargs...)
-}
-
-// DescribeAddressTransfersRequest mocks base method.
-func (m *MockEC2API) DescribeAddressTransfersRequest(arg0 *ec2.DescribeAddressTransfersInput) (*request.Request, *ec2.DescribeAddressTransfersOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAddressTransfersRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeAddressTransfersOutput)
-	return ret0, ret1
-}
-
-// DescribeAddressTransfersRequest indicates an expected call of DescribeAddressTransfersRequest.
-func (mr *MockEC2APIMockRecorder) DescribeAddressTransfersRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressTransfersRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressTransfersRequest), arg0)
-}
-
-// DescribeAddressTransfersWithContext mocks base method.
-func (m *MockEC2API) DescribeAddressTransfersWithContext(arg0 context.Context, arg1 *ec2.DescribeAddressTransfersInput, arg2 ...request.Option) (*ec2.DescribeAddressTransfersOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeAddressTransfersWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeAddressTransfersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAddressTransfersWithContext indicates an expected call of DescribeAddressTransfersWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeAddressTransfersWithContext(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, "DescribeAddressTransfersWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressTransfersWithContext), varargs...)
-}
-
-// DescribeAddresses mocks base method.
-func (m *MockEC2API) DescribeAddresses(arg0 *ec2.DescribeAddressesInput) (*ec2.DescribeAddressesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAddresses", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeAddressesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAddresses indicates an expected call of DescribeAddresses.
-func (mr *MockEC2APIMockRecorder) DescribeAddresses(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddresses", reflect.TypeOf((*MockEC2API)(nil).DescribeAddresses), arg0)
-}
-
-// DescribeAddressesAttribute mocks base method.
-func (m *MockEC2API) DescribeAddressesAttribute(arg0 *ec2.DescribeAddressesAttributeInput) (*ec2.DescribeAddressesAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAddressesAttribute", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeAddressesAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAddressesAttribute indicates an expected call of DescribeAddressesAttribute.
-func (mr *MockEC2APIMockRecorder) DescribeAddressesAttribute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesAttribute), arg0)
-}
-
-// DescribeAddressesAttributePages mocks base method.
-func (m *MockEC2API) DescribeAddressesAttributePages(arg0 *ec2.DescribeAddressesAttributeInput, arg1 func(*ec2.DescribeAddressesAttributeOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAddressesAttributePages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeAddressesAttributePages indicates an expected call of DescribeAddressesAttributePages.
-func (mr *MockEC2APIMockRecorder) DescribeAddressesAttributePages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesAttributePages", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesAttributePages), arg0, arg1)
-}
-
-// DescribeAddressesAttributePagesWithContext mocks base method.
-func (m *MockEC2API) DescribeAddressesAttributePagesWithContext(arg0 context.Context, arg1 *ec2.DescribeAddressesAttributeInput, arg2 func(*ec2.DescribeAddressesAttributeOutput, 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, "DescribeAddressesAttributePagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeAddressesAttributePagesWithContext indicates an expected call of DescribeAddressesAttributePagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeAddressesAttributePagesWithContext(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, "DescribeAddressesAttributePagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesAttributePagesWithContext), varargs...)
-}
-
-// DescribeAddressesAttributeRequest mocks base method.
-func (m *MockEC2API) DescribeAddressesAttributeRequest(arg0 *ec2.DescribeAddressesAttributeInput) (*request.Request, *ec2.DescribeAddressesAttributeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAddressesAttributeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeAddressesAttributeOutput)
-	return ret0, ret1
-}
-
-// DescribeAddressesAttributeRequest indicates an expected call of DescribeAddressesAttributeRequest.
-func (mr *MockEC2APIMockRecorder) DescribeAddressesAttributeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesAttributeRequest), arg0)
-}
-
-// DescribeAddressesAttributeWithContext mocks base method.
-func (m *MockEC2API) DescribeAddressesAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeAddressesAttributeInput, arg2 ...request.Option) (*ec2.DescribeAddressesAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeAddressesAttributeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeAddressesAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAddressesAttributeWithContext indicates an expected call of DescribeAddressesAttributeWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeAddressesAttributeWithContext(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, "DescribeAddressesAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesAttributeWithContext), varargs...)
-}
-
-// DescribeAddressesRequest mocks base method.
-func (m *MockEC2API) DescribeAddressesRequest(arg0 *ec2.DescribeAddressesInput) (*request.Request, *ec2.DescribeAddressesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAddressesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeAddressesOutput)
-	return ret0, ret1
-}
-
-// DescribeAddressesRequest indicates an expected call of DescribeAddressesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeAddressesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesRequest), arg0)
-}
-
-// DescribeAddressesWithContext mocks base method.
-func (m *MockEC2API) DescribeAddressesWithContext(arg0 context.Context, arg1 *ec2.DescribeAddressesInput, arg2 ...request.Option) (*ec2.DescribeAddressesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeAddressesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeAddressesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAddressesWithContext indicates an expected call of DescribeAddressesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeAddressesWithContext(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, "DescribeAddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesWithContext), varargs...)
-}
-
-// DescribeAggregateIdFormat mocks base method.
-func (m *MockEC2API) DescribeAggregateIdFormat(arg0 *ec2.DescribeAggregateIdFormatInput) (*ec2.DescribeAggregateIdFormatOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAggregateIdFormat", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeAggregateIdFormatOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAggregateIdFormat indicates an expected call of DescribeAggregateIdFormat.
-func (mr *MockEC2APIMockRecorder) DescribeAggregateIdFormat(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAggregateIdFormat", reflect.TypeOf((*MockEC2API)(nil).DescribeAggregateIdFormat), arg0)
-}
-
-// DescribeAggregateIdFormatRequest mocks base method.
-func (m *MockEC2API) DescribeAggregateIdFormatRequest(arg0 *ec2.DescribeAggregateIdFormatInput) (*request.Request, *ec2.DescribeAggregateIdFormatOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAggregateIdFormatRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeAggregateIdFormatOutput)
-	return ret0, ret1
-}
-
-// DescribeAggregateIdFormatRequest indicates an expected call of DescribeAggregateIdFormatRequest.
-func (mr *MockEC2APIMockRecorder) DescribeAggregateIdFormatRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAggregateIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAggregateIdFormatRequest), arg0)
-}
-
-// DescribeAggregateIdFormatWithContext mocks base method.
-func (m *MockEC2API) DescribeAggregateIdFormatWithContext(arg0 context.Context, arg1 *ec2.DescribeAggregateIdFormatInput, arg2 ...request.Option) (*ec2.DescribeAggregateIdFormatOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeAggregateIdFormatWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeAggregateIdFormatOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAggregateIdFormatWithContext indicates an expected call of DescribeAggregateIdFormatWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeAggregateIdFormatWithContext(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, "DescribeAggregateIdFormatWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeAggregateIdFormatWithContext), varargs...)
-}
-
-// DescribeAvailabilityZones mocks base method.
-func (m *MockEC2API) DescribeAvailabilityZones(arg0 *ec2.DescribeAvailabilityZonesInput) (*ec2.DescribeAvailabilityZonesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAvailabilityZones", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeAvailabilityZonesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAvailabilityZones indicates an expected call of DescribeAvailabilityZones.
-func (mr *MockEC2APIMockRecorder) DescribeAvailabilityZones(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAvailabilityZones", reflect.TypeOf((*MockEC2API)(nil).DescribeAvailabilityZones), arg0)
-}
-
-// DescribeAvailabilityZonesRequest mocks base method.
-func (m *MockEC2API) DescribeAvailabilityZonesRequest(arg0 *ec2.DescribeAvailabilityZonesInput) (*request.Request, *ec2.DescribeAvailabilityZonesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAvailabilityZonesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeAvailabilityZonesOutput)
-	return ret0, ret1
-}
-
-// DescribeAvailabilityZonesRequest indicates an expected call of DescribeAvailabilityZonesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeAvailabilityZonesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAvailabilityZonesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAvailabilityZonesRequest), arg0)
-}
-
-// DescribeAvailabilityZonesWithContext mocks base method.
-func (m *MockEC2API) DescribeAvailabilityZonesWithContext(arg0 context.Context, arg1 *ec2.DescribeAvailabilityZonesInput, arg2 ...request.Option) (*ec2.DescribeAvailabilityZonesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeAvailabilityZonesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeAvailabilityZonesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAvailabilityZonesWithContext indicates an expected call of DescribeAvailabilityZonesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeAvailabilityZonesWithContext(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, "DescribeAvailabilityZonesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeAvailabilityZonesWithContext), varargs...)
-}
-
-// DescribeAwsNetworkPerformanceMetricSubscriptions mocks base method.
-func (m *MockEC2API) DescribeAwsNetworkPerformanceMetricSubscriptions(arg0 *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsInput) (*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAwsNetworkPerformanceMetricSubscriptions", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAwsNetworkPerformanceMetricSubscriptions indicates an expected call of DescribeAwsNetworkPerformanceMetricSubscriptions.
-func (mr *MockEC2APIMockRecorder) DescribeAwsNetworkPerformanceMetricSubscriptions(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAwsNetworkPerformanceMetricSubscriptions", reflect.TypeOf((*MockEC2API)(nil).DescribeAwsNetworkPerformanceMetricSubscriptions), arg0)
-}
-
-// DescribeAwsNetworkPerformanceMetricSubscriptionsPages mocks base method.
-func (m *MockEC2API) DescribeAwsNetworkPerformanceMetricSubscriptionsPages(arg0 *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsInput, arg1 func(*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAwsNetworkPerformanceMetricSubscriptionsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeAwsNetworkPerformanceMetricSubscriptionsPages indicates an expected call of DescribeAwsNetworkPerformanceMetricSubscriptionsPages.
-func (mr *MockEC2APIMockRecorder) DescribeAwsNetworkPerformanceMetricSubscriptionsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAwsNetworkPerformanceMetricSubscriptionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeAwsNetworkPerformanceMetricSubscriptionsPages), arg0, arg1)
-}
-
-// DescribeAwsNetworkPerformanceMetricSubscriptionsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeAwsNetworkPerformanceMetricSubscriptionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsInput, arg2 func(*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput, 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, "DescribeAwsNetworkPerformanceMetricSubscriptionsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeAwsNetworkPerformanceMetricSubscriptionsPagesWithContext indicates an expected call of DescribeAwsNetworkPerformanceMetricSubscriptionsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeAwsNetworkPerformanceMetricSubscriptionsPagesWithContext(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, "DescribeAwsNetworkPerformanceMetricSubscriptionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeAwsNetworkPerformanceMetricSubscriptionsPagesWithContext), varargs...)
-}
-
-// DescribeAwsNetworkPerformanceMetricSubscriptionsRequest mocks base method.
-func (m *MockEC2API) DescribeAwsNetworkPerformanceMetricSubscriptionsRequest(arg0 *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsInput) (*request.Request, *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeAwsNetworkPerformanceMetricSubscriptionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput)
-	return ret0, ret1
-}
-
-// DescribeAwsNetworkPerformanceMetricSubscriptionsRequest indicates an expected call of DescribeAwsNetworkPerformanceMetricSubscriptionsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeAwsNetworkPerformanceMetricSubscriptionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAwsNetworkPerformanceMetricSubscriptionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAwsNetworkPerformanceMetricSubscriptionsRequest), arg0)
-}
-
-// DescribeAwsNetworkPerformanceMetricSubscriptionsWithContext mocks base method.
-func (m *MockEC2API) DescribeAwsNetworkPerformanceMetricSubscriptionsWithContext(arg0 context.Context, arg1 *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsInput, arg2 ...request.Option) (*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeAwsNetworkPerformanceMetricSubscriptionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeAwsNetworkPerformanceMetricSubscriptionsWithContext indicates an expected call of DescribeAwsNetworkPerformanceMetricSubscriptionsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeAwsNetworkPerformanceMetricSubscriptionsWithContext(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, "DescribeAwsNetworkPerformanceMetricSubscriptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeAwsNetworkPerformanceMetricSubscriptionsWithContext), varargs...)
-}
-
-// DescribeBundleTasks mocks base method.
-func (m *MockEC2API) DescribeBundleTasks(arg0 *ec2.DescribeBundleTasksInput) (*ec2.DescribeBundleTasksOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeBundleTasks", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeBundleTasksOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeBundleTasks indicates an expected call of DescribeBundleTasks.
-func (mr *MockEC2APIMockRecorder) DescribeBundleTasks(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBundleTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeBundleTasks), arg0)
-}
-
-// DescribeBundleTasksRequest mocks base method.
-func (m *MockEC2API) DescribeBundleTasksRequest(arg0 *ec2.DescribeBundleTasksInput) (*request.Request, *ec2.DescribeBundleTasksOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeBundleTasksRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeBundleTasksOutput)
-	return ret0, ret1
-}
-
-// DescribeBundleTasksRequest indicates an expected call of DescribeBundleTasksRequest.
-func (mr *MockEC2APIMockRecorder) DescribeBundleTasksRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBundleTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeBundleTasksRequest), arg0)
-}
-
-// DescribeBundleTasksWithContext mocks base method.
-func (m *MockEC2API) DescribeBundleTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeBundleTasksInput, arg2 ...request.Option) (*ec2.DescribeBundleTasksOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeBundleTasksWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeBundleTasksOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeBundleTasksWithContext indicates an expected call of DescribeBundleTasksWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeBundleTasksWithContext(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, "DescribeBundleTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeBundleTasksWithContext), varargs...)
-}
-
-// DescribeByoipCidrs mocks base method.
-func (m *MockEC2API) DescribeByoipCidrs(arg0 *ec2.DescribeByoipCidrsInput) (*ec2.DescribeByoipCidrsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeByoipCidrs", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeByoipCidrsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeByoipCidrs indicates an expected call of DescribeByoipCidrs.
-func (mr *MockEC2APIMockRecorder) DescribeByoipCidrs(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeByoipCidrs", reflect.TypeOf((*MockEC2API)(nil).DescribeByoipCidrs), arg0)
-}
-
-// DescribeByoipCidrsPages mocks base method.
-func (m *MockEC2API) DescribeByoipCidrsPages(arg0 *ec2.DescribeByoipCidrsInput, arg1 func(*ec2.DescribeByoipCidrsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeByoipCidrsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeByoipCidrsPages indicates an expected call of DescribeByoipCidrsPages.
-func (mr *MockEC2APIMockRecorder) DescribeByoipCidrsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeByoipCidrsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeByoipCidrsPages), arg0, arg1)
-}
-
-// DescribeByoipCidrsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeByoipCidrsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeByoipCidrsInput, arg2 func(*ec2.DescribeByoipCidrsOutput, 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, "DescribeByoipCidrsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeByoipCidrsPagesWithContext indicates an expected call of DescribeByoipCidrsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeByoipCidrsPagesWithContext(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, "DescribeByoipCidrsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeByoipCidrsPagesWithContext), varargs...)
-}
-
-// DescribeByoipCidrsRequest mocks base method.
-func (m *MockEC2API) DescribeByoipCidrsRequest(arg0 *ec2.DescribeByoipCidrsInput) (*request.Request, *ec2.DescribeByoipCidrsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeByoipCidrsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeByoipCidrsOutput)
-	return ret0, ret1
-}
-
-// DescribeByoipCidrsRequest indicates an expected call of DescribeByoipCidrsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeByoipCidrsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeByoipCidrsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeByoipCidrsRequest), arg0)
-}
-
-// DescribeByoipCidrsWithContext mocks base method.
-func (m *MockEC2API) DescribeByoipCidrsWithContext(arg0 context.Context, arg1 *ec2.DescribeByoipCidrsInput, arg2 ...request.Option) (*ec2.DescribeByoipCidrsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeByoipCidrsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeByoipCidrsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeByoipCidrsWithContext indicates an expected call of DescribeByoipCidrsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeByoipCidrsWithContext(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, "DescribeByoipCidrsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeByoipCidrsWithContext), varargs...)
-}
-
-// DescribeCapacityBlockOfferings mocks base method.
-func (m *MockEC2API) DescribeCapacityBlockOfferings(arg0 *ec2.DescribeCapacityBlockOfferingsInput) (*ec2.DescribeCapacityBlockOfferingsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeCapacityBlockOfferings", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeCapacityBlockOfferingsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeCapacityBlockOfferings indicates an expected call of DescribeCapacityBlockOfferings.
-func (mr *MockEC2APIMockRecorder) DescribeCapacityBlockOfferings(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityBlockOfferings", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityBlockOfferings), arg0)
-}
-
-// DescribeCapacityBlockOfferingsPages mocks base method.
-func (m *MockEC2API) DescribeCapacityBlockOfferingsPages(arg0 *ec2.DescribeCapacityBlockOfferingsInput, arg1 func(*ec2.DescribeCapacityBlockOfferingsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeCapacityBlockOfferingsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeCapacityBlockOfferingsPages indicates an expected call of DescribeCapacityBlockOfferingsPages.
-func (mr *MockEC2APIMockRecorder) DescribeCapacityBlockOfferingsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityBlockOfferingsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityBlockOfferingsPages), arg0, arg1)
-}
-
-// DescribeCapacityBlockOfferingsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeCapacityBlockOfferingsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeCapacityBlockOfferingsInput, arg2 func(*ec2.DescribeCapacityBlockOfferingsOutput, 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, "DescribeCapacityBlockOfferingsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeCapacityBlockOfferingsPagesWithContext indicates an expected call of DescribeCapacityBlockOfferingsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeCapacityBlockOfferingsPagesWithContext(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, "DescribeCapacityBlockOfferingsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityBlockOfferingsPagesWithContext), varargs...)
-}
-
-// DescribeCapacityBlockOfferingsRequest mocks base method.
-func (m *MockEC2API) DescribeCapacityBlockOfferingsRequest(arg0 *ec2.DescribeCapacityBlockOfferingsInput) (*request.Request, *ec2.DescribeCapacityBlockOfferingsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeCapacityBlockOfferingsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeCapacityBlockOfferingsOutput)
-	return ret0, ret1
-}
-
-// DescribeCapacityBlockOfferingsRequest indicates an expected call of DescribeCapacityBlockOfferingsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeCapacityBlockOfferingsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityBlockOfferingsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityBlockOfferingsRequest), arg0)
-}
-
-// DescribeCapacityBlockOfferingsWithContext mocks base method.
-func (m *MockEC2API) DescribeCapacityBlockOfferingsWithContext(arg0 context.Context, arg1 *ec2.DescribeCapacityBlockOfferingsInput, arg2 ...request.Option) (*ec2.DescribeCapacityBlockOfferingsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeCapacityBlockOfferingsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeCapacityBlockOfferingsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeCapacityBlockOfferingsWithContext indicates an expected call of DescribeCapacityBlockOfferingsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeCapacityBlockOfferingsWithContext(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, "DescribeCapacityBlockOfferingsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityBlockOfferingsWithContext), varargs...)
-}
-
-// DescribeCapacityReservationFleets mocks base method.
-func (m *MockEC2API) DescribeCapacityReservationFleets(arg0 *ec2.DescribeCapacityReservationFleetsInput) (*ec2.DescribeCapacityReservationFleetsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeCapacityReservationFleets", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeCapacityReservationFleetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeCapacityReservationFleets indicates an expected call of DescribeCapacityReservationFleets.
-func (mr *MockEC2APIMockRecorder) DescribeCapacityReservationFleets(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationFleets", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationFleets), arg0)
-}
-
-// DescribeCapacityReservationFleetsPages mocks base method.
-func (m *MockEC2API) DescribeCapacityReservationFleetsPages(arg0 *ec2.DescribeCapacityReservationFleetsInput, arg1 func(*ec2.DescribeCapacityReservationFleetsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeCapacityReservationFleetsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeCapacityReservationFleetsPages indicates an expected call of DescribeCapacityReservationFleetsPages.
-func (mr *MockEC2APIMockRecorder) DescribeCapacityReservationFleetsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationFleetsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationFleetsPages), arg0, arg1)
-}
-
-// DescribeCapacityReservationFleetsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeCapacityReservationFleetsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeCapacityReservationFleetsInput, arg2 func(*ec2.DescribeCapacityReservationFleetsOutput, 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, "DescribeCapacityReservationFleetsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeCapacityReservationFleetsPagesWithContext indicates an expected call of DescribeCapacityReservationFleetsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeCapacityReservationFleetsPagesWithContext(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, "DescribeCapacityReservationFleetsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationFleetsPagesWithContext), varargs...)
-}
-
-// DescribeCapacityReservationFleetsRequest mocks base method.
-func (m *MockEC2API) DescribeCapacityReservationFleetsRequest(arg0 *ec2.DescribeCapacityReservationFleetsInput) (*request.Request, *ec2.DescribeCapacityReservationFleetsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeCapacityReservationFleetsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeCapacityReservationFleetsOutput)
-	return ret0, ret1
-}
-
-// DescribeCapacityReservationFleetsRequest indicates an expected call of DescribeCapacityReservationFleetsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeCapacityReservationFleetsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationFleetsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationFleetsRequest), arg0)
-}
-
-// DescribeCapacityReservationFleetsWithContext mocks base method.
-func (m *MockEC2API) DescribeCapacityReservationFleetsWithContext(arg0 context.Context, arg1 *ec2.DescribeCapacityReservationFleetsInput, arg2 ...request.Option) (*ec2.DescribeCapacityReservationFleetsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeCapacityReservationFleetsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeCapacityReservationFleetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeCapacityReservationFleetsWithContext indicates an expected call of DescribeCapacityReservationFleetsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeCapacityReservationFleetsWithContext(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, "DescribeCapacityReservationFleetsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationFleetsWithContext), varargs...)
-}
-
-// DescribeCapacityReservations mocks base method.
-func (m *MockEC2API) DescribeCapacityReservations(arg0 *ec2.DescribeCapacityReservationsInput) (*ec2.DescribeCapacityReservationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeCapacityReservations", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeCapacityReservationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeCapacityReservations indicates an expected call of DescribeCapacityReservations.
-func (mr *MockEC2APIMockRecorder) DescribeCapacityReservations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservations", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservations), arg0)
-}
-
-// DescribeCapacityReservationsPages mocks base method.
-func (m *MockEC2API) DescribeCapacityReservationsPages(arg0 *ec2.DescribeCapacityReservationsInput, arg1 func(*ec2.DescribeCapacityReservationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeCapacityReservationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeCapacityReservationsPages indicates an expected call of DescribeCapacityReservationsPages.
-func (mr *MockEC2APIMockRecorder) DescribeCapacityReservationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationsPages), arg0, arg1)
-}
-
-// DescribeCapacityReservationsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeCapacityReservationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeCapacityReservationsInput, arg2 func(*ec2.DescribeCapacityReservationsOutput, 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, "DescribeCapacityReservationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeCapacityReservationsPagesWithContext indicates an expected call of DescribeCapacityReservationsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeCapacityReservationsPagesWithContext(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, "DescribeCapacityReservationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationsPagesWithContext), varargs...)
-}
-
-// DescribeCapacityReservationsRequest mocks base method.
-func (m *MockEC2API) DescribeCapacityReservationsRequest(arg0 *ec2.DescribeCapacityReservationsInput) (*request.Request, *ec2.DescribeCapacityReservationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeCapacityReservationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeCapacityReservationsOutput)
-	return ret0, ret1
-}
-
-// DescribeCapacityReservationsRequest indicates an expected call of DescribeCapacityReservationsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeCapacityReservationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationsRequest), arg0)
-}
-
-// DescribeCapacityReservationsWithContext mocks base method.
-func (m *MockEC2API) DescribeCapacityReservationsWithContext(arg0 context.Context, arg1 *ec2.DescribeCapacityReservationsInput, arg2 ...request.Option) (*ec2.DescribeCapacityReservationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeCapacityReservationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeCapacityReservationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeCapacityReservationsWithContext indicates an expected call of DescribeCapacityReservationsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeCapacityReservationsWithContext(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, "DescribeCapacityReservationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationsWithContext), varargs...)
-}
-
-// DescribeCarrierGateways mocks base method.
-func (m *MockEC2API) DescribeCarrierGateways(arg0 *ec2.DescribeCarrierGatewaysInput) (*ec2.DescribeCarrierGatewaysOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeCarrierGateways", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeCarrierGatewaysOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeCarrierGateways indicates an expected call of DescribeCarrierGateways.
-func (mr *MockEC2APIMockRecorder) DescribeCarrierGateways(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCarrierGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeCarrierGateways), arg0)
-}
-
-// DescribeCarrierGatewaysPages mocks base method.
-func (m *MockEC2API) DescribeCarrierGatewaysPages(arg0 *ec2.DescribeCarrierGatewaysInput, arg1 func(*ec2.DescribeCarrierGatewaysOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeCarrierGatewaysPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeCarrierGatewaysPages indicates an expected call of DescribeCarrierGatewaysPages.
-func (mr *MockEC2APIMockRecorder) DescribeCarrierGatewaysPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCarrierGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeCarrierGatewaysPages), arg0, arg1)
-}
-
-// DescribeCarrierGatewaysPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeCarrierGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeCarrierGatewaysInput, arg2 func(*ec2.DescribeCarrierGatewaysOutput, 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, "DescribeCarrierGatewaysPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeCarrierGatewaysPagesWithContext indicates an expected call of DescribeCarrierGatewaysPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeCarrierGatewaysPagesWithContext(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, "DescribeCarrierGatewaysPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCarrierGatewaysPagesWithContext), varargs...)
-}
-
-// DescribeCarrierGatewaysRequest mocks base method.
-func (m *MockEC2API) DescribeCarrierGatewaysRequest(arg0 *ec2.DescribeCarrierGatewaysInput) (*request.Request, *ec2.DescribeCarrierGatewaysOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeCarrierGatewaysRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeCarrierGatewaysOutput)
-	return ret0, ret1
-}
-
-// DescribeCarrierGatewaysRequest indicates an expected call of DescribeCarrierGatewaysRequest.
-func (mr *MockEC2APIMockRecorder) DescribeCarrierGatewaysRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCarrierGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeCarrierGatewaysRequest), arg0)
-}
-
-// DescribeCarrierGatewaysWithContext mocks base method.
-func (m *MockEC2API) DescribeCarrierGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeCarrierGatewaysInput, arg2 ...request.Option) (*ec2.DescribeCarrierGatewaysOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeCarrierGatewaysWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeCarrierGatewaysOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeCarrierGatewaysWithContext indicates an expected call of DescribeCarrierGatewaysWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeCarrierGatewaysWithContext(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, "DescribeCarrierGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCarrierGatewaysWithContext), varargs...)
-}
-
-// DescribeClassicLinkInstances mocks base method.
-func (m *MockEC2API) DescribeClassicLinkInstances(arg0 *ec2.DescribeClassicLinkInstancesInput) (*ec2.DescribeClassicLinkInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeClassicLinkInstances", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeClassicLinkInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeClassicLinkInstances indicates an expected call of DescribeClassicLinkInstances.
-func (mr *MockEC2APIMockRecorder) DescribeClassicLinkInstances(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClassicLinkInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeClassicLinkInstances), arg0)
-}
-
-// DescribeClassicLinkInstancesPages mocks base method.
-func (m *MockEC2API) DescribeClassicLinkInstancesPages(arg0 *ec2.DescribeClassicLinkInstancesInput, arg1 func(*ec2.DescribeClassicLinkInstancesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeClassicLinkInstancesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeClassicLinkInstancesPages indicates an expected call of DescribeClassicLinkInstancesPages.
-func (mr *MockEC2APIMockRecorder) DescribeClassicLinkInstancesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClassicLinkInstancesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClassicLinkInstancesPages), arg0, arg1)
-}
-
-// DescribeClassicLinkInstancesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeClassicLinkInstancesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClassicLinkInstancesInput, arg2 func(*ec2.DescribeClassicLinkInstancesOutput, 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, "DescribeClassicLinkInstancesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeClassicLinkInstancesPagesWithContext indicates an expected call of DescribeClassicLinkInstancesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeClassicLinkInstancesPagesWithContext(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, "DescribeClassicLinkInstancesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClassicLinkInstancesPagesWithContext), varargs...)
-}
-
-// DescribeClassicLinkInstancesRequest mocks base method.
-func (m *MockEC2API) DescribeClassicLinkInstancesRequest(arg0 *ec2.DescribeClassicLinkInstancesInput) (*request.Request, *ec2.DescribeClassicLinkInstancesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeClassicLinkInstancesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeClassicLinkInstancesOutput)
-	return ret0, ret1
-}
-
-// DescribeClassicLinkInstancesRequest indicates an expected call of DescribeClassicLinkInstancesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeClassicLinkInstancesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClassicLinkInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClassicLinkInstancesRequest), arg0)
-}
-
-// DescribeClassicLinkInstancesWithContext mocks base method.
-func (m *MockEC2API) DescribeClassicLinkInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeClassicLinkInstancesInput, arg2 ...request.Option) (*ec2.DescribeClassicLinkInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeClassicLinkInstancesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeClassicLinkInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeClassicLinkInstancesWithContext indicates an expected call of DescribeClassicLinkInstancesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeClassicLinkInstancesWithContext(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, "DescribeClassicLinkInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClassicLinkInstancesWithContext), varargs...)
-}
-
-// DescribeClientVpnAuthorizationRules mocks base method.
-func (m *MockEC2API) DescribeClientVpnAuthorizationRules(arg0 *ec2.DescribeClientVpnAuthorizationRulesInput) (*ec2.DescribeClientVpnAuthorizationRulesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRules", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeClientVpnAuthorizationRulesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeClientVpnAuthorizationRules indicates an expected call of DescribeClientVpnAuthorizationRules.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnAuthorizationRules(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRules", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRules), arg0)
-}
-
-// DescribeClientVpnAuthorizationRulesPages mocks base method.
-func (m *MockEC2API) DescribeClientVpnAuthorizationRulesPages(arg0 *ec2.DescribeClientVpnAuthorizationRulesInput, arg1 func(*ec2.DescribeClientVpnAuthorizationRulesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRulesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeClientVpnAuthorizationRulesPages indicates an expected call of DescribeClientVpnAuthorizationRulesPages.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnAuthorizationRulesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRulesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRulesPages), arg0, arg1)
-}
-
-// DescribeClientVpnAuthorizationRulesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeClientVpnAuthorizationRulesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnAuthorizationRulesInput, arg2 func(*ec2.DescribeClientVpnAuthorizationRulesOutput, 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, "DescribeClientVpnAuthorizationRulesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeClientVpnAuthorizationRulesPagesWithContext indicates an expected call of DescribeClientVpnAuthorizationRulesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnAuthorizationRulesPagesWithContext(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, "DescribeClientVpnAuthorizationRulesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRulesPagesWithContext), varargs...)
-}
-
-// DescribeClientVpnAuthorizationRulesRequest mocks base method.
-func (m *MockEC2API) DescribeClientVpnAuthorizationRulesRequest(arg0 *ec2.DescribeClientVpnAuthorizationRulesInput) (*request.Request, *ec2.DescribeClientVpnAuthorizationRulesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRulesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeClientVpnAuthorizationRulesOutput)
-	return ret0, ret1
-}
-
-// DescribeClientVpnAuthorizationRulesRequest indicates an expected call of DescribeClientVpnAuthorizationRulesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnAuthorizationRulesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRulesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRulesRequest), arg0)
-}
-
-// DescribeClientVpnAuthorizationRulesWithContext mocks base method.
-func (m *MockEC2API) DescribeClientVpnAuthorizationRulesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnAuthorizationRulesInput, arg2 ...request.Option) (*ec2.DescribeClientVpnAuthorizationRulesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRulesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeClientVpnAuthorizationRulesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeClientVpnAuthorizationRulesWithContext indicates an expected call of DescribeClientVpnAuthorizationRulesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnAuthorizationRulesWithContext(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, "DescribeClientVpnAuthorizationRulesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRulesWithContext), varargs...)
-}
-
-// DescribeClientVpnConnections mocks base method.
-func (m *MockEC2API) DescribeClientVpnConnections(arg0 *ec2.DescribeClientVpnConnectionsInput) (*ec2.DescribeClientVpnConnectionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeClientVpnConnections", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeClientVpnConnectionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeClientVpnConnections indicates an expected call of DescribeClientVpnConnections.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnConnections(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnections", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnections), arg0)
-}
-
-// DescribeClientVpnConnectionsPages mocks base method.
-func (m *MockEC2API) DescribeClientVpnConnectionsPages(arg0 *ec2.DescribeClientVpnConnectionsInput, arg1 func(*ec2.DescribeClientVpnConnectionsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeClientVpnConnectionsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeClientVpnConnectionsPages indicates an expected call of DescribeClientVpnConnectionsPages.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnConnectionsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnectionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnectionsPages), arg0, arg1)
-}
-
-// DescribeClientVpnConnectionsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeClientVpnConnectionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnConnectionsInput, arg2 func(*ec2.DescribeClientVpnConnectionsOutput, 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, "DescribeClientVpnConnectionsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeClientVpnConnectionsPagesWithContext indicates an expected call of DescribeClientVpnConnectionsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnConnectionsPagesWithContext(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, "DescribeClientVpnConnectionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnectionsPagesWithContext), varargs...)
-}
-
-// DescribeClientVpnConnectionsRequest mocks base method.
-func (m *MockEC2API) DescribeClientVpnConnectionsRequest(arg0 *ec2.DescribeClientVpnConnectionsInput) (*request.Request, *ec2.DescribeClientVpnConnectionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeClientVpnConnectionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeClientVpnConnectionsOutput)
-	return ret0, ret1
-}
-
-// DescribeClientVpnConnectionsRequest indicates an expected call of DescribeClientVpnConnectionsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnConnectionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnectionsRequest), arg0)
-}
-
-// DescribeClientVpnConnectionsWithContext mocks base method.
-func (m *MockEC2API) DescribeClientVpnConnectionsWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnConnectionsInput, arg2 ...request.Option) (*ec2.DescribeClientVpnConnectionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeClientVpnConnectionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeClientVpnConnectionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeClientVpnConnectionsWithContext indicates an expected call of DescribeClientVpnConnectionsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnConnectionsWithContext(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, "DescribeClientVpnConnectionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnectionsWithContext), varargs...)
-}
-
-// DescribeClientVpnEndpoints mocks base method.
-func (m *MockEC2API) DescribeClientVpnEndpoints(arg0 *ec2.DescribeClientVpnEndpointsInput) (*ec2.DescribeClientVpnEndpointsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeClientVpnEndpoints", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeClientVpnEndpointsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeClientVpnEndpoints indicates an expected call of DescribeClientVpnEndpoints.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnEndpoints(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnEndpoints", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnEndpoints), arg0)
-}
-
-// DescribeClientVpnEndpointsPages mocks base method.
-func (m *MockEC2API) DescribeClientVpnEndpointsPages(arg0 *ec2.DescribeClientVpnEndpointsInput, arg1 func(*ec2.DescribeClientVpnEndpointsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeClientVpnEndpointsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeClientVpnEndpointsPages indicates an expected call of DescribeClientVpnEndpointsPages.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnEndpointsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnEndpointsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnEndpointsPages), arg0, arg1)
-}
-
-// DescribeClientVpnEndpointsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeClientVpnEndpointsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnEndpointsInput, arg2 func(*ec2.DescribeClientVpnEndpointsOutput, 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, "DescribeClientVpnEndpointsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeClientVpnEndpointsPagesWithContext indicates an expected call of DescribeClientVpnEndpointsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnEndpointsPagesWithContext(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, "DescribeClientVpnEndpointsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnEndpointsPagesWithContext), varargs...)
-}
-
-// DescribeClientVpnEndpointsRequest mocks base method.
-func (m *MockEC2API) DescribeClientVpnEndpointsRequest(arg0 *ec2.DescribeClientVpnEndpointsInput) (*request.Request, *ec2.DescribeClientVpnEndpointsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeClientVpnEndpointsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeClientVpnEndpointsOutput)
-	return ret0, ret1
-}
-
-// DescribeClientVpnEndpointsRequest indicates an expected call of DescribeClientVpnEndpointsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnEndpointsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnEndpointsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnEndpointsRequest), arg0)
-}
-
-// DescribeClientVpnEndpointsWithContext mocks base method.
-func (m *MockEC2API) DescribeClientVpnEndpointsWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnEndpointsInput, arg2 ...request.Option) (*ec2.DescribeClientVpnEndpointsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeClientVpnEndpointsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeClientVpnEndpointsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeClientVpnEndpointsWithContext indicates an expected call of DescribeClientVpnEndpointsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnEndpointsWithContext(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, "DescribeClientVpnEndpointsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnEndpointsWithContext), varargs...)
-}
-
-// DescribeClientVpnRoutes mocks base method.
-func (m *MockEC2API) DescribeClientVpnRoutes(arg0 *ec2.DescribeClientVpnRoutesInput) (*ec2.DescribeClientVpnRoutesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeClientVpnRoutes", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeClientVpnRoutesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeClientVpnRoutes indicates an expected call of DescribeClientVpnRoutes.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnRoutes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnRoutes", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnRoutes), arg0)
-}
-
-// DescribeClientVpnRoutesPages mocks base method.
-func (m *MockEC2API) DescribeClientVpnRoutesPages(arg0 *ec2.DescribeClientVpnRoutesInput, arg1 func(*ec2.DescribeClientVpnRoutesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeClientVpnRoutesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeClientVpnRoutesPages indicates an expected call of DescribeClientVpnRoutesPages.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnRoutesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnRoutesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnRoutesPages), arg0, arg1)
-}
-
-// DescribeClientVpnRoutesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeClientVpnRoutesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnRoutesInput, arg2 func(*ec2.DescribeClientVpnRoutesOutput, 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, "DescribeClientVpnRoutesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeClientVpnRoutesPagesWithContext indicates an expected call of DescribeClientVpnRoutesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnRoutesPagesWithContext(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, "DescribeClientVpnRoutesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnRoutesPagesWithContext), varargs...)
-}
-
-// DescribeClientVpnRoutesRequest mocks base method.
-func (m *MockEC2API) DescribeClientVpnRoutesRequest(arg0 *ec2.DescribeClientVpnRoutesInput) (*request.Request, *ec2.DescribeClientVpnRoutesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeClientVpnRoutesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeClientVpnRoutesOutput)
-	return ret0, ret1
-}
-
-// DescribeClientVpnRoutesRequest indicates an expected call of DescribeClientVpnRoutesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnRoutesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnRoutesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnRoutesRequest), arg0)
-}
-
-// DescribeClientVpnRoutesWithContext mocks base method.
-func (m *MockEC2API) DescribeClientVpnRoutesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnRoutesInput, arg2 ...request.Option) (*ec2.DescribeClientVpnRoutesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeClientVpnRoutesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeClientVpnRoutesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeClientVpnRoutesWithContext indicates an expected call of DescribeClientVpnRoutesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnRoutesWithContext(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, "DescribeClientVpnRoutesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnRoutesWithContext), varargs...)
-}
-
-// DescribeClientVpnTargetNetworks mocks base method.
-func (m *MockEC2API) DescribeClientVpnTargetNetworks(arg0 *ec2.DescribeClientVpnTargetNetworksInput) (*ec2.DescribeClientVpnTargetNetworksOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeClientVpnTargetNetworks", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeClientVpnTargetNetworksOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeClientVpnTargetNetworks indicates an expected call of DescribeClientVpnTargetNetworks.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnTargetNetworks(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnTargetNetworks", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnTargetNetworks), arg0)
-}
-
-// DescribeClientVpnTargetNetworksPages mocks base method.
-func (m *MockEC2API) DescribeClientVpnTargetNetworksPages(arg0 *ec2.DescribeClientVpnTargetNetworksInput, arg1 func(*ec2.DescribeClientVpnTargetNetworksOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeClientVpnTargetNetworksPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeClientVpnTargetNetworksPages indicates an expected call of DescribeClientVpnTargetNetworksPages.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnTargetNetworksPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnTargetNetworksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnTargetNetworksPages), arg0, arg1)
-}
-
-// DescribeClientVpnTargetNetworksPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeClientVpnTargetNetworksPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnTargetNetworksInput, arg2 func(*ec2.DescribeClientVpnTargetNetworksOutput, 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, "DescribeClientVpnTargetNetworksPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeClientVpnTargetNetworksPagesWithContext indicates an expected call of DescribeClientVpnTargetNetworksPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnTargetNetworksPagesWithContext(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, "DescribeClientVpnTargetNetworksPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnTargetNetworksPagesWithContext), varargs...)
-}
-
-// DescribeClientVpnTargetNetworksRequest mocks base method.
-func (m *MockEC2API) DescribeClientVpnTargetNetworksRequest(arg0 *ec2.DescribeClientVpnTargetNetworksInput) (*request.Request, *ec2.DescribeClientVpnTargetNetworksOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeClientVpnTargetNetworksRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeClientVpnTargetNetworksOutput)
-	return ret0, ret1
-}
-
-// DescribeClientVpnTargetNetworksRequest indicates an expected call of DescribeClientVpnTargetNetworksRequest.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnTargetNetworksRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnTargetNetworksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnTargetNetworksRequest), arg0)
-}
-
-// DescribeClientVpnTargetNetworksWithContext mocks base method.
-func (m *MockEC2API) DescribeClientVpnTargetNetworksWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnTargetNetworksInput, arg2 ...request.Option) (*ec2.DescribeClientVpnTargetNetworksOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeClientVpnTargetNetworksWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeClientVpnTargetNetworksOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeClientVpnTargetNetworksWithContext indicates an expected call of DescribeClientVpnTargetNetworksWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeClientVpnTargetNetworksWithContext(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, "DescribeClientVpnTargetNetworksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnTargetNetworksWithContext), varargs...)
-}
-
-// DescribeCoipPools mocks base method.
-func (m *MockEC2API) DescribeCoipPools(arg0 *ec2.DescribeCoipPoolsInput) (*ec2.DescribeCoipPoolsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeCoipPools", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeCoipPoolsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeCoipPools indicates an expected call of DescribeCoipPools.
-func (mr *MockEC2APIMockRecorder) DescribeCoipPools(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCoipPools", reflect.TypeOf((*MockEC2API)(nil).DescribeCoipPools), arg0)
-}
-
-// DescribeCoipPoolsPages mocks base method.
-func (m *MockEC2API) DescribeCoipPoolsPages(arg0 *ec2.DescribeCoipPoolsInput, arg1 func(*ec2.DescribeCoipPoolsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeCoipPoolsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeCoipPoolsPages indicates an expected call of DescribeCoipPoolsPages.
-func (mr *MockEC2APIMockRecorder) DescribeCoipPoolsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCoipPoolsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeCoipPoolsPages), arg0, arg1)
-}
-
-// DescribeCoipPoolsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeCoipPoolsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeCoipPoolsInput, arg2 func(*ec2.DescribeCoipPoolsOutput, 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, "DescribeCoipPoolsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeCoipPoolsPagesWithContext indicates an expected call of DescribeCoipPoolsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeCoipPoolsPagesWithContext(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, "DescribeCoipPoolsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCoipPoolsPagesWithContext), varargs...)
-}
-
-// DescribeCoipPoolsRequest mocks base method.
-func (m *MockEC2API) DescribeCoipPoolsRequest(arg0 *ec2.DescribeCoipPoolsInput) (*request.Request, *ec2.DescribeCoipPoolsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeCoipPoolsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeCoipPoolsOutput)
-	return ret0, ret1
-}
-
-// DescribeCoipPoolsRequest indicates an expected call of DescribeCoipPoolsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeCoipPoolsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCoipPoolsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeCoipPoolsRequest), arg0)
-}
-
-// DescribeCoipPoolsWithContext mocks base method.
-func (m *MockEC2API) DescribeCoipPoolsWithContext(arg0 context.Context, arg1 *ec2.DescribeCoipPoolsInput, arg2 ...request.Option) (*ec2.DescribeCoipPoolsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeCoipPoolsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeCoipPoolsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeCoipPoolsWithContext indicates an expected call of DescribeCoipPoolsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeCoipPoolsWithContext(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, "DescribeCoipPoolsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCoipPoolsWithContext), varargs...)
-}
-
-// DescribeConversionTasks mocks base method.
-func (m *MockEC2API) DescribeConversionTasks(arg0 *ec2.DescribeConversionTasksInput) (*ec2.DescribeConversionTasksOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeConversionTasks", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeConversionTasksOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeConversionTasks indicates an expected call of DescribeConversionTasks.
-func (mr *MockEC2APIMockRecorder) DescribeConversionTasks(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConversionTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeConversionTasks), arg0)
-}
-
-// DescribeConversionTasksRequest mocks base method.
-func (m *MockEC2API) DescribeConversionTasksRequest(arg0 *ec2.DescribeConversionTasksInput) (*request.Request, *ec2.DescribeConversionTasksOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeConversionTasksRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeConversionTasksOutput)
-	return ret0, ret1
-}
-
-// DescribeConversionTasksRequest indicates an expected call of DescribeConversionTasksRequest.
-func (mr *MockEC2APIMockRecorder) DescribeConversionTasksRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConversionTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeConversionTasksRequest), arg0)
-}
-
-// DescribeConversionTasksWithContext mocks base method.
-func (m *MockEC2API) DescribeConversionTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeConversionTasksInput, arg2 ...request.Option) (*ec2.DescribeConversionTasksOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeConversionTasksWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeConversionTasksOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeConversionTasksWithContext indicates an expected call of DescribeConversionTasksWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeConversionTasksWithContext(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, "DescribeConversionTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeConversionTasksWithContext), varargs...)
-}
-
-// DescribeCustomerGateways mocks base method.
-func (m *MockEC2API) DescribeCustomerGateways(arg0 *ec2.DescribeCustomerGatewaysInput) (*ec2.DescribeCustomerGatewaysOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeCustomerGateways", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeCustomerGatewaysOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeCustomerGateways indicates an expected call of DescribeCustomerGateways.
-func (mr *MockEC2APIMockRecorder) DescribeCustomerGateways(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomerGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeCustomerGateways), arg0)
-}
-
-// DescribeCustomerGatewaysRequest mocks base method.
-func (m *MockEC2API) DescribeCustomerGatewaysRequest(arg0 *ec2.DescribeCustomerGatewaysInput) (*request.Request, *ec2.DescribeCustomerGatewaysOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeCustomerGatewaysRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeCustomerGatewaysOutput)
-	return ret0, ret1
-}
-
-// DescribeCustomerGatewaysRequest indicates an expected call of DescribeCustomerGatewaysRequest.
-func (mr *MockEC2APIMockRecorder) DescribeCustomerGatewaysRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomerGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeCustomerGatewaysRequest), arg0)
-}
-
-// DescribeCustomerGatewaysWithContext mocks base method.
-func (m *MockEC2API) DescribeCustomerGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeCustomerGatewaysInput, arg2 ...request.Option) (*ec2.DescribeCustomerGatewaysOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeCustomerGatewaysWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeCustomerGatewaysOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeCustomerGatewaysWithContext indicates an expected call of DescribeCustomerGatewaysWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeCustomerGatewaysWithContext(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, "DescribeCustomerGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCustomerGatewaysWithContext), varargs...)
-}
-
-// DescribeDhcpOptions mocks base method.
-func (m *MockEC2API) DescribeDhcpOptions(arg0 *ec2.DescribeDhcpOptionsInput) (*ec2.DescribeDhcpOptionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeDhcpOptions", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeDhcpOptionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeDhcpOptions indicates an expected call of DescribeDhcpOptions.
-func (mr *MockEC2APIMockRecorder) DescribeDhcpOptions(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptions", reflect.TypeOf((*MockEC2API)(nil).DescribeDhcpOptions), arg0)
-}
-
-// DescribeDhcpOptionsPages mocks base method.
-func (m *MockEC2API) DescribeDhcpOptionsPages(arg0 *ec2.DescribeDhcpOptionsInput, arg1 func(*ec2.DescribeDhcpOptionsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeDhcpOptionsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeDhcpOptionsPages indicates an expected call of DescribeDhcpOptionsPages.
-func (mr *MockEC2APIMockRecorder) DescribeDhcpOptionsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeDhcpOptionsPages), arg0, arg1)
-}
-
-// DescribeDhcpOptionsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeDhcpOptionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeDhcpOptionsInput, arg2 func(*ec2.DescribeDhcpOptionsOutput, 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, "DescribeDhcpOptionsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeDhcpOptionsPagesWithContext indicates an expected call of DescribeDhcpOptionsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeDhcpOptionsPagesWithContext(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, "DescribeDhcpOptionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeDhcpOptionsPagesWithContext), varargs...)
-}
-
-// DescribeDhcpOptionsRequest mocks base method.
-func (m *MockEC2API) DescribeDhcpOptionsRequest(arg0 *ec2.DescribeDhcpOptionsInput) (*request.Request, *ec2.DescribeDhcpOptionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeDhcpOptionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeDhcpOptionsOutput)
-	return ret0, ret1
-}
-
-// DescribeDhcpOptionsRequest indicates an expected call of DescribeDhcpOptionsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeDhcpOptionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeDhcpOptionsRequest), arg0)
-}
-
-// DescribeDhcpOptionsWithContext mocks base method.
-func (m *MockEC2API) DescribeDhcpOptionsWithContext(arg0 context.Context, arg1 *ec2.DescribeDhcpOptionsInput, arg2 ...request.Option) (*ec2.DescribeDhcpOptionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeDhcpOptionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeDhcpOptionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeDhcpOptionsWithContext indicates an expected call of DescribeDhcpOptionsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeDhcpOptionsWithContext(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, "DescribeDhcpOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeDhcpOptionsWithContext), varargs...)
-}
-
-// DescribeEgressOnlyInternetGateways mocks base method.
-func (m *MockEC2API) DescribeEgressOnlyInternetGateways(arg0 *ec2.DescribeEgressOnlyInternetGatewaysInput) (*ec2.DescribeEgressOnlyInternetGatewaysOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGateways", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeEgressOnlyInternetGatewaysOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeEgressOnlyInternetGateways indicates an expected call of DescribeEgressOnlyInternetGateways.
-func (mr *MockEC2APIMockRecorder) DescribeEgressOnlyInternetGateways(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEgressOnlyInternetGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeEgressOnlyInternetGateways), arg0)
-}
-
-// DescribeEgressOnlyInternetGatewaysPages mocks base method.
-func (m *MockEC2API) DescribeEgressOnlyInternetGatewaysPages(arg0 *ec2.DescribeEgressOnlyInternetGatewaysInput, arg1 func(*ec2.DescribeEgressOnlyInternetGatewaysOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGatewaysPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeEgressOnlyInternetGatewaysPages indicates an expected call of DescribeEgressOnlyInternetGatewaysPages.
-func (mr *MockEC2APIMockRecorder) DescribeEgressOnlyInternetGatewaysPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEgressOnlyInternetGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeEgressOnlyInternetGatewaysPages), arg0, arg1)
-}
-
-// DescribeEgressOnlyInternetGatewaysPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeEgressOnlyInternetGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeEgressOnlyInternetGatewaysInput, arg2 func(*ec2.DescribeEgressOnlyInternetGatewaysOutput, 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, "DescribeEgressOnlyInternetGatewaysPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeEgressOnlyInternetGatewaysPagesWithContext indicates an expected call of DescribeEgressOnlyInternetGatewaysPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeEgressOnlyInternetGatewaysPagesWithContext(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, "DescribeEgressOnlyInternetGatewaysPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeEgressOnlyInternetGatewaysPagesWithContext), varargs...)
-}
-
-// DescribeEgressOnlyInternetGatewaysRequest mocks base method.
-func (m *MockEC2API) DescribeEgressOnlyInternetGatewaysRequest(arg0 *ec2.DescribeEgressOnlyInternetGatewaysInput) (*request.Request, *ec2.DescribeEgressOnlyInternetGatewaysOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGatewaysRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeEgressOnlyInternetGatewaysOutput)
-	return ret0, ret1
-}
-
-// DescribeEgressOnlyInternetGatewaysRequest indicates an expected call of DescribeEgressOnlyInternetGatewaysRequest.
-func (mr *MockEC2APIMockRecorder) DescribeEgressOnlyInternetGatewaysRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEgressOnlyInternetGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeEgressOnlyInternetGatewaysRequest), arg0)
-}
-
-// DescribeEgressOnlyInternetGatewaysWithContext mocks base method.
-func (m *MockEC2API) DescribeEgressOnlyInternetGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeEgressOnlyInternetGatewaysInput, arg2 ...request.Option) (*ec2.DescribeEgressOnlyInternetGatewaysOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGatewaysWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeEgressOnlyInternetGatewaysOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeEgressOnlyInternetGatewaysWithContext indicates an expected call of DescribeEgressOnlyInternetGatewaysWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeEgressOnlyInternetGatewaysWithContext(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, "DescribeEgressOnlyInternetGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeEgressOnlyInternetGatewaysWithContext), varargs...)
-}
-
-// DescribeElasticGpus mocks base method.
-func (m *MockEC2API) DescribeElasticGpus(arg0 *ec2.DescribeElasticGpusInput) (*ec2.DescribeElasticGpusOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeElasticGpus", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeElasticGpusOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeElasticGpus indicates an expected call of DescribeElasticGpus.
-func (mr *MockEC2APIMockRecorder) DescribeElasticGpus(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeElasticGpus", reflect.TypeOf((*MockEC2API)(nil).DescribeElasticGpus), arg0)
-}
-
-// DescribeElasticGpusRequest mocks base method.
-func (m *MockEC2API) DescribeElasticGpusRequest(arg0 *ec2.DescribeElasticGpusInput) (*request.Request, *ec2.DescribeElasticGpusOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeElasticGpusRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeElasticGpusOutput)
-	return ret0, ret1
-}
-
-// DescribeElasticGpusRequest indicates an expected call of DescribeElasticGpusRequest.
-func (mr *MockEC2APIMockRecorder) DescribeElasticGpusRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeElasticGpusRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeElasticGpusRequest), arg0)
-}
-
-// DescribeElasticGpusWithContext mocks base method.
-func (m *MockEC2API) DescribeElasticGpusWithContext(arg0 context.Context, arg1 *ec2.DescribeElasticGpusInput, arg2 ...request.Option) (*ec2.DescribeElasticGpusOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeElasticGpusWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeElasticGpusOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeElasticGpusWithContext indicates an expected call of DescribeElasticGpusWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeElasticGpusWithContext(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, "DescribeElasticGpusWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeElasticGpusWithContext), varargs...)
-}
-
-// DescribeExportImageTasks mocks base method.
-func (m *MockEC2API) DescribeExportImageTasks(arg0 *ec2.DescribeExportImageTasksInput) (*ec2.DescribeExportImageTasksOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeExportImageTasks", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeExportImageTasksOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeExportImageTasks indicates an expected call of DescribeExportImageTasks.
-func (mr *MockEC2APIMockRecorder) DescribeExportImageTasks(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportImageTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeExportImageTasks), arg0)
-}
-
-// DescribeExportImageTasksPages mocks base method.
-func (m *MockEC2API) DescribeExportImageTasksPages(arg0 *ec2.DescribeExportImageTasksInput, arg1 func(*ec2.DescribeExportImageTasksOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeExportImageTasksPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeExportImageTasksPages indicates an expected call of DescribeExportImageTasksPages.
-func (mr *MockEC2APIMockRecorder) DescribeExportImageTasksPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportImageTasksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeExportImageTasksPages), arg0, arg1)
-}
-
-// DescribeExportImageTasksPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeExportImageTasksPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeExportImageTasksInput, arg2 func(*ec2.DescribeExportImageTasksOutput, 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, "DescribeExportImageTasksPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeExportImageTasksPagesWithContext indicates an expected call of DescribeExportImageTasksPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeExportImageTasksPagesWithContext(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, "DescribeExportImageTasksPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeExportImageTasksPagesWithContext), varargs...)
-}
-
-// DescribeExportImageTasksRequest mocks base method.
-func (m *MockEC2API) DescribeExportImageTasksRequest(arg0 *ec2.DescribeExportImageTasksInput) (*request.Request, *ec2.DescribeExportImageTasksOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeExportImageTasksRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeExportImageTasksOutput)
-	return ret0, ret1
-}
-
-// DescribeExportImageTasksRequest indicates an expected call of DescribeExportImageTasksRequest.
-func (mr *MockEC2APIMockRecorder) DescribeExportImageTasksRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportImageTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeExportImageTasksRequest), arg0)
-}
-
-// DescribeExportImageTasksWithContext mocks base method.
-func (m *MockEC2API) DescribeExportImageTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeExportImageTasksInput, arg2 ...request.Option) (*ec2.DescribeExportImageTasksOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeExportImageTasksWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeExportImageTasksOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeExportImageTasksWithContext indicates an expected call of DescribeExportImageTasksWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeExportImageTasksWithContext(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, "DescribeExportImageTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeExportImageTasksWithContext), varargs...)
-}
-
-// DescribeExportTasks mocks base method.
-func (m *MockEC2API) DescribeExportTasks(arg0 *ec2.DescribeExportTasksInput) (*ec2.DescribeExportTasksOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeExportTasks", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeExportTasksOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeExportTasks indicates an expected call of DescribeExportTasks.
-func (mr *MockEC2APIMockRecorder) DescribeExportTasks(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeExportTasks), arg0)
-}
-
-// DescribeExportTasksRequest mocks base method.
-func (m *MockEC2API) DescribeExportTasksRequest(arg0 *ec2.DescribeExportTasksInput) (*request.Request, *ec2.DescribeExportTasksOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeExportTasksRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeExportTasksOutput)
-	return ret0, ret1
-}
-
-// DescribeExportTasksRequest indicates an expected call of DescribeExportTasksRequest.
-func (mr *MockEC2APIMockRecorder) DescribeExportTasksRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeExportTasksRequest), arg0)
-}
-
-// DescribeExportTasksWithContext mocks base method.
-func (m *MockEC2API) DescribeExportTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeExportTasksInput, arg2 ...request.Option) (*ec2.DescribeExportTasksOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeExportTasksWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeExportTasksOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeExportTasksWithContext indicates an expected call of DescribeExportTasksWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeExportTasksWithContext(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, "DescribeExportTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeExportTasksWithContext), varargs...)
-}
-
-// DescribeFastLaunchImages mocks base method.
-func (m *MockEC2API) DescribeFastLaunchImages(arg0 *ec2.DescribeFastLaunchImagesInput) (*ec2.DescribeFastLaunchImagesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeFastLaunchImages", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeFastLaunchImagesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeFastLaunchImages indicates an expected call of DescribeFastLaunchImages.
-func (mr *MockEC2APIMockRecorder) DescribeFastLaunchImages(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastLaunchImages", reflect.TypeOf((*MockEC2API)(nil).DescribeFastLaunchImages), arg0)
-}
-
-// DescribeFastLaunchImagesPages mocks base method.
-func (m *MockEC2API) DescribeFastLaunchImagesPages(arg0 *ec2.DescribeFastLaunchImagesInput, arg1 func(*ec2.DescribeFastLaunchImagesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeFastLaunchImagesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeFastLaunchImagesPages indicates an expected call of DescribeFastLaunchImagesPages.
-func (mr *MockEC2APIMockRecorder) DescribeFastLaunchImagesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastLaunchImagesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeFastLaunchImagesPages), arg0, arg1)
-}
-
-// DescribeFastLaunchImagesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeFastLaunchImagesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFastLaunchImagesInput, arg2 func(*ec2.DescribeFastLaunchImagesOutput, 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, "DescribeFastLaunchImagesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeFastLaunchImagesPagesWithContext indicates an expected call of DescribeFastLaunchImagesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeFastLaunchImagesPagesWithContext(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, "DescribeFastLaunchImagesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFastLaunchImagesPagesWithContext), varargs...)
-}
-
-// DescribeFastLaunchImagesRequest mocks base method.
-func (m *MockEC2API) DescribeFastLaunchImagesRequest(arg0 *ec2.DescribeFastLaunchImagesInput) (*request.Request, *ec2.DescribeFastLaunchImagesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeFastLaunchImagesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeFastLaunchImagesOutput)
-	return ret0, ret1
-}
-
-// DescribeFastLaunchImagesRequest indicates an expected call of DescribeFastLaunchImagesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeFastLaunchImagesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastLaunchImagesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFastLaunchImagesRequest), arg0)
-}
-
-// DescribeFastLaunchImagesWithContext mocks base method.
-func (m *MockEC2API) DescribeFastLaunchImagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFastLaunchImagesInput, arg2 ...request.Option) (*ec2.DescribeFastLaunchImagesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeFastLaunchImagesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeFastLaunchImagesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeFastLaunchImagesWithContext indicates an expected call of DescribeFastLaunchImagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeFastLaunchImagesWithContext(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, "DescribeFastLaunchImagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFastLaunchImagesWithContext), varargs...)
-}
-
-// DescribeFastSnapshotRestores mocks base method.
-func (m *MockEC2API) DescribeFastSnapshotRestores(arg0 *ec2.DescribeFastSnapshotRestoresInput) (*ec2.DescribeFastSnapshotRestoresOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeFastSnapshotRestores", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeFastSnapshotRestoresOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeFastSnapshotRestores indicates an expected call of DescribeFastSnapshotRestores.
-func (mr *MockEC2APIMockRecorder) DescribeFastSnapshotRestores(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastSnapshotRestores", reflect.TypeOf((*MockEC2API)(nil).DescribeFastSnapshotRestores), arg0)
-}
-
-// DescribeFastSnapshotRestoresPages mocks base method.
-func (m *MockEC2API) DescribeFastSnapshotRestoresPages(arg0 *ec2.DescribeFastSnapshotRestoresInput, arg1 func(*ec2.DescribeFastSnapshotRestoresOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeFastSnapshotRestoresPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeFastSnapshotRestoresPages indicates an expected call of DescribeFastSnapshotRestoresPages.
-func (mr *MockEC2APIMockRecorder) DescribeFastSnapshotRestoresPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastSnapshotRestoresPages", reflect.TypeOf((*MockEC2API)(nil).DescribeFastSnapshotRestoresPages), arg0, arg1)
-}
-
-// DescribeFastSnapshotRestoresPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeFastSnapshotRestoresPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFastSnapshotRestoresInput, arg2 func(*ec2.DescribeFastSnapshotRestoresOutput, 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, "DescribeFastSnapshotRestoresPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeFastSnapshotRestoresPagesWithContext indicates an expected call of DescribeFastSnapshotRestoresPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeFastSnapshotRestoresPagesWithContext(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, "DescribeFastSnapshotRestoresPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFastSnapshotRestoresPagesWithContext), varargs...)
-}
-
-// DescribeFastSnapshotRestoresRequest mocks base method.
-func (m *MockEC2API) DescribeFastSnapshotRestoresRequest(arg0 *ec2.DescribeFastSnapshotRestoresInput) (*request.Request, *ec2.DescribeFastSnapshotRestoresOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeFastSnapshotRestoresRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeFastSnapshotRestoresOutput)
-	return ret0, ret1
-}
-
-// DescribeFastSnapshotRestoresRequest indicates an expected call of DescribeFastSnapshotRestoresRequest.
-func (mr *MockEC2APIMockRecorder) DescribeFastSnapshotRestoresRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastSnapshotRestoresRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFastSnapshotRestoresRequest), arg0)
-}
-
-// DescribeFastSnapshotRestoresWithContext mocks base method.
-func (m *MockEC2API) DescribeFastSnapshotRestoresWithContext(arg0 context.Context, arg1 *ec2.DescribeFastSnapshotRestoresInput, arg2 ...request.Option) (*ec2.DescribeFastSnapshotRestoresOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeFastSnapshotRestoresWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeFastSnapshotRestoresOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeFastSnapshotRestoresWithContext indicates an expected call of DescribeFastSnapshotRestoresWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeFastSnapshotRestoresWithContext(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, "DescribeFastSnapshotRestoresWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFastSnapshotRestoresWithContext), varargs...)
-}
-
-// DescribeFleetHistory mocks base method.
-func (m *MockEC2API) DescribeFleetHistory(arg0 *ec2.DescribeFleetHistoryInput) (*ec2.DescribeFleetHistoryOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeFleetHistory", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeFleetHistoryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeFleetHistory indicates an expected call of DescribeFleetHistory.
-func (mr *MockEC2APIMockRecorder) DescribeFleetHistory(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetHistory", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetHistory), arg0)
-}
-
-// DescribeFleetHistoryRequest mocks base method.
-func (m *MockEC2API) DescribeFleetHistoryRequest(arg0 *ec2.DescribeFleetHistoryInput) (*request.Request, *ec2.DescribeFleetHistoryOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeFleetHistoryRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeFleetHistoryOutput)
-	return ret0, ret1
-}
-
-// DescribeFleetHistoryRequest indicates an expected call of DescribeFleetHistoryRequest.
-func (mr *MockEC2APIMockRecorder) DescribeFleetHistoryRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetHistoryRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetHistoryRequest), arg0)
-}
-
-// DescribeFleetHistoryWithContext mocks base method.
-func (m *MockEC2API) DescribeFleetHistoryWithContext(arg0 context.Context, arg1 *ec2.DescribeFleetHistoryInput, arg2 ...request.Option) (*ec2.DescribeFleetHistoryOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeFleetHistoryWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeFleetHistoryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeFleetHistoryWithContext indicates an expected call of DescribeFleetHistoryWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeFleetHistoryWithContext(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, "DescribeFleetHistoryWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetHistoryWithContext), varargs...)
-}
-
-// DescribeFleetInstances mocks base method.
-func (m *MockEC2API) DescribeFleetInstances(arg0 *ec2.DescribeFleetInstancesInput) (*ec2.DescribeFleetInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeFleetInstances", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeFleetInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeFleetInstances indicates an expected call of DescribeFleetInstances.
-func (mr *MockEC2APIMockRecorder) DescribeFleetInstances(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetInstances), arg0)
-}
-
-// DescribeFleetInstancesRequest mocks base method.
-func (m *MockEC2API) DescribeFleetInstancesRequest(arg0 *ec2.DescribeFleetInstancesInput) (*request.Request, *ec2.DescribeFleetInstancesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeFleetInstancesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeFleetInstancesOutput)
-	return ret0, ret1
-}
-
-// DescribeFleetInstancesRequest indicates an expected call of DescribeFleetInstancesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeFleetInstancesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetInstancesRequest), arg0)
-}
-
-// DescribeFleetInstancesWithContext mocks base method.
-func (m *MockEC2API) DescribeFleetInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeFleetInstancesInput, arg2 ...request.Option) (*ec2.DescribeFleetInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeFleetInstancesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeFleetInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeFleetInstancesWithContext indicates an expected call of DescribeFleetInstancesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeFleetInstancesWithContext(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, "DescribeFleetInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetInstancesWithContext), varargs...)
-}
-
-// DescribeFleets mocks base method.
-func (m *MockEC2API) DescribeFleets(arg0 *ec2.DescribeFleetsInput) (*ec2.DescribeFleetsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeFleets", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeFleetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeFleets indicates an expected call of DescribeFleets.
-func (mr *MockEC2APIMockRecorder) DescribeFleets(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleets", reflect.TypeOf((*MockEC2API)(nil).DescribeFleets), arg0)
-}
-
-// DescribeFleetsPages mocks base method.
-func (m *MockEC2API) DescribeFleetsPages(arg0 *ec2.DescribeFleetsInput, arg1 func(*ec2.DescribeFleetsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeFleetsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeFleetsPages indicates an expected call of DescribeFleetsPages.
-func (mr *MockEC2APIMockRecorder) DescribeFleetsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetsPages), arg0, arg1)
-}
-
-// DescribeFleetsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeFleetsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFleetsInput, arg2 func(*ec2.DescribeFleetsOutput, 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, "DescribeFleetsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeFleetsPagesWithContext indicates an expected call of DescribeFleetsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeFleetsPagesWithContext(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, "DescribeFleetsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetsPagesWithContext), varargs...)
-}
-
-// DescribeFleetsRequest mocks base method.
-func (m *MockEC2API) DescribeFleetsRequest(arg0 *ec2.DescribeFleetsInput) (*request.Request, *ec2.DescribeFleetsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeFleetsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeFleetsOutput)
-	return ret0, ret1
-}
-
-// DescribeFleetsRequest indicates an expected call of DescribeFleetsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeFleetsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetsRequest), arg0)
-}
-
-// DescribeFleetsWithContext mocks base method.
-func (m *MockEC2API) DescribeFleetsWithContext(arg0 context.Context, arg1 *ec2.DescribeFleetsInput, arg2 ...request.Option) (*ec2.DescribeFleetsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeFleetsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeFleetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeFleetsWithContext indicates an expected call of DescribeFleetsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeFleetsWithContext(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, "DescribeFleetsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetsWithContext), varargs...)
-}
-
-// DescribeFlowLogs mocks base method.
-func (m *MockEC2API) DescribeFlowLogs(arg0 *ec2.DescribeFlowLogsInput) (*ec2.DescribeFlowLogsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeFlowLogs", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeFlowLogsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeFlowLogs indicates an expected call of DescribeFlowLogs.
-func (mr *MockEC2APIMockRecorder) DescribeFlowLogs(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFlowLogs", reflect.TypeOf((*MockEC2API)(nil).DescribeFlowLogs), arg0)
-}
-
-// DescribeFlowLogsPages mocks base method.
-func (m *MockEC2API) DescribeFlowLogsPages(arg0 *ec2.DescribeFlowLogsInput, arg1 func(*ec2.DescribeFlowLogsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeFlowLogsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeFlowLogsPages indicates an expected call of DescribeFlowLogsPages.
-func (mr *MockEC2APIMockRecorder) DescribeFlowLogsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFlowLogsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeFlowLogsPages), arg0, arg1)
-}
-
-// DescribeFlowLogsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeFlowLogsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFlowLogsInput, arg2 func(*ec2.DescribeFlowLogsOutput, 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, "DescribeFlowLogsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeFlowLogsPagesWithContext indicates an expected call of DescribeFlowLogsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeFlowLogsPagesWithContext(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, "DescribeFlowLogsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFlowLogsPagesWithContext), varargs...)
-}
-
-// DescribeFlowLogsRequest mocks base method.
-func (m *MockEC2API) DescribeFlowLogsRequest(arg0 *ec2.DescribeFlowLogsInput) (*request.Request, *ec2.DescribeFlowLogsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeFlowLogsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeFlowLogsOutput)
-	return ret0, ret1
-}
-
-// DescribeFlowLogsRequest indicates an expected call of DescribeFlowLogsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeFlowLogsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFlowLogsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFlowLogsRequest), arg0)
-}
-
-// DescribeFlowLogsWithContext mocks base method.
-func (m *MockEC2API) DescribeFlowLogsWithContext(arg0 context.Context, arg1 *ec2.DescribeFlowLogsInput, arg2 ...request.Option) (*ec2.DescribeFlowLogsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeFlowLogsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeFlowLogsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeFlowLogsWithContext indicates an expected call of DescribeFlowLogsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeFlowLogsWithContext(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, "DescribeFlowLogsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFlowLogsWithContext), varargs...)
-}
-
-// DescribeFpgaImageAttribute mocks base method.
-func (m *MockEC2API) DescribeFpgaImageAttribute(arg0 *ec2.DescribeFpgaImageAttributeInput) (*ec2.DescribeFpgaImageAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeFpgaImageAttribute", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeFpgaImageAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeFpgaImageAttribute indicates an expected call of DescribeFpgaImageAttribute.
-func (mr *MockEC2APIMockRecorder) DescribeFpgaImageAttribute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImageAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImageAttribute), arg0)
-}
-
-// DescribeFpgaImageAttributeRequest mocks base method.
-func (m *MockEC2API) DescribeFpgaImageAttributeRequest(arg0 *ec2.DescribeFpgaImageAttributeInput) (*request.Request, *ec2.DescribeFpgaImageAttributeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeFpgaImageAttributeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeFpgaImageAttributeOutput)
-	return ret0, ret1
-}
-
-// DescribeFpgaImageAttributeRequest indicates an expected call of DescribeFpgaImageAttributeRequest.
-func (mr *MockEC2APIMockRecorder) DescribeFpgaImageAttributeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImageAttributeRequest), arg0)
-}
-
-// DescribeFpgaImageAttributeWithContext mocks base method.
-func (m *MockEC2API) DescribeFpgaImageAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeFpgaImageAttributeInput, arg2 ...request.Option) (*ec2.DescribeFpgaImageAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeFpgaImageAttributeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeFpgaImageAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeFpgaImageAttributeWithContext indicates an expected call of DescribeFpgaImageAttributeWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeFpgaImageAttributeWithContext(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, "DescribeFpgaImageAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImageAttributeWithContext), varargs...)
-}
-
-// DescribeFpgaImages mocks base method.
-func (m *MockEC2API) DescribeFpgaImages(arg0 *ec2.DescribeFpgaImagesInput) (*ec2.DescribeFpgaImagesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeFpgaImages", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeFpgaImagesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeFpgaImages indicates an expected call of DescribeFpgaImages.
-func (mr *MockEC2APIMockRecorder) DescribeFpgaImages(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImages", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImages), arg0)
-}
-
-// DescribeFpgaImagesPages mocks base method.
-func (m *MockEC2API) DescribeFpgaImagesPages(arg0 *ec2.DescribeFpgaImagesInput, arg1 func(*ec2.DescribeFpgaImagesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeFpgaImagesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeFpgaImagesPages indicates an expected call of DescribeFpgaImagesPages.
-func (mr *MockEC2APIMockRecorder) DescribeFpgaImagesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImagesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImagesPages), arg0, arg1)
-}
-
-// DescribeFpgaImagesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeFpgaImagesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFpgaImagesInput, arg2 func(*ec2.DescribeFpgaImagesOutput, 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, "DescribeFpgaImagesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeFpgaImagesPagesWithContext indicates an expected call of DescribeFpgaImagesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeFpgaImagesPagesWithContext(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, "DescribeFpgaImagesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImagesPagesWithContext), varargs...)
-}
-
-// DescribeFpgaImagesRequest mocks base method.
-func (m *MockEC2API) DescribeFpgaImagesRequest(arg0 *ec2.DescribeFpgaImagesInput) (*request.Request, *ec2.DescribeFpgaImagesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeFpgaImagesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeFpgaImagesOutput)
-	return ret0, ret1
-}
-
-// DescribeFpgaImagesRequest indicates an expected call of DescribeFpgaImagesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeFpgaImagesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImagesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImagesRequest), arg0)
-}
-
-// DescribeFpgaImagesWithContext mocks base method.
-func (m *MockEC2API) DescribeFpgaImagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFpgaImagesInput, arg2 ...request.Option) (*ec2.DescribeFpgaImagesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeFpgaImagesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeFpgaImagesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeFpgaImagesWithContext indicates an expected call of DescribeFpgaImagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeFpgaImagesWithContext(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, "DescribeFpgaImagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImagesWithContext), varargs...)
-}
-
-// DescribeHostReservationOfferings mocks base method.
-func (m *MockEC2API) DescribeHostReservationOfferings(arg0 *ec2.DescribeHostReservationOfferingsInput) (*ec2.DescribeHostReservationOfferingsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeHostReservationOfferings", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeHostReservationOfferingsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeHostReservationOfferings indicates an expected call of DescribeHostReservationOfferings.
-func (mr *MockEC2APIMockRecorder) DescribeHostReservationOfferings(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationOfferings", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationOfferings), arg0)
-}
-
-// DescribeHostReservationOfferingsPages mocks base method.
-func (m *MockEC2API) DescribeHostReservationOfferingsPages(arg0 *ec2.DescribeHostReservationOfferingsInput, arg1 func(*ec2.DescribeHostReservationOfferingsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeHostReservationOfferingsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeHostReservationOfferingsPages indicates an expected call of DescribeHostReservationOfferingsPages.
-func (mr *MockEC2APIMockRecorder) DescribeHostReservationOfferingsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationOfferingsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationOfferingsPages), arg0, arg1)
-}
-
-// DescribeHostReservationOfferingsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeHostReservationOfferingsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeHostReservationOfferingsInput, arg2 func(*ec2.DescribeHostReservationOfferingsOutput, 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, "DescribeHostReservationOfferingsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeHostReservationOfferingsPagesWithContext indicates an expected call of DescribeHostReservationOfferingsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeHostReservationOfferingsPagesWithContext(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, "DescribeHostReservationOfferingsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationOfferingsPagesWithContext), varargs...)
-}
-
-// DescribeHostReservationOfferingsRequest mocks base method.
-func (m *MockEC2API) DescribeHostReservationOfferingsRequest(arg0 *ec2.DescribeHostReservationOfferingsInput) (*request.Request, *ec2.DescribeHostReservationOfferingsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeHostReservationOfferingsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeHostReservationOfferingsOutput)
-	return ret0, ret1
-}
-
-// DescribeHostReservationOfferingsRequest indicates an expected call of DescribeHostReservationOfferingsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeHostReservationOfferingsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationOfferingsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationOfferingsRequest), arg0)
-}
-
-// DescribeHostReservationOfferingsWithContext mocks base method.
-func (m *MockEC2API) DescribeHostReservationOfferingsWithContext(arg0 context.Context, arg1 *ec2.DescribeHostReservationOfferingsInput, arg2 ...request.Option) (*ec2.DescribeHostReservationOfferingsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeHostReservationOfferingsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeHostReservationOfferingsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeHostReservationOfferingsWithContext indicates an expected call of DescribeHostReservationOfferingsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeHostReservationOfferingsWithContext(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, "DescribeHostReservationOfferingsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationOfferingsWithContext), varargs...)
-}
-
-// DescribeHostReservations mocks base method.
-func (m *MockEC2API) DescribeHostReservations(arg0 *ec2.DescribeHostReservationsInput) (*ec2.DescribeHostReservationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeHostReservations", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeHostReservationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeHostReservations indicates an expected call of DescribeHostReservations.
-func (mr *MockEC2APIMockRecorder) DescribeHostReservations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservations", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservations), arg0)
-}
-
-// DescribeHostReservationsPages mocks base method.
-func (m *MockEC2API) DescribeHostReservationsPages(arg0 *ec2.DescribeHostReservationsInput, arg1 func(*ec2.DescribeHostReservationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeHostReservationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeHostReservationsPages indicates an expected call of DescribeHostReservationsPages.
-func (mr *MockEC2APIMockRecorder) DescribeHostReservationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationsPages), arg0, arg1)
-}
-
-// DescribeHostReservationsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeHostReservationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeHostReservationsInput, arg2 func(*ec2.DescribeHostReservationsOutput, 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, "DescribeHostReservationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeHostReservationsPagesWithContext indicates an expected call of DescribeHostReservationsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeHostReservationsPagesWithContext(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, "DescribeHostReservationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationsPagesWithContext), varargs...)
-}
-
-// DescribeHostReservationsRequest mocks base method.
-func (m *MockEC2API) DescribeHostReservationsRequest(arg0 *ec2.DescribeHostReservationsInput) (*request.Request, *ec2.DescribeHostReservationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeHostReservationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeHostReservationsOutput)
-	return ret0, ret1
-}
-
-// DescribeHostReservationsRequest indicates an expected call of DescribeHostReservationsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeHostReservationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationsRequest), arg0)
-}
-
-// DescribeHostReservationsWithContext mocks base method.
-func (m *MockEC2API) DescribeHostReservationsWithContext(arg0 context.Context, arg1 *ec2.DescribeHostReservationsInput, arg2 ...request.Option) (*ec2.DescribeHostReservationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeHostReservationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeHostReservationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeHostReservationsWithContext indicates an expected call of DescribeHostReservationsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeHostReservationsWithContext(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, "DescribeHostReservationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationsWithContext), varargs...)
-}
-
-// DescribeHosts mocks base method.
-func (m *MockEC2API) DescribeHosts(arg0 *ec2.DescribeHostsInput) (*ec2.DescribeHostsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeHosts", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeHostsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeHosts indicates an expected call of DescribeHosts.
-func (mr *MockEC2APIMockRecorder) DescribeHosts(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHosts", reflect.TypeOf((*MockEC2API)(nil).DescribeHosts), arg0)
-}
-
-// DescribeHostsPages mocks base method.
-func (m *MockEC2API) DescribeHostsPages(arg0 *ec2.DescribeHostsInput, arg1 func(*ec2.DescribeHostsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeHostsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeHostsPages indicates an expected call of DescribeHostsPages.
-func (mr *MockEC2APIMockRecorder) DescribeHostsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeHostsPages), arg0, arg1)
-}
-
-// DescribeHostsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeHostsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeHostsInput, arg2 func(*ec2.DescribeHostsOutput, 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, "DescribeHostsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeHostsPagesWithContext indicates an expected call of DescribeHostsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeHostsPagesWithContext(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, "DescribeHostsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeHostsPagesWithContext), varargs...)
-}
-
-// DescribeHostsRequest mocks base method.
-func (m *MockEC2API) DescribeHostsRequest(arg0 *ec2.DescribeHostsInput) (*request.Request, *ec2.DescribeHostsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeHostsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeHostsOutput)
-	return ret0, ret1
-}
-
-// DescribeHostsRequest indicates an expected call of DescribeHostsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeHostsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeHostsRequest), arg0)
-}
-
-// DescribeHostsWithContext mocks base method.
-func (m *MockEC2API) DescribeHostsWithContext(arg0 context.Context, arg1 *ec2.DescribeHostsInput, arg2 ...request.Option) (*ec2.DescribeHostsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeHostsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeHostsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeHostsWithContext indicates an expected call of DescribeHostsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeHostsWithContext(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, "DescribeHostsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeHostsWithContext), varargs...)
-}
-
-// DescribeIamInstanceProfileAssociations mocks base method.
-func (m *MockEC2API) DescribeIamInstanceProfileAssociations(arg0 *ec2.DescribeIamInstanceProfileAssociationsInput) (*ec2.DescribeIamInstanceProfileAssociationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIamInstanceProfileAssociations", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeIamInstanceProfileAssociationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeIamInstanceProfileAssociations indicates an expected call of DescribeIamInstanceProfileAssociations.
-func (mr *MockEC2APIMockRecorder) DescribeIamInstanceProfileAssociations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIamInstanceProfileAssociations", reflect.TypeOf((*MockEC2API)(nil).DescribeIamInstanceProfileAssociations), arg0)
-}
-
-// DescribeIamInstanceProfileAssociationsPages mocks base method.
-func (m *MockEC2API) DescribeIamInstanceProfileAssociationsPages(arg0 *ec2.DescribeIamInstanceProfileAssociationsInput, arg1 func(*ec2.DescribeIamInstanceProfileAssociationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIamInstanceProfileAssociationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeIamInstanceProfileAssociationsPages indicates an expected call of DescribeIamInstanceProfileAssociationsPages.
-func (mr *MockEC2APIMockRecorder) DescribeIamInstanceProfileAssociationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIamInstanceProfileAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeIamInstanceProfileAssociationsPages), arg0, arg1)
-}
-
-// DescribeIamInstanceProfileAssociationsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeIamInstanceProfileAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeIamInstanceProfileAssociationsInput, arg2 func(*ec2.DescribeIamInstanceProfileAssociationsOutput, 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, "DescribeIamInstanceProfileAssociationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeIamInstanceProfileAssociationsPagesWithContext indicates an expected call of DescribeIamInstanceProfileAssociationsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeIamInstanceProfileAssociationsPagesWithContext(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, "DescribeIamInstanceProfileAssociationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIamInstanceProfileAssociationsPagesWithContext), varargs...)
-}
-
-// DescribeIamInstanceProfileAssociationsRequest mocks base method.
-func (m *MockEC2API) DescribeIamInstanceProfileAssociationsRequest(arg0 *ec2.DescribeIamInstanceProfileAssociationsInput) (*request.Request, *ec2.DescribeIamInstanceProfileAssociationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIamInstanceProfileAssociationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeIamInstanceProfileAssociationsOutput)
-	return ret0, ret1
-}
-
-// DescribeIamInstanceProfileAssociationsRequest indicates an expected call of DescribeIamInstanceProfileAssociationsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeIamInstanceProfileAssociationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIamInstanceProfileAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIamInstanceProfileAssociationsRequest), arg0)
-}
-
-// DescribeIamInstanceProfileAssociationsWithContext mocks base method.
-func (m *MockEC2API) DescribeIamInstanceProfileAssociationsWithContext(arg0 context.Context, arg1 *ec2.DescribeIamInstanceProfileAssociationsInput, arg2 ...request.Option) (*ec2.DescribeIamInstanceProfileAssociationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeIamInstanceProfileAssociationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeIamInstanceProfileAssociationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeIamInstanceProfileAssociationsWithContext indicates an expected call of DescribeIamInstanceProfileAssociationsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeIamInstanceProfileAssociationsWithContext(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, "DescribeIamInstanceProfileAssociationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIamInstanceProfileAssociationsWithContext), varargs...)
-}
-
-// DescribeIdFormat mocks base method.
-func (m *MockEC2API) DescribeIdFormat(arg0 *ec2.DescribeIdFormatInput) (*ec2.DescribeIdFormatOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIdFormat", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeIdFormatOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeIdFormat indicates an expected call of DescribeIdFormat.
-func (mr *MockEC2APIMockRecorder) DescribeIdFormat(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdFormat", reflect.TypeOf((*MockEC2API)(nil).DescribeIdFormat), arg0)
-}
-
-// DescribeIdFormatRequest mocks base method.
-func (m *MockEC2API) DescribeIdFormatRequest(arg0 *ec2.DescribeIdFormatInput) (*request.Request, *ec2.DescribeIdFormatOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIdFormatRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeIdFormatOutput)
-	return ret0, ret1
-}
-
-// DescribeIdFormatRequest indicates an expected call of DescribeIdFormatRequest.
-func (mr *MockEC2APIMockRecorder) DescribeIdFormatRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIdFormatRequest), arg0)
-}
-
-// DescribeIdFormatWithContext mocks base method.
-func (m *MockEC2API) DescribeIdFormatWithContext(arg0 context.Context, arg1 *ec2.DescribeIdFormatInput, arg2 ...request.Option) (*ec2.DescribeIdFormatOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeIdFormatWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeIdFormatOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeIdFormatWithContext indicates an expected call of DescribeIdFormatWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeIdFormatWithContext(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, "DescribeIdFormatWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIdFormatWithContext), varargs...)
-}
-
-// DescribeIdentityIdFormat mocks base method.
-func (m *MockEC2API) DescribeIdentityIdFormat(arg0 *ec2.DescribeIdentityIdFormatInput) (*ec2.DescribeIdentityIdFormatOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIdentityIdFormat", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeIdentityIdFormatOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeIdentityIdFormat indicates an expected call of DescribeIdentityIdFormat.
-func (mr *MockEC2APIMockRecorder) DescribeIdentityIdFormat(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdentityIdFormat", reflect.TypeOf((*MockEC2API)(nil).DescribeIdentityIdFormat), arg0)
-}
-
-// DescribeIdentityIdFormatRequest mocks base method.
-func (m *MockEC2API) DescribeIdentityIdFormatRequest(arg0 *ec2.DescribeIdentityIdFormatInput) (*request.Request, *ec2.DescribeIdentityIdFormatOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIdentityIdFormatRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeIdentityIdFormatOutput)
-	return ret0, ret1
-}
-
-// DescribeIdentityIdFormatRequest indicates an expected call of DescribeIdentityIdFormatRequest.
-func (mr *MockEC2APIMockRecorder) DescribeIdentityIdFormatRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdentityIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIdentityIdFormatRequest), arg0)
-}
-
-// DescribeIdentityIdFormatWithContext mocks base method.
-func (m *MockEC2API) DescribeIdentityIdFormatWithContext(arg0 context.Context, arg1 *ec2.DescribeIdentityIdFormatInput, arg2 ...request.Option) (*ec2.DescribeIdentityIdFormatOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeIdentityIdFormatWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeIdentityIdFormatOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeIdentityIdFormatWithContext indicates an expected call of DescribeIdentityIdFormatWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeIdentityIdFormatWithContext(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, "DescribeIdentityIdFormatWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIdentityIdFormatWithContext), varargs...)
-}
-
-// DescribeImageAttribute mocks base method.
-func (m *MockEC2API) DescribeImageAttribute(arg0 *ec2.DescribeImageAttributeInput) (*ec2.DescribeImageAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeImageAttribute", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeImageAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeImageAttribute indicates an expected call of DescribeImageAttribute.
-func (mr *MockEC2APIMockRecorder) DescribeImageAttribute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImageAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeImageAttribute), arg0)
-}
-
-// DescribeImageAttributeRequest mocks base method.
-func (m *MockEC2API) DescribeImageAttributeRequest(arg0 *ec2.DescribeImageAttributeInput) (*request.Request, *ec2.DescribeImageAttributeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeImageAttributeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeImageAttributeOutput)
-	return ret0, ret1
-}
-
-// DescribeImageAttributeRequest indicates an expected call of DescribeImageAttributeRequest.
-func (mr *MockEC2APIMockRecorder) DescribeImageAttributeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeImageAttributeRequest), arg0)
-}
-
-// DescribeImageAttributeWithContext mocks base method.
-func (m *MockEC2API) DescribeImageAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeImageAttributeInput, arg2 ...request.Option) (*ec2.DescribeImageAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeImageAttributeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeImageAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeImageAttributeWithContext indicates an expected call of DescribeImageAttributeWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeImageAttributeWithContext(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, "DescribeImageAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeImageAttributeWithContext), varargs...)
-}
-
-// DescribeImages mocks base method.
-func (m *MockEC2API) DescribeImages(arg0 *ec2.DescribeImagesInput) (*ec2.DescribeImagesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeImages", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeImagesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeImages indicates an expected call of DescribeImages.
-func (mr *MockEC2APIMockRecorder) DescribeImages(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImages", reflect.TypeOf((*MockEC2API)(nil).DescribeImages), arg0)
-}
-
-// DescribeImagesPages mocks base method.
-func (m *MockEC2API) DescribeImagesPages(arg0 *ec2.DescribeImagesInput, arg1 func(*ec2.DescribeImagesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeImagesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeImagesPages indicates an expected call of DescribeImagesPages.
-func (mr *MockEC2APIMockRecorder) DescribeImagesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImagesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeImagesPages), arg0, arg1)
-}
-
-// DescribeImagesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeImagesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeImagesInput, arg2 func(*ec2.DescribeImagesOutput, 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, "DescribeImagesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeImagesPagesWithContext indicates an expected call of DescribeImagesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeImagesPagesWithContext(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, "DescribeImagesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeImagesPagesWithContext), varargs...)
-}
-
-// DescribeImagesRequest mocks base method.
-func (m *MockEC2API) DescribeImagesRequest(arg0 *ec2.DescribeImagesInput) (*request.Request, *ec2.DescribeImagesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeImagesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeImagesOutput)
-	return ret0, ret1
-}
-
-// DescribeImagesRequest indicates an expected call of DescribeImagesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeImagesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImagesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeImagesRequest), arg0)
-}
-
-// DescribeImagesWithContext mocks base method.
-func (m *MockEC2API) DescribeImagesWithContext(arg0 context.Context, arg1 *ec2.DescribeImagesInput, arg2 ...request.Option) (*ec2.DescribeImagesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeImagesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeImagesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeImagesWithContext indicates an expected call of DescribeImagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeImagesWithContext(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, "DescribeImagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeImagesWithContext), varargs...)
-}
-
-// DescribeImportImageTasks mocks base method.
-func (m *MockEC2API) DescribeImportImageTasks(arg0 *ec2.DescribeImportImageTasksInput) (*ec2.DescribeImportImageTasksOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeImportImageTasks", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeImportImageTasksOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeImportImageTasks indicates an expected call of DescribeImportImageTasks.
-func (mr *MockEC2APIMockRecorder) DescribeImportImageTasks(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeImportImageTasks), arg0)
-}
-
-// DescribeImportImageTasksPages mocks base method.
-func (m *MockEC2API) DescribeImportImageTasksPages(arg0 *ec2.DescribeImportImageTasksInput, arg1 func(*ec2.DescribeImportImageTasksOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeImportImageTasksPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeImportImageTasksPages indicates an expected call of DescribeImportImageTasksPages.
-func (mr *MockEC2APIMockRecorder) DescribeImportImageTasksPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeImportImageTasksPages), arg0, arg1)
-}
-
-// DescribeImportImageTasksPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeImportImageTasksPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeImportImageTasksInput, arg2 func(*ec2.DescribeImportImageTasksOutput, 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, "DescribeImportImageTasksPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeImportImageTasksPagesWithContext indicates an expected call of DescribeImportImageTasksPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeImportImageTasksPagesWithContext(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, "DescribeImportImageTasksPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeImportImageTasksPagesWithContext), varargs...)
-}
-
-// DescribeImportImageTasksRequest mocks base method.
-func (m *MockEC2API) DescribeImportImageTasksRequest(arg0 *ec2.DescribeImportImageTasksInput) (*request.Request, *ec2.DescribeImportImageTasksOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeImportImageTasksRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeImportImageTasksOutput)
-	return ret0, ret1
-}
-
-// DescribeImportImageTasksRequest indicates an expected call of DescribeImportImageTasksRequest.
-func (mr *MockEC2APIMockRecorder) DescribeImportImageTasksRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeImportImageTasksRequest), arg0)
-}
-
-// DescribeImportImageTasksWithContext mocks base method.
-func (m *MockEC2API) DescribeImportImageTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeImportImageTasksInput, arg2 ...request.Option) (*ec2.DescribeImportImageTasksOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeImportImageTasksWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeImportImageTasksOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeImportImageTasksWithContext indicates an expected call of DescribeImportImageTasksWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeImportImageTasksWithContext(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, "DescribeImportImageTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeImportImageTasksWithContext), varargs...)
-}
-
-// DescribeImportSnapshotTasks mocks base method.
-func (m *MockEC2API) DescribeImportSnapshotTasks(arg0 *ec2.DescribeImportSnapshotTasksInput) (*ec2.DescribeImportSnapshotTasksOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeImportSnapshotTasks", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeImportSnapshotTasksOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeImportSnapshotTasks indicates an expected call of DescribeImportSnapshotTasks.
-func (mr *MockEC2APIMockRecorder) DescribeImportSnapshotTasks(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportSnapshotTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeImportSnapshotTasks), arg0)
-}
-
-// DescribeImportSnapshotTasksPages mocks base method.
-func (m *MockEC2API) DescribeImportSnapshotTasksPages(arg0 *ec2.DescribeImportSnapshotTasksInput, arg1 func(*ec2.DescribeImportSnapshotTasksOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeImportSnapshotTasksPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeImportSnapshotTasksPages indicates an expected call of DescribeImportSnapshotTasksPages.
-func (mr *MockEC2APIMockRecorder) DescribeImportSnapshotTasksPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportSnapshotTasksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeImportSnapshotTasksPages), arg0, arg1)
-}
-
-// DescribeImportSnapshotTasksPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeImportSnapshotTasksPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeImportSnapshotTasksInput, arg2 func(*ec2.DescribeImportSnapshotTasksOutput, 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, "DescribeImportSnapshotTasksPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeImportSnapshotTasksPagesWithContext indicates an expected call of DescribeImportSnapshotTasksPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeImportSnapshotTasksPagesWithContext(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, "DescribeImportSnapshotTasksPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeImportSnapshotTasksPagesWithContext), varargs...)
-}
-
-// DescribeImportSnapshotTasksRequest mocks base method.
-func (m *MockEC2API) DescribeImportSnapshotTasksRequest(arg0 *ec2.DescribeImportSnapshotTasksInput) (*request.Request, *ec2.DescribeImportSnapshotTasksOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeImportSnapshotTasksRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeImportSnapshotTasksOutput)
-	return ret0, ret1
-}
-
-// DescribeImportSnapshotTasksRequest indicates an expected call of DescribeImportSnapshotTasksRequest.
-func (mr *MockEC2APIMockRecorder) DescribeImportSnapshotTasksRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportSnapshotTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeImportSnapshotTasksRequest), arg0)
-}
-
-// DescribeImportSnapshotTasksWithContext mocks base method.
-func (m *MockEC2API) DescribeImportSnapshotTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeImportSnapshotTasksInput, arg2 ...request.Option) (*ec2.DescribeImportSnapshotTasksOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeImportSnapshotTasksWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeImportSnapshotTasksOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeImportSnapshotTasksWithContext indicates an expected call of DescribeImportSnapshotTasksWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeImportSnapshotTasksWithContext(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, "DescribeImportSnapshotTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeImportSnapshotTasksWithContext), varargs...)
-}
-
-// DescribeInstanceAttribute mocks base method.
-func (m *MockEC2API) DescribeInstanceAttribute(arg0 *ec2.DescribeInstanceAttributeInput) (*ec2.DescribeInstanceAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceAttribute", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeInstanceAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstanceAttribute indicates an expected call of DescribeInstanceAttribute.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceAttribute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceAttribute), arg0)
-}
-
-// DescribeInstanceAttributeRequest mocks base method.
-func (m *MockEC2API) DescribeInstanceAttributeRequest(arg0 *ec2.DescribeInstanceAttributeInput) (*request.Request, *ec2.DescribeInstanceAttributeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceAttributeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeInstanceAttributeOutput)
-	return ret0, ret1
-}
-
-// DescribeInstanceAttributeRequest indicates an expected call of DescribeInstanceAttributeRequest.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceAttributeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceAttributeRequest), arg0)
-}
-
-// DescribeInstanceAttributeWithContext mocks base method.
-func (m *MockEC2API) DescribeInstanceAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceAttributeInput, arg2 ...request.Option) (*ec2.DescribeInstanceAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeInstanceAttributeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeInstanceAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstanceAttributeWithContext indicates an expected call of DescribeInstanceAttributeWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceAttributeWithContext(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, "DescribeInstanceAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceAttributeWithContext), varargs...)
-}
-
-// DescribeInstanceConnectEndpoints mocks base method.
-func (m *MockEC2API) DescribeInstanceConnectEndpoints(arg0 *ec2.DescribeInstanceConnectEndpointsInput) (*ec2.DescribeInstanceConnectEndpointsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceConnectEndpoints", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeInstanceConnectEndpointsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstanceConnectEndpoints indicates an expected call of DescribeInstanceConnectEndpoints.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceConnectEndpoints(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceConnectEndpoints", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceConnectEndpoints), arg0)
-}
-
-// DescribeInstanceConnectEndpointsPages mocks base method.
-func (m *MockEC2API) DescribeInstanceConnectEndpointsPages(arg0 *ec2.DescribeInstanceConnectEndpointsInput, arg1 func(*ec2.DescribeInstanceConnectEndpointsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceConnectEndpointsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeInstanceConnectEndpointsPages indicates an expected call of DescribeInstanceConnectEndpointsPages.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceConnectEndpointsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceConnectEndpointsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceConnectEndpointsPages), arg0, arg1)
-}
-
-// DescribeInstanceConnectEndpointsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeInstanceConnectEndpointsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceConnectEndpointsInput, arg2 func(*ec2.DescribeInstanceConnectEndpointsOutput, 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, "DescribeInstanceConnectEndpointsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeInstanceConnectEndpointsPagesWithContext indicates an expected call of DescribeInstanceConnectEndpointsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceConnectEndpointsPagesWithContext(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, "DescribeInstanceConnectEndpointsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceConnectEndpointsPagesWithContext), varargs...)
-}
-
-// DescribeInstanceConnectEndpointsRequest mocks base method.
-func (m *MockEC2API) DescribeInstanceConnectEndpointsRequest(arg0 *ec2.DescribeInstanceConnectEndpointsInput) (*request.Request, *ec2.DescribeInstanceConnectEndpointsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceConnectEndpointsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeInstanceConnectEndpointsOutput)
-	return ret0, ret1
-}
-
-// DescribeInstanceConnectEndpointsRequest indicates an expected call of DescribeInstanceConnectEndpointsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceConnectEndpointsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceConnectEndpointsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceConnectEndpointsRequest), arg0)
-}
-
-// DescribeInstanceConnectEndpointsWithContext mocks base method.
-func (m *MockEC2API) DescribeInstanceConnectEndpointsWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceConnectEndpointsInput, arg2 ...request.Option) (*ec2.DescribeInstanceConnectEndpointsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeInstanceConnectEndpointsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeInstanceConnectEndpointsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstanceConnectEndpointsWithContext indicates an expected call of DescribeInstanceConnectEndpointsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceConnectEndpointsWithContext(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, "DescribeInstanceConnectEndpointsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceConnectEndpointsWithContext), varargs...)
-}
-
-// DescribeInstanceCreditSpecifications mocks base method.
-func (m *MockEC2API) DescribeInstanceCreditSpecifications(arg0 *ec2.DescribeInstanceCreditSpecificationsInput) (*ec2.DescribeInstanceCreditSpecificationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceCreditSpecifications", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeInstanceCreditSpecificationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstanceCreditSpecifications indicates an expected call of DescribeInstanceCreditSpecifications.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceCreditSpecifications(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceCreditSpecifications", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceCreditSpecifications), arg0)
-}
-
-// DescribeInstanceCreditSpecificationsPages mocks base method.
-func (m *MockEC2API) DescribeInstanceCreditSpecificationsPages(arg0 *ec2.DescribeInstanceCreditSpecificationsInput, arg1 func(*ec2.DescribeInstanceCreditSpecificationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceCreditSpecificationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeInstanceCreditSpecificationsPages indicates an expected call of DescribeInstanceCreditSpecificationsPages.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceCreditSpecificationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceCreditSpecificationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceCreditSpecificationsPages), arg0, arg1)
-}
-
-// DescribeInstanceCreditSpecificationsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeInstanceCreditSpecificationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceCreditSpecificationsInput, arg2 func(*ec2.DescribeInstanceCreditSpecificationsOutput, 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, "DescribeInstanceCreditSpecificationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeInstanceCreditSpecificationsPagesWithContext indicates an expected call of DescribeInstanceCreditSpecificationsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceCreditSpecificationsPagesWithContext(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, "DescribeInstanceCreditSpecificationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceCreditSpecificationsPagesWithContext), varargs...)
-}
-
-// DescribeInstanceCreditSpecificationsRequest mocks base method.
-func (m *MockEC2API) DescribeInstanceCreditSpecificationsRequest(arg0 *ec2.DescribeInstanceCreditSpecificationsInput) (*request.Request, *ec2.DescribeInstanceCreditSpecificationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceCreditSpecificationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeInstanceCreditSpecificationsOutput)
-	return ret0, ret1
-}
-
-// DescribeInstanceCreditSpecificationsRequest indicates an expected call of DescribeInstanceCreditSpecificationsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceCreditSpecificationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceCreditSpecificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceCreditSpecificationsRequest), arg0)
-}
-
-// DescribeInstanceCreditSpecificationsWithContext mocks base method.
-func (m *MockEC2API) DescribeInstanceCreditSpecificationsWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceCreditSpecificationsInput, arg2 ...request.Option) (*ec2.DescribeInstanceCreditSpecificationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeInstanceCreditSpecificationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeInstanceCreditSpecificationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstanceCreditSpecificationsWithContext indicates an expected call of DescribeInstanceCreditSpecificationsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceCreditSpecificationsWithContext(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, "DescribeInstanceCreditSpecificationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceCreditSpecificationsWithContext), varargs...)
-}
-
-// DescribeInstanceEventNotificationAttributes mocks base method.
-func (m *MockEC2API) DescribeInstanceEventNotificationAttributes(arg0 *ec2.DescribeInstanceEventNotificationAttributesInput) (*ec2.DescribeInstanceEventNotificationAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceEventNotificationAttributes", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeInstanceEventNotificationAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstanceEventNotificationAttributes indicates an expected call of DescribeInstanceEventNotificationAttributes.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceEventNotificationAttributes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceEventNotificationAttributes", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceEventNotificationAttributes), arg0)
-}
-
-// DescribeInstanceEventNotificationAttributesRequest mocks base method.
-func (m *MockEC2API) DescribeInstanceEventNotificationAttributesRequest(arg0 *ec2.DescribeInstanceEventNotificationAttributesInput) (*request.Request, *ec2.DescribeInstanceEventNotificationAttributesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceEventNotificationAttributesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeInstanceEventNotificationAttributesOutput)
-	return ret0, ret1
-}
-
-// DescribeInstanceEventNotificationAttributesRequest indicates an expected call of DescribeInstanceEventNotificationAttributesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceEventNotificationAttributesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceEventNotificationAttributesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceEventNotificationAttributesRequest), arg0)
-}
-
-// DescribeInstanceEventNotificationAttributesWithContext mocks base method.
-func (m *MockEC2API) DescribeInstanceEventNotificationAttributesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceEventNotificationAttributesInput, arg2 ...request.Option) (*ec2.DescribeInstanceEventNotificationAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeInstanceEventNotificationAttributesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeInstanceEventNotificationAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstanceEventNotificationAttributesWithContext indicates an expected call of DescribeInstanceEventNotificationAttributesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceEventNotificationAttributesWithContext(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, "DescribeInstanceEventNotificationAttributesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceEventNotificationAttributesWithContext), varargs...)
-}
-
-// DescribeInstanceEventWindows mocks base method.
-func (m *MockEC2API) DescribeInstanceEventWindows(arg0 *ec2.DescribeInstanceEventWindowsInput) (*ec2.DescribeInstanceEventWindowsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceEventWindows", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeInstanceEventWindowsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstanceEventWindows indicates an expected call of DescribeInstanceEventWindows.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceEventWindows(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceEventWindows", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceEventWindows), arg0)
-}
-
-// DescribeInstanceEventWindowsPages mocks base method.
-func (m *MockEC2API) DescribeInstanceEventWindowsPages(arg0 *ec2.DescribeInstanceEventWindowsInput, arg1 func(*ec2.DescribeInstanceEventWindowsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceEventWindowsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeInstanceEventWindowsPages indicates an expected call of DescribeInstanceEventWindowsPages.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceEventWindowsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceEventWindowsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceEventWindowsPages), arg0, arg1)
-}
-
-// DescribeInstanceEventWindowsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeInstanceEventWindowsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceEventWindowsInput, arg2 func(*ec2.DescribeInstanceEventWindowsOutput, 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, "DescribeInstanceEventWindowsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeInstanceEventWindowsPagesWithContext indicates an expected call of DescribeInstanceEventWindowsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceEventWindowsPagesWithContext(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, "DescribeInstanceEventWindowsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceEventWindowsPagesWithContext), varargs...)
-}
-
-// DescribeInstanceEventWindowsRequest mocks base method.
-func (m *MockEC2API) DescribeInstanceEventWindowsRequest(arg0 *ec2.DescribeInstanceEventWindowsInput) (*request.Request, *ec2.DescribeInstanceEventWindowsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceEventWindowsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeInstanceEventWindowsOutput)
-	return ret0, ret1
-}
-
-// DescribeInstanceEventWindowsRequest indicates an expected call of DescribeInstanceEventWindowsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceEventWindowsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceEventWindowsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceEventWindowsRequest), arg0)
-}
-
-// DescribeInstanceEventWindowsWithContext mocks base method.
-func (m *MockEC2API) DescribeInstanceEventWindowsWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceEventWindowsInput, arg2 ...request.Option) (*ec2.DescribeInstanceEventWindowsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeInstanceEventWindowsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeInstanceEventWindowsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstanceEventWindowsWithContext indicates an expected call of DescribeInstanceEventWindowsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceEventWindowsWithContext(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, "DescribeInstanceEventWindowsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceEventWindowsWithContext), varargs...)
-}
-
-// DescribeInstanceStatus mocks base method.
-func (m *MockEC2API) DescribeInstanceStatus(arg0 *ec2.DescribeInstanceStatusInput) (*ec2.DescribeInstanceStatusOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceStatus", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeInstanceStatusOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstanceStatus indicates an expected call of DescribeInstanceStatus.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceStatus(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceStatus", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceStatus), arg0)
-}
-
-// DescribeInstanceStatusPages mocks base method.
-func (m *MockEC2API) DescribeInstanceStatusPages(arg0 *ec2.DescribeInstanceStatusInput, arg1 func(*ec2.DescribeInstanceStatusOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceStatusPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeInstanceStatusPages indicates an expected call of DescribeInstanceStatusPages.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceStatusPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceStatusPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceStatusPages), arg0, arg1)
-}
-
-// DescribeInstanceStatusPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeInstanceStatusPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceStatusInput, arg2 func(*ec2.DescribeInstanceStatusOutput, 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, "DescribeInstanceStatusPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeInstanceStatusPagesWithContext indicates an expected call of DescribeInstanceStatusPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceStatusPagesWithContext(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, "DescribeInstanceStatusPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceStatusPagesWithContext), varargs...)
-}
-
-// DescribeInstanceStatusRequest mocks base method.
-func (m *MockEC2API) DescribeInstanceStatusRequest(arg0 *ec2.DescribeInstanceStatusInput) (*request.Request, *ec2.DescribeInstanceStatusOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceStatusRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeInstanceStatusOutput)
-	return ret0, ret1
-}
-
-// DescribeInstanceStatusRequest indicates an expected call of DescribeInstanceStatusRequest.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceStatusRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceStatusRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceStatusRequest), arg0)
-}
-
-// DescribeInstanceStatusWithContext mocks base method.
-func (m *MockEC2API) DescribeInstanceStatusWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceStatusInput, arg2 ...request.Option) (*ec2.DescribeInstanceStatusOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeInstanceStatusWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeInstanceStatusOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstanceStatusWithContext indicates an expected call of DescribeInstanceStatusWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceStatusWithContext(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, "DescribeInstanceStatusWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceStatusWithContext), varargs...)
-}
-
-// DescribeInstanceTopology mocks base method.
-func (m *MockEC2API) DescribeInstanceTopology(arg0 *ec2.DescribeInstanceTopologyInput) (*ec2.DescribeInstanceTopologyOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceTopology", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeInstanceTopologyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstanceTopology indicates an expected call of DescribeInstanceTopology.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceTopology(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTopology", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTopology), arg0)
-}
-
-// DescribeInstanceTopologyPages mocks base method.
-func (m *MockEC2API) DescribeInstanceTopologyPages(arg0 *ec2.DescribeInstanceTopologyInput, arg1 func(*ec2.DescribeInstanceTopologyOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceTopologyPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeInstanceTopologyPages indicates an expected call of DescribeInstanceTopologyPages.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceTopologyPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTopologyPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTopologyPages), arg0, arg1)
-}
-
-// DescribeInstanceTopologyPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeInstanceTopologyPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceTopologyInput, arg2 func(*ec2.DescribeInstanceTopologyOutput, 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, "DescribeInstanceTopologyPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeInstanceTopologyPagesWithContext indicates an expected call of DescribeInstanceTopologyPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceTopologyPagesWithContext(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, "DescribeInstanceTopologyPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTopologyPagesWithContext), varargs...)
-}
-
-// DescribeInstanceTopologyRequest mocks base method.
-func (m *MockEC2API) DescribeInstanceTopologyRequest(arg0 *ec2.DescribeInstanceTopologyInput) (*request.Request, *ec2.DescribeInstanceTopologyOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceTopologyRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeInstanceTopologyOutput)
-	return ret0, ret1
-}
-
-// DescribeInstanceTopologyRequest indicates an expected call of DescribeInstanceTopologyRequest.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceTopologyRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTopologyRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTopologyRequest), arg0)
-}
-
-// DescribeInstanceTopologyWithContext mocks base method.
-func (m *MockEC2API) DescribeInstanceTopologyWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceTopologyInput, arg2 ...request.Option) (*ec2.DescribeInstanceTopologyOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeInstanceTopologyWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeInstanceTopologyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstanceTopologyWithContext indicates an expected call of DescribeInstanceTopologyWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceTopologyWithContext(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, "DescribeInstanceTopologyWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTopologyWithContext), varargs...)
-}
-
-// DescribeInstanceTypeOfferings mocks base method.
-func (m *MockEC2API) DescribeInstanceTypeOfferings(arg0 *ec2.DescribeInstanceTypeOfferingsInput) (*ec2.DescribeInstanceTypeOfferingsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceTypeOfferings", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeInstanceTypeOfferingsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstanceTypeOfferings indicates an expected call of DescribeInstanceTypeOfferings.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceTypeOfferings(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypeOfferings", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypeOfferings), arg0)
-}
-
-// DescribeInstanceTypeOfferingsPages mocks base method.
-func (m *MockEC2API) DescribeInstanceTypeOfferingsPages(arg0 *ec2.DescribeInstanceTypeOfferingsInput, arg1 func(*ec2.DescribeInstanceTypeOfferingsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceTypeOfferingsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeInstanceTypeOfferingsPages indicates an expected call of DescribeInstanceTypeOfferingsPages.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceTypeOfferingsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypeOfferingsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypeOfferingsPages), arg0, arg1)
-}
-
-// DescribeInstanceTypeOfferingsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeInstanceTypeOfferingsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceTypeOfferingsInput, arg2 func(*ec2.DescribeInstanceTypeOfferingsOutput, 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, "DescribeInstanceTypeOfferingsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeInstanceTypeOfferingsPagesWithContext indicates an expected call of DescribeInstanceTypeOfferingsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceTypeOfferingsPagesWithContext(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, "DescribeInstanceTypeOfferingsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypeOfferingsPagesWithContext), varargs...)
-}
-
-// DescribeInstanceTypeOfferingsRequest mocks base method.
-func (m *MockEC2API) DescribeInstanceTypeOfferingsRequest(arg0 *ec2.DescribeInstanceTypeOfferingsInput) (*request.Request, *ec2.DescribeInstanceTypeOfferingsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceTypeOfferingsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeInstanceTypeOfferingsOutput)
-	return ret0, ret1
-}
-
-// DescribeInstanceTypeOfferingsRequest indicates an expected call of DescribeInstanceTypeOfferingsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceTypeOfferingsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypeOfferingsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypeOfferingsRequest), arg0)
-}
-
-// DescribeInstanceTypeOfferingsWithContext mocks base method.
-func (m *MockEC2API) DescribeInstanceTypeOfferingsWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceTypeOfferingsInput, arg2 ...request.Option) (*ec2.DescribeInstanceTypeOfferingsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeInstanceTypeOfferingsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeInstanceTypeOfferingsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstanceTypeOfferingsWithContext indicates an expected call of DescribeInstanceTypeOfferingsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceTypeOfferingsWithContext(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, "DescribeInstanceTypeOfferingsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypeOfferingsWithContext), varargs...)
-}
-
-// DescribeInstanceTypes mocks base method.
-func (m *MockEC2API) DescribeInstanceTypes(arg0 *ec2.DescribeInstanceTypesInput) (*ec2.DescribeInstanceTypesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceTypes", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeInstanceTypesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstanceTypes indicates an expected call of DescribeInstanceTypes.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceTypes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypes", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypes), arg0)
-}
-
-// DescribeInstanceTypesPages mocks base method.
-func (m *MockEC2API) DescribeInstanceTypesPages(arg0 *ec2.DescribeInstanceTypesInput, arg1 func(*ec2.DescribeInstanceTypesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceTypesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeInstanceTypesPages indicates an expected call of DescribeInstanceTypesPages.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceTypesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypesPages), arg0, arg1)
-}
-
-// DescribeInstanceTypesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeInstanceTypesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceTypesInput, arg2 func(*ec2.DescribeInstanceTypesOutput, 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, "DescribeInstanceTypesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeInstanceTypesPagesWithContext indicates an expected call of DescribeInstanceTypesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceTypesPagesWithContext(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, "DescribeInstanceTypesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypesPagesWithContext), varargs...)
-}
-
-// DescribeInstanceTypesRequest mocks base method.
-func (m *MockEC2API) DescribeInstanceTypesRequest(arg0 *ec2.DescribeInstanceTypesInput) (*request.Request, *ec2.DescribeInstanceTypesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstanceTypesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeInstanceTypesOutput)
-	return ret0, ret1
-}
-
-// DescribeInstanceTypesRequest indicates an expected call of DescribeInstanceTypesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceTypesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypesRequest), arg0)
-}
-
-// DescribeInstanceTypesWithContext mocks base method.
-func (m *MockEC2API) DescribeInstanceTypesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceTypesInput, arg2 ...request.Option) (*ec2.DescribeInstanceTypesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeInstanceTypesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeInstanceTypesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstanceTypesWithContext indicates an expected call of DescribeInstanceTypesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeInstanceTypesWithContext(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, "DescribeInstanceTypesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypesWithContext), varargs...)
-}
-
-// DescribeInstances mocks base method.
-func (m *MockEC2API) DescribeInstances(arg0 *ec2.DescribeInstancesInput) (*ec2.DescribeInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstances", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstances indicates an expected call of DescribeInstances.
-func (mr *MockEC2APIMockRecorder) DescribeInstances(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeInstances), arg0)
-}
-
-// DescribeInstancesPages mocks base method.
-func (m *MockEC2API) DescribeInstancesPages(arg0 *ec2.DescribeInstancesInput, arg1 func(*ec2.DescribeInstancesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstancesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeInstancesPages indicates an expected call of DescribeInstancesPages.
-func (mr *MockEC2APIMockRecorder) DescribeInstancesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstancesPages), arg0, arg1)
-}
-
-// DescribeInstancesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeInstancesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, arg2 func(*ec2.DescribeInstancesOutput, 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, "DescribeInstancesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeInstancesPagesWithContext indicates an expected call of DescribeInstancesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeInstancesPagesWithContext(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, "DescribeInstancesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstancesPagesWithContext), varargs...)
-}
-
-// DescribeInstancesRequest mocks base method.
-func (m *MockEC2API) DescribeInstancesRequest(arg0 *ec2.DescribeInstancesInput) (*request.Request, *ec2.DescribeInstancesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInstancesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeInstancesOutput)
-	return ret0, ret1
-}
-
-// DescribeInstancesRequest indicates an expected call of DescribeInstancesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeInstancesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstancesRequest), arg0)
-}
-
-// DescribeInstancesWithContext mocks base method.
-func (m *MockEC2API) DescribeInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, arg2 ...request.Option) (*ec2.DescribeInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeInstancesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInstancesWithContext indicates an expected call of DescribeInstancesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeInstancesWithContext(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, "DescribeInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstancesWithContext), varargs...)
-}
-
-// DescribeInternetGateways mocks base method.
-func (m *MockEC2API) DescribeInternetGateways(arg0 *ec2.DescribeInternetGatewaysInput) (*ec2.DescribeInternetGatewaysOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInternetGateways", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeInternetGatewaysOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInternetGateways indicates an expected call of DescribeInternetGateways.
-func (mr *MockEC2APIMockRecorder) DescribeInternetGateways(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInternetGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeInternetGateways), arg0)
-}
-
-// DescribeInternetGatewaysPages mocks base method.
-func (m *MockEC2API) DescribeInternetGatewaysPages(arg0 *ec2.DescribeInternetGatewaysInput, arg1 func(*ec2.DescribeInternetGatewaysOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInternetGatewaysPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeInternetGatewaysPages indicates an expected call of DescribeInternetGatewaysPages.
-func (mr *MockEC2APIMockRecorder) DescribeInternetGatewaysPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInternetGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInternetGatewaysPages), arg0, arg1)
-}
-
-// DescribeInternetGatewaysPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeInternetGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInternetGatewaysInput, arg2 func(*ec2.DescribeInternetGatewaysOutput, 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, "DescribeInternetGatewaysPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeInternetGatewaysPagesWithContext indicates an expected call of DescribeInternetGatewaysPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeInternetGatewaysPagesWithContext(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, "DescribeInternetGatewaysPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInternetGatewaysPagesWithContext), varargs...)
-}
-
-// DescribeInternetGatewaysRequest mocks base method.
-func (m *MockEC2API) DescribeInternetGatewaysRequest(arg0 *ec2.DescribeInternetGatewaysInput) (*request.Request, *ec2.DescribeInternetGatewaysOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeInternetGatewaysRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeInternetGatewaysOutput)
-	return ret0, ret1
-}
-
-// DescribeInternetGatewaysRequest indicates an expected call of DescribeInternetGatewaysRequest.
-func (mr *MockEC2APIMockRecorder) DescribeInternetGatewaysRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInternetGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInternetGatewaysRequest), arg0)
-}
-
-// DescribeInternetGatewaysWithContext mocks base method.
-func (m *MockEC2API) DescribeInternetGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeInternetGatewaysInput, arg2 ...request.Option) (*ec2.DescribeInternetGatewaysOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeInternetGatewaysWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeInternetGatewaysOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeInternetGatewaysWithContext indicates an expected call of DescribeInternetGatewaysWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeInternetGatewaysWithContext(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, "DescribeInternetGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInternetGatewaysWithContext), varargs...)
-}
-
-// DescribeIpamByoasn mocks base method.
-func (m *MockEC2API) DescribeIpamByoasn(arg0 *ec2.DescribeIpamByoasnInput) (*ec2.DescribeIpamByoasnOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIpamByoasn", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeIpamByoasnOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeIpamByoasn indicates an expected call of DescribeIpamByoasn.
-func (mr *MockEC2APIMockRecorder) DescribeIpamByoasn(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamByoasn", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamByoasn), arg0)
-}
-
-// DescribeIpamByoasnRequest mocks base method.
-func (m *MockEC2API) DescribeIpamByoasnRequest(arg0 *ec2.DescribeIpamByoasnInput) (*request.Request, *ec2.DescribeIpamByoasnOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIpamByoasnRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeIpamByoasnOutput)
-	return ret0, ret1
-}
-
-// DescribeIpamByoasnRequest indicates an expected call of DescribeIpamByoasnRequest.
-func (mr *MockEC2APIMockRecorder) DescribeIpamByoasnRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamByoasnRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamByoasnRequest), arg0)
-}
-
-// DescribeIpamByoasnWithContext mocks base method.
-func (m *MockEC2API) DescribeIpamByoasnWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamByoasnInput, arg2 ...request.Option) (*ec2.DescribeIpamByoasnOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeIpamByoasnWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeIpamByoasnOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeIpamByoasnWithContext indicates an expected call of DescribeIpamByoasnWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeIpamByoasnWithContext(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, "DescribeIpamByoasnWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamByoasnWithContext), varargs...)
-}
-
-// DescribeIpamExternalResourceVerificationTokens mocks base method.
-func (m *MockEC2API) DescribeIpamExternalResourceVerificationTokens(arg0 *ec2.DescribeIpamExternalResourceVerificationTokensInput) (*ec2.DescribeIpamExternalResourceVerificationTokensOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIpamExternalResourceVerificationTokens", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeIpamExternalResourceVerificationTokensOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeIpamExternalResourceVerificationTokens indicates an expected call of DescribeIpamExternalResourceVerificationTokens.
-func (mr *MockEC2APIMockRecorder) DescribeIpamExternalResourceVerificationTokens(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamExternalResourceVerificationTokens", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamExternalResourceVerificationTokens), arg0)
-}
-
-// DescribeIpamExternalResourceVerificationTokensRequest mocks base method.
-func (m *MockEC2API) DescribeIpamExternalResourceVerificationTokensRequest(arg0 *ec2.DescribeIpamExternalResourceVerificationTokensInput) (*request.Request, *ec2.DescribeIpamExternalResourceVerificationTokensOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIpamExternalResourceVerificationTokensRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeIpamExternalResourceVerificationTokensOutput)
-	return ret0, ret1
-}
-
-// DescribeIpamExternalResourceVerificationTokensRequest indicates an expected call of DescribeIpamExternalResourceVerificationTokensRequest.
-func (mr *MockEC2APIMockRecorder) DescribeIpamExternalResourceVerificationTokensRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamExternalResourceVerificationTokensRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamExternalResourceVerificationTokensRequest), arg0)
-}
-
-// DescribeIpamExternalResourceVerificationTokensWithContext mocks base method.
-func (m *MockEC2API) DescribeIpamExternalResourceVerificationTokensWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamExternalResourceVerificationTokensInput, arg2 ...request.Option) (*ec2.DescribeIpamExternalResourceVerificationTokensOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeIpamExternalResourceVerificationTokensWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeIpamExternalResourceVerificationTokensOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeIpamExternalResourceVerificationTokensWithContext indicates an expected call of DescribeIpamExternalResourceVerificationTokensWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeIpamExternalResourceVerificationTokensWithContext(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, "DescribeIpamExternalResourceVerificationTokensWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamExternalResourceVerificationTokensWithContext), varargs...)
-}
-
-// DescribeIpamPools mocks base method.
-func (m *MockEC2API) DescribeIpamPools(arg0 *ec2.DescribeIpamPoolsInput) (*ec2.DescribeIpamPoolsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIpamPools", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeIpamPoolsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeIpamPools indicates an expected call of DescribeIpamPools.
-func (mr *MockEC2APIMockRecorder) DescribeIpamPools(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamPools", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamPools), arg0)
-}
-
-// DescribeIpamPoolsPages mocks base method.
-func (m *MockEC2API) DescribeIpamPoolsPages(arg0 *ec2.DescribeIpamPoolsInput, arg1 func(*ec2.DescribeIpamPoolsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIpamPoolsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeIpamPoolsPages indicates an expected call of DescribeIpamPoolsPages.
-func (mr *MockEC2APIMockRecorder) DescribeIpamPoolsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamPoolsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamPoolsPages), arg0, arg1)
-}
-
-// DescribeIpamPoolsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeIpamPoolsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamPoolsInput, arg2 func(*ec2.DescribeIpamPoolsOutput, 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, "DescribeIpamPoolsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeIpamPoolsPagesWithContext indicates an expected call of DescribeIpamPoolsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeIpamPoolsPagesWithContext(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, "DescribeIpamPoolsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamPoolsPagesWithContext), varargs...)
-}
-
-// DescribeIpamPoolsRequest mocks base method.
-func (m *MockEC2API) DescribeIpamPoolsRequest(arg0 *ec2.DescribeIpamPoolsInput) (*request.Request, *ec2.DescribeIpamPoolsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIpamPoolsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeIpamPoolsOutput)
-	return ret0, ret1
-}
-
-// DescribeIpamPoolsRequest indicates an expected call of DescribeIpamPoolsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeIpamPoolsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamPoolsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamPoolsRequest), arg0)
-}
-
-// DescribeIpamPoolsWithContext mocks base method.
-func (m *MockEC2API) DescribeIpamPoolsWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamPoolsInput, arg2 ...request.Option) (*ec2.DescribeIpamPoolsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeIpamPoolsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeIpamPoolsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeIpamPoolsWithContext indicates an expected call of DescribeIpamPoolsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeIpamPoolsWithContext(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, "DescribeIpamPoolsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamPoolsWithContext), varargs...)
-}
-
-// DescribeIpamResourceDiscoveries mocks base method.
-func (m *MockEC2API) DescribeIpamResourceDiscoveries(arg0 *ec2.DescribeIpamResourceDiscoveriesInput) (*ec2.DescribeIpamResourceDiscoveriesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveries", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeIpamResourceDiscoveriesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeIpamResourceDiscoveries indicates an expected call of DescribeIpamResourceDiscoveries.
-func (mr *MockEC2APIMockRecorder) DescribeIpamResourceDiscoveries(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamResourceDiscoveries", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamResourceDiscoveries), arg0)
-}
-
-// DescribeIpamResourceDiscoveriesPages mocks base method.
-func (m *MockEC2API) DescribeIpamResourceDiscoveriesPages(arg0 *ec2.DescribeIpamResourceDiscoveriesInput, arg1 func(*ec2.DescribeIpamResourceDiscoveriesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveriesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeIpamResourceDiscoveriesPages indicates an expected call of DescribeIpamResourceDiscoveriesPages.
-func (mr *MockEC2APIMockRecorder) DescribeIpamResourceDiscoveriesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamResourceDiscoveriesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamResourceDiscoveriesPages), arg0, arg1)
-}
-
-// DescribeIpamResourceDiscoveriesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeIpamResourceDiscoveriesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamResourceDiscoveriesInput, arg2 func(*ec2.DescribeIpamResourceDiscoveriesOutput, 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, "DescribeIpamResourceDiscoveriesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeIpamResourceDiscoveriesPagesWithContext indicates an expected call of DescribeIpamResourceDiscoveriesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeIpamResourceDiscoveriesPagesWithContext(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, "DescribeIpamResourceDiscoveriesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamResourceDiscoveriesPagesWithContext), varargs...)
-}
-
-// DescribeIpamResourceDiscoveriesRequest mocks base method.
-func (m *MockEC2API) DescribeIpamResourceDiscoveriesRequest(arg0 *ec2.DescribeIpamResourceDiscoveriesInput) (*request.Request, *ec2.DescribeIpamResourceDiscoveriesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveriesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeIpamResourceDiscoveriesOutput)
-	return ret0, ret1
-}
-
-// DescribeIpamResourceDiscoveriesRequest indicates an expected call of DescribeIpamResourceDiscoveriesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeIpamResourceDiscoveriesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamResourceDiscoveriesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamResourceDiscoveriesRequest), arg0)
-}
-
-// DescribeIpamResourceDiscoveriesWithContext mocks base method.
-func (m *MockEC2API) DescribeIpamResourceDiscoveriesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamResourceDiscoveriesInput, arg2 ...request.Option) (*ec2.DescribeIpamResourceDiscoveriesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveriesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeIpamResourceDiscoveriesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeIpamResourceDiscoveriesWithContext indicates an expected call of DescribeIpamResourceDiscoveriesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeIpamResourceDiscoveriesWithContext(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, "DescribeIpamResourceDiscoveriesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamResourceDiscoveriesWithContext), varargs...)
-}
-
-// DescribeIpamResourceDiscoveryAssociations mocks base method.
-func (m *MockEC2API) DescribeIpamResourceDiscoveryAssociations(arg0 *ec2.DescribeIpamResourceDiscoveryAssociationsInput) (*ec2.DescribeIpamResourceDiscoveryAssociationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveryAssociations", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeIpamResourceDiscoveryAssociationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeIpamResourceDiscoveryAssociations indicates an expected call of DescribeIpamResourceDiscoveryAssociations.
-func (mr *MockEC2APIMockRecorder) DescribeIpamResourceDiscoveryAssociations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamResourceDiscoveryAssociations", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamResourceDiscoveryAssociations), arg0)
-}
-
-// DescribeIpamResourceDiscoveryAssociationsPages mocks base method.
-func (m *MockEC2API) DescribeIpamResourceDiscoveryAssociationsPages(arg0 *ec2.DescribeIpamResourceDiscoveryAssociationsInput, arg1 func(*ec2.DescribeIpamResourceDiscoveryAssociationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveryAssociationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeIpamResourceDiscoveryAssociationsPages indicates an expected call of DescribeIpamResourceDiscoveryAssociationsPages.
-func (mr *MockEC2APIMockRecorder) DescribeIpamResourceDiscoveryAssociationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamResourceDiscoveryAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamResourceDiscoveryAssociationsPages), arg0, arg1)
-}
-
-// DescribeIpamResourceDiscoveryAssociationsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeIpamResourceDiscoveryAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamResourceDiscoveryAssociationsInput, arg2 func(*ec2.DescribeIpamResourceDiscoveryAssociationsOutput, 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, "DescribeIpamResourceDiscoveryAssociationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeIpamResourceDiscoveryAssociationsPagesWithContext indicates an expected call of DescribeIpamResourceDiscoveryAssociationsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeIpamResourceDiscoveryAssociationsPagesWithContext(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, "DescribeIpamResourceDiscoveryAssociationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamResourceDiscoveryAssociationsPagesWithContext), varargs...)
-}
-
-// DescribeIpamResourceDiscoveryAssociationsRequest mocks base method.
-func (m *MockEC2API) DescribeIpamResourceDiscoveryAssociationsRequest(arg0 *ec2.DescribeIpamResourceDiscoveryAssociationsInput) (*request.Request, *ec2.DescribeIpamResourceDiscoveryAssociationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveryAssociationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeIpamResourceDiscoveryAssociationsOutput)
-	return ret0, ret1
-}
-
-// DescribeIpamResourceDiscoveryAssociationsRequest indicates an expected call of DescribeIpamResourceDiscoveryAssociationsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeIpamResourceDiscoveryAssociationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamResourceDiscoveryAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamResourceDiscoveryAssociationsRequest), arg0)
-}
-
-// DescribeIpamResourceDiscoveryAssociationsWithContext mocks base method.
-func (m *MockEC2API) DescribeIpamResourceDiscoveryAssociationsWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamResourceDiscoveryAssociationsInput, arg2 ...request.Option) (*ec2.DescribeIpamResourceDiscoveryAssociationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveryAssociationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeIpamResourceDiscoveryAssociationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeIpamResourceDiscoveryAssociationsWithContext indicates an expected call of DescribeIpamResourceDiscoveryAssociationsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeIpamResourceDiscoveryAssociationsWithContext(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, "DescribeIpamResourceDiscoveryAssociationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamResourceDiscoveryAssociationsWithContext), varargs...)
-}
-
-// DescribeIpamScopes mocks base method.
-func (m *MockEC2API) DescribeIpamScopes(arg0 *ec2.DescribeIpamScopesInput) (*ec2.DescribeIpamScopesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIpamScopes", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeIpamScopesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeIpamScopes indicates an expected call of DescribeIpamScopes.
-func (mr *MockEC2APIMockRecorder) DescribeIpamScopes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamScopes", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamScopes), arg0)
-}
-
-// DescribeIpamScopesPages mocks base method.
-func (m *MockEC2API) DescribeIpamScopesPages(arg0 *ec2.DescribeIpamScopesInput, arg1 func(*ec2.DescribeIpamScopesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIpamScopesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeIpamScopesPages indicates an expected call of DescribeIpamScopesPages.
-func (mr *MockEC2APIMockRecorder) DescribeIpamScopesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamScopesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamScopesPages), arg0, arg1)
-}
-
-// DescribeIpamScopesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeIpamScopesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamScopesInput, arg2 func(*ec2.DescribeIpamScopesOutput, 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, "DescribeIpamScopesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeIpamScopesPagesWithContext indicates an expected call of DescribeIpamScopesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeIpamScopesPagesWithContext(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, "DescribeIpamScopesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamScopesPagesWithContext), varargs...)
-}
-
-// DescribeIpamScopesRequest mocks base method.
-func (m *MockEC2API) DescribeIpamScopesRequest(arg0 *ec2.DescribeIpamScopesInput) (*request.Request, *ec2.DescribeIpamScopesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIpamScopesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeIpamScopesOutput)
-	return ret0, ret1
-}
-
-// DescribeIpamScopesRequest indicates an expected call of DescribeIpamScopesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeIpamScopesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamScopesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamScopesRequest), arg0)
-}
-
-// DescribeIpamScopesWithContext mocks base method.
-func (m *MockEC2API) DescribeIpamScopesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamScopesInput, arg2 ...request.Option) (*ec2.DescribeIpamScopesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeIpamScopesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeIpamScopesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeIpamScopesWithContext indicates an expected call of DescribeIpamScopesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeIpamScopesWithContext(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, "DescribeIpamScopesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamScopesWithContext), varargs...)
-}
-
-// DescribeIpams mocks base method.
-func (m *MockEC2API) DescribeIpams(arg0 *ec2.DescribeIpamsInput) (*ec2.DescribeIpamsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIpams", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeIpamsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeIpams indicates an expected call of DescribeIpams.
-func (mr *MockEC2APIMockRecorder) DescribeIpams(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpams", reflect.TypeOf((*MockEC2API)(nil).DescribeIpams), arg0)
-}
-
-// DescribeIpamsPages mocks base method.
-func (m *MockEC2API) DescribeIpamsPages(arg0 *ec2.DescribeIpamsInput, arg1 func(*ec2.DescribeIpamsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIpamsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeIpamsPages indicates an expected call of DescribeIpamsPages.
-func (mr *MockEC2APIMockRecorder) DescribeIpamsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamsPages), arg0, arg1)
-}
-
-// DescribeIpamsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeIpamsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamsInput, arg2 func(*ec2.DescribeIpamsOutput, 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, "DescribeIpamsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeIpamsPagesWithContext indicates an expected call of DescribeIpamsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeIpamsPagesWithContext(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, "DescribeIpamsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamsPagesWithContext), varargs...)
-}
-
-// DescribeIpamsRequest mocks base method.
-func (m *MockEC2API) DescribeIpamsRequest(arg0 *ec2.DescribeIpamsInput) (*request.Request, *ec2.DescribeIpamsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIpamsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeIpamsOutput)
-	return ret0, ret1
-}
-
-// DescribeIpamsRequest indicates an expected call of DescribeIpamsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeIpamsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamsRequest), arg0)
-}
-
-// DescribeIpamsWithContext mocks base method.
-func (m *MockEC2API) DescribeIpamsWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamsInput, arg2 ...request.Option) (*ec2.DescribeIpamsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeIpamsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeIpamsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeIpamsWithContext indicates an expected call of DescribeIpamsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeIpamsWithContext(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, "DescribeIpamsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamsWithContext), varargs...)
-}
-
-// DescribeIpv6Pools mocks base method.
-func (m *MockEC2API) DescribeIpv6Pools(arg0 *ec2.DescribeIpv6PoolsInput) (*ec2.DescribeIpv6PoolsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIpv6Pools", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeIpv6PoolsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeIpv6Pools indicates an expected call of DescribeIpv6Pools.
-func (mr *MockEC2APIMockRecorder) DescribeIpv6Pools(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpv6Pools", reflect.TypeOf((*MockEC2API)(nil).DescribeIpv6Pools), arg0)
-}
-
-// DescribeIpv6PoolsPages mocks base method.
-func (m *MockEC2API) DescribeIpv6PoolsPages(arg0 *ec2.DescribeIpv6PoolsInput, arg1 func(*ec2.DescribeIpv6PoolsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIpv6PoolsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeIpv6PoolsPages indicates an expected call of DescribeIpv6PoolsPages.
-func (mr *MockEC2APIMockRecorder) DescribeIpv6PoolsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpv6PoolsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeIpv6PoolsPages), arg0, arg1)
-}
-
-// DescribeIpv6PoolsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeIpv6PoolsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpv6PoolsInput, arg2 func(*ec2.DescribeIpv6PoolsOutput, 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, "DescribeIpv6PoolsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeIpv6PoolsPagesWithContext indicates an expected call of DescribeIpv6PoolsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeIpv6PoolsPagesWithContext(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, "DescribeIpv6PoolsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIpv6PoolsPagesWithContext), varargs...)
-}
-
-// DescribeIpv6PoolsRequest mocks base method.
-func (m *MockEC2API) DescribeIpv6PoolsRequest(arg0 *ec2.DescribeIpv6PoolsInput) (*request.Request, *ec2.DescribeIpv6PoolsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeIpv6PoolsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeIpv6PoolsOutput)
-	return ret0, ret1
-}
-
-// DescribeIpv6PoolsRequest indicates an expected call of DescribeIpv6PoolsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeIpv6PoolsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpv6PoolsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIpv6PoolsRequest), arg0)
-}
-
-// DescribeIpv6PoolsWithContext mocks base method.
-func (m *MockEC2API) DescribeIpv6PoolsWithContext(arg0 context.Context, arg1 *ec2.DescribeIpv6PoolsInput, arg2 ...request.Option) (*ec2.DescribeIpv6PoolsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeIpv6PoolsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeIpv6PoolsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeIpv6PoolsWithContext indicates an expected call of DescribeIpv6PoolsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeIpv6PoolsWithContext(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, "DescribeIpv6PoolsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIpv6PoolsWithContext), varargs...)
-}
-
-// DescribeKeyPairs mocks base method.
-func (m *MockEC2API) DescribeKeyPairs(arg0 *ec2.DescribeKeyPairsInput) (*ec2.DescribeKeyPairsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeKeyPairs", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeKeyPairsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeKeyPairs indicates an expected call of DescribeKeyPairs.
-func (mr *MockEC2APIMockRecorder) DescribeKeyPairs(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKeyPairs", reflect.TypeOf((*MockEC2API)(nil).DescribeKeyPairs), arg0)
-}
-
-// DescribeKeyPairsRequest mocks base method.
-func (m *MockEC2API) DescribeKeyPairsRequest(arg0 *ec2.DescribeKeyPairsInput) (*request.Request, *ec2.DescribeKeyPairsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeKeyPairsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeKeyPairsOutput)
-	return ret0, ret1
-}
-
-// DescribeKeyPairsRequest indicates an expected call of DescribeKeyPairsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeKeyPairsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKeyPairsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeKeyPairsRequest), arg0)
-}
-
-// DescribeKeyPairsWithContext mocks base method.
-func (m *MockEC2API) DescribeKeyPairsWithContext(arg0 context.Context, arg1 *ec2.DescribeKeyPairsInput, arg2 ...request.Option) (*ec2.DescribeKeyPairsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeKeyPairsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeKeyPairsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeKeyPairsWithContext indicates an expected call of DescribeKeyPairsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeKeyPairsWithContext(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, "DescribeKeyPairsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeKeyPairsWithContext), varargs...)
-}
-
-// DescribeLaunchTemplateVersions mocks base method.
-func (m *MockEC2API) DescribeLaunchTemplateVersions(arg0 *ec2.DescribeLaunchTemplateVersionsInput) (*ec2.DescribeLaunchTemplateVersionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersions", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeLaunchTemplateVersionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLaunchTemplateVersions indicates an expected call of DescribeLaunchTemplateVersions.
-func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplateVersions(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplateVersions", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplateVersions), arg0)
-}
-
-// DescribeLaunchTemplateVersionsPages mocks base method.
-func (m *MockEC2API) DescribeLaunchTemplateVersionsPages(arg0 *ec2.DescribeLaunchTemplateVersionsInput, arg1 func(*ec2.DescribeLaunchTemplateVersionsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersionsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeLaunchTemplateVersionsPages indicates an expected call of DescribeLaunchTemplateVersionsPages.
-func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplateVersionsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplateVersionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplateVersionsPages), arg0, arg1)
-}
-
-// DescribeLaunchTemplateVersionsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeLaunchTemplateVersionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLaunchTemplateVersionsInput, arg2 func(*ec2.DescribeLaunchTemplateVersionsOutput, 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, "DescribeLaunchTemplateVersionsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeLaunchTemplateVersionsPagesWithContext indicates an expected call of DescribeLaunchTemplateVersionsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplateVersionsPagesWithContext(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, "DescribeLaunchTemplateVersionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplateVersionsPagesWithContext), varargs...)
-}
-
-// DescribeLaunchTemplateVersionsRequest mocks base method.
-func (m *MockEC2API) DescribeLaunchTemplateVersionsRequest(arg0 *ec2.DescribeLaunchTemplateVersionsInput) (*request.Request, *ec2.DescribeLaunchTemplateVersionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeLaunchTemplateVersionsOutput)
-	return ret0, ret1
-}
-
-// DescribeLaunchTemplateVersionsRequest indicates an expected call of DescribeLaunchTemplateVersionsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplateVersionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplateVersionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplateVersionsRequest), arg0)
-}
-
-// DescribeLaunchTemplateVersionsWithContext mocks base method.
-func (m *MockEC2API) DescribeLaunchTemplateVersionsWithContext(arg0 context.Context, arg1 *ec2.DescribeLaunchTemplateVersionsInput, arg2 ...request.Option) (*ec2.DescribeLaunchTemplateVersionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeLaunchTemplateVersionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLaunchTemplateVersionsWithContext indicates an expected call of DescribeLaunchTemplateVersionsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplateVersionsWithContext(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, "DescribeLaunchTemplateVersionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplateVersionsWithContext), varargs...)
-}
-
-// DescribeLaunchTemplates mocks base method.
-func (m *MockEC2API) DescribeLaunchTemplates(arg0 *ec2.DescribeLaunchTemplatesInput) (*ec2.DescribeLaunchTemplatesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLaunchTemplates", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeLaunchTemplatesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLaunchTemplates indicates an expected call of DescribeLaunchTemplates.
-func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplates(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplates", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplates), arg0)
-}
-
-// DescribeLaunchTemplatesPages mocks base method.
-func (m *MockEC2API) DescribeLaunchTemplatesPages(arg0 *ec2.DescribeLaunchTemplatesInput, arg1 func(*ec2.DescribeLaunchTemplatesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLaunchTemplatesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeLaunchTemplatesPages indicates an expected call of DescribeLaunchTemplatesPages.
-func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplatesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplatesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplatesPages), arg0, arg1)
-}
-
-// DescribeLaunchTemplatesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeLaunchTemplatesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLaunchTemplatesInput, arg2 func(*ec2.DescribeLaunchTemplatesOutput, 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, "DescribeLaunchTemplatesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeLaunchTemplatesPagesWithContext indicates an expected call of DescribeLaunchTemplatesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplatesPagesWithContext(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, "DescribeLaunchTemplatesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplatesPagesWithContext), varargs...)
-}
-
-// DescribeLaunchTemplatesRequest mocks base method.
-func (m *MockEC2API) DescribeLaunchTemplatesRequest(arg0 *ec2.DescribeLaunchTemplatesInput) (*request.Request, *ec2.DescribeLaunchTemplatesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLaunchTemplatesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeLaunchTemplatesOutput)
-	return ret0, ret1
-}
-
-// DescribeLaunchTemplatesRequest indicates an expected call of DescribeLaunchTemplatesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplatesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplatesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplatesRequest), arg0)
-}
-
-// DescribeLaunchTemplatesWithContext mocks base method.
-func (m *MockEC2API) DescribeLaunchTemplatesWithContext(arg0 context.Context, arg1 *ec2.DescribeLaunchTemplatesInput, arg2 ...request.Option) (*ec2.DescribeLaunchTemplatesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeLaunchTemplatesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeLaunchTemplatesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLaunchTemplatesWithContext indicates an expected call of DescribeLaunchTemplatesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplatesWithContext(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, "DescribeLaunchTemplatesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplatesWithContext), varargs...)
-}
-
-// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(arg0 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput) (*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations indicates an expected call of DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations), arg0)
-}
-
-// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages(arg0 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput, arg1 func(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages indicates an expected call of DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages), arg0, arg1)
-}
-
-// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput, arg2 func(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, 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, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext indicates an expected call of DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext(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, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext), varargs...)
-}
-
-// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest(arg0 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput) (*request.Request, *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput)
-	return ret0, ret1
-}
-
-// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest indicates an expected call of DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest), arg0)
-}
-
-// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext indicates an expected call of DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext(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, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext), varargs...)
-}
-
-// DescribeLocalGatewayRouteTableVpcAssociations mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayRouteTableVpcAssociations(arg0 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput) (*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVpcAssociations", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLocalGatewayRouteTableVpcAssociations indicates an expected call of DescribeLocalGatewayRouteTableVpcAssociations.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVpcAssociations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVpcAssociations", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVpcAssociations), arg0)
-}
-
-// DescribeLocalGatewayRouteTableVpcAssociationsPages mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayRouteTableVpcAssociationsPages(arg0 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput, arg1 func(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVpcAssociationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeLocalGatewayRouteTableVpcAssociationsPages indicates an expected call of DescribeLocalGatewayRouteTableVpcAssociationsPages.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVpcAssociationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVpcAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVpcAssociationsPages), arg0, arg1)
-}
-
-// DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput, arg2 func(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, 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, "DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext indicates an expected call of DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext(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, "DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext), varargs...)
-}
-
-// DescribeLocalGatewayRouteTableVpcAssociationsRequest mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayRouteTableVpcAssociationsRequest(arg0 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput) (*request.Request, *ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVpcAssociationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput)
-	return ret0, ret1
-}
-
-// DescribeLocalGatewayRouteTableVpcAssociationsRequest indicates an expected call of DescribeLocalGatewayRouteTableVpcAssociationsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVpcAssociationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVpcAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVpcAssociationsRequest), arg0)
-}
-
-// DescribeLocalGatewayRouteTableVpcAssociationsWithContext mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayRouteTableVpcAssociationsWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVpcAssociationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLocalGatewayRouteTableVpcAssociationsWithContext indicates an expected call of DescribeLocalGatewayRouteTableVpcAssociationsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVpcAssociationsWithContext(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, "DescribeLocalGatewayRouteTableVpcAssociationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVpcAssociationsWithContext), varargs...)
-}
-
-// DescribeLocalGatewayRouteTables mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayRouteTables(arg0 *ec2.DescribeLocalGatewayRouteTablesInput) (*ec2.DescribeLocalGatewayRouteTablesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTables", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTablesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLocalGatewayRouteTables indicates an expected call of DescribeLocalGatewayRouteTables.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTables(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTables", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTables), arg0)
-}
-
-// DescribeLocalGatewayRouteTablesPages mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayRouteTablesPages(arg0 *ec2.DescribeLocalGatewayRouteTablesInput, arg1 func(*ec2.DescribeLocalGatewayRouteTablesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTablesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeLocalGatewayRouteTablesPages indicates an expected call of DescribeLocalGatewayRouteTablesPages.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTablesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTablesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTablesPages), arg0, arg1)
-}
-
-// DescribeLocalGatewayRouteTablesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayRouteTablesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTablesInput, arg2 func(*ec2.DescribeLocalGatewayRouteTablesOutput, 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, "DescribeLocalGatewayRouteTablesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeLocalGatewayRouteTablesPagesWithContext indicates an expected call of DescribeLocalGatewayRouteTablesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTablesPagesWithContext(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, "DescribeLocalGatewayRouteTablesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTablesPagesWithContext), varargs...)
-}
-
-// DescribeLocalGatewayRouteTablesRequest mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayRouteTablesRequest(arg0 *ec2.DescribeLocalGatewayRouteTablesInput) (*request.Request, *ec2.DescribeLocalGatewayRouteTablesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTablesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeLocalGatewayRouteTablesOutput)
-	return ret0, ret1
-}
-
-// DescribeLocalGatewayRouteTablesRequest indicates an expected call of DescribeLocalGatewayRouteTablesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTablesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTablesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTablesRequest), arg0)
-}
-
-// DescribeLocalGatewayRouteTablesWithContext mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayRouteTablesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTablesInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewayRouteTablesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTablesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTablesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLocalGatewayRouteTablesWithContext indicates an expected call of DescribeLocalGatewayRouteTablesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTablesWithContext(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, "DescribeLocalGatewayRouteTablesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTablesWithContext), varargs...)
-}
-
-// DescribeLocalGatewayVirtualInterfaceGroups mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayVirtualInterfaceGroups(arg0 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput) (*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfaceGroups", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLocalGatewayVirtualInterfaceGroups indicates an expected call of DescribeLocalGatewayVirtualInterfaceGroups.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfaceGroups(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfaceGroups", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfaceGroups), arg0)
-}
-
-// DescribeLocalGatewayVirtualInterfaceGroupsPages mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayVirtualInterfaceGroupsPages(arg0 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput, arg1 func(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfaceGroupsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeLocalGatewayVirtualInterfaceGroupsPages indicates an expected call of DescribeLocalGatewayVirtualInterfaceGroupsPages.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfaceGroupsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfaceGroupsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfaceGroupsPages), arg0, arg1)
-}
-
-// DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput, arg2 func(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, 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, "DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext indicates an expected call of DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext(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, "DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext), varargs...)
-}
-
-// DescribeLocalGatewayVirtualInterfaceGroupsRequest mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayVirtualInterfaceGroupsRequest(arg0 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput) (*request.Request, *ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfaceGroupsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput)
-	return ret0, ret1
-}
-
-// DescribeLocalGatewayVirtualInterfaceGroupsRequest indicates an expected call of DescribeLocalGatewayVirtualInterfaceGroupsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfaceGroupsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfaceGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfaceGroupsRequest), arg0)
-}
-
-// DescribeLocalGatewayVirtualInterfaceGroupsWithContext mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayVirtualInterfaceGroupsWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfaceGroupsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLocalGatewayVirtualInterfaceGroupsWithContext indicates an expected call of DescribeLocalGatewayVirtualInterfaceGroupsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfaceGroupsWithContext(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, "DescribeLocalGatewayVirtualInterfaceGroupsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfaceGroupsWithContext), varargs...)
-}
-
-// DescribeLocalGatewayVirtualInterfaces mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayVirtualInterfaces(arg0 *ec2.DescribeLocalGatewayVirtualInterfacesInput) (*ec2.DescribeLocalGatewayVirtualInterfacesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfaces", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeLocalGatewayVirtualInterfacesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLocalGatewayVirtualInterfaces indicates an expected call of DescribeLocalGatewayVirtualInterfaces.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfaces(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfaces", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfaces), arg0)
-}
-
-// DescribeLocalGatewayVirtualInterfacesPages mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayVirtualInterfacesPages(arg0 *ec2.DescribeLocalGatewayVirtualInterfacesInput, arg1 func(*ec2.DescribeLocalGatewayVirtualInterfacesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfacesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeLocalGatewayVirtualInterfacesPages indicates an expected call of DescribeLocalGatewayVirtualInterfacesPages.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfacesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfacesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfacesPages), arg0, arg1)
-}
-
-// DescribeLocalGatewayVirtualInterfacesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayVirtualInterfacesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayVirtualInterfacesInput, arg2 func(*ec2.DescribeLocalGatewayVirtualInterfacesOutput, 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, "DescribeLocalGatewayVirtualInterfacesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeLocalGatewayVirtualInterfacesPagesWithContext indicates an expected call of DescribeLocalGatewayVirtualInterfacesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfacesPagesWithContext(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, "DescribeLocalGatewayVirtualInterfacesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfacesPagesWithContext), varargs...)
-}
-
-// DescribeLocalGatewayVirtualInterfacesRequest mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayVirtualInterfacesRequest(arg0 *ec2.DescribeLocalGatewayVirtualInterfacesInput) (*request.Request, *ec2.DescribeLocalGatewayVirtualInterfacesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfacesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeLocalGatewayVirtualInterfacesOutput)
-	return ret0, ret1
-}
-
-// DescribeLocalGatewayVirtualInterfacesRequest indicates an expected call of DescribeLocalGatewayVirtualInterfacesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfacesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfacesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfacesRequest), arg0)
-}
-
-// DescribeLocalGatewayVirtualInterfacesWithContext mocks base method.
-func (m *MockEC2API) DescribeLocalGatewayVirtualInterfacesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayVirtualInterfacesInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewayVirtualInterfacesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfacesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeLocalGatewayVirtualInterfacesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLocalGatewayVirtualInterfacesWithContext indicates an expected call of DescribeLocalGatewayVirtualInterfacesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfacesWithContext(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, "DescribeLocalGatewayVirtualInterfacesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfacesWithContext), varargs...)
-}
-
-// DescribeLocalGateways mocks base method.
-func (m *MockEC2API) DescribeLocalGateways(arg0 *ec2.DescribeLocalGatewaysInput) (*ec2.DescribeLocalGatewaysOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLocalGateways", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeLocalGatewaysOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLocalGateways indicates an expected call of DescribeLocalGateways.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGateways(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGateways), arg0)
-}
-
-// DescribeLocalGatewaysPages mocks base method.
-func (m *MockEC2API) DescribeLocalGatewaysPages(arg0 *ec2.DescribeLocalGatewaysInput, arg1 func(*ec2.DescribeLocalGatewaysOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLocalGatewaysPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeLocalGatewaysPages indicates an expected call of DescribeLocalGatewaysPages.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewaysPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewaysPages), arg0, arg1)
-}
-
-// DescribeLocalGatewaysPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeLocalGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewaysInput, arg2 func(*ec2.DescribeLocalGatewaysOutput, 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, "DescribeLocalGatewaysPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeLocalGatewaysPagesWithContext indicates an expected call of DescribeLocalGatewaysPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewaysPagesWithContext(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, "DescribeLocalGatewaysPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewaysPagesWithContext), varargs...)
-}
-
-// DescribeLocalGatewaysRequest mocks base method.
-func (m *MockEC2API) DescribeLocalGatewaysRequest(arg0 *ec2.DescribeLocalGatewaysInput) (*request.Request, *ec2.DescribeLocalGatewaysOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLocalGatewaysRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeLocalGatewaysOutput)
-	return ret0, ret1
-}
-
-// DescribeLocalGatewaysRequest indicates an expected call of DescribeLocalGatewaysRequest.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewaysRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewaysRequest), arg0)
-}
-
-// DescribeLocalGatewaysWithContext mocks base method.
-func (m *MockEC2API) DescribeLocalGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewaysInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewaysOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeLocalGatewaysWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeLocalGatewaysOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLocalGatewaysWithContext indicates an expected call of DescribeLocalGatewaysWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeLocalGatewaysWithContext(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, "DescribeLocalGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewaysWithContext), varargs...)
-}
-
-// DescribeLockedSnapshots mocks base method.
-func (m *MockEC2API) DescribeLockedSnapshots(arg0 *ec2.DescribeLockedSnapshotsInput) (*ec2.DescribeLockedSnapshotsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLockedSnapshots", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeLockedSnapshotsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLockedSnapshots indicates an expected call of DescribeLockedSnapshots.
-func (mr *MockEC2APIMockRecorder) DescribeLockedSnapshots(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLockedSnapshots", reflect.TypeOf((*MockEC2API)(nil).DescribeLockedSnapshots), arg0)
-}
-
-// DescribeLockedSnapshotsRequest mocks base method.
-func (m *MockEC2API) DescribeLockedSnapshotsRequest(arg0 *ec2.DescribeLockedSnapshotsInput) (*request.Request, *ec2.DescribeLockedSnapshotsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeLockedSnapshotsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeLockedSnapshotsOutput)
-	return ret0, ret1
-}
-
-// DescribeLockedSnapshotsRequest indicates an expected call of DescribeLockedSnapshotsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeLockedSnapshotsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLockedSnapshotsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLockedSnapshotsRequest), arg0)
-}
-
-// DescribeLockedSnapshotsWithContext mocks base method.
-func (m *MockEC2API) DescribeLockedSnapshotsWithContext(arg0 context.Context, arg1 *ec2.DescribeLockedSnapshotsInput, arg2 ...request.Option) (*ec2.DescribeLockedSnapshotsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeLockedSnapshotsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeLockedSnapshotsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeLockedSnapshotsWithContext indicates an expected call of DescribeLockedSnapshotsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeLockedSnapshotsWithContext(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, "DescribeLockedSnapshotsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLockedSnapshotsWithContext), varargs...)
-}
-
-// DescribeMacHosts mocks base method.
-func (m *MockEC2API) DescribeMacHosts(arg0 *ec2.DescribeMacHostsInput) (*ec2.DescribeMacHostsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeMacHosts", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeMacHostsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeMacHosts indicates an expected call of DescribeMacHosts.
-func (mr *MockEC2APIMockRecorder) DescribeMacHosts(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMacHosts", reflect.TypeOf((*MockEC2API)(nil).DescribeMacHosts), arg0)
-}
-
-// DescribeMacHostsPages mocks base method.
-func (m *MockEC2API) DescribeMacHostsPages(arg0 *ec2.DescribeMacHostsInput, arg1 func(*ec2.DescribeMacHostsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeMacHostsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeMacHostsPages indicates an expected call of DescribeMacHostsPages.
-func (mr *MockEC2APIMockRecorder) DescribeMacHostsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMacHostsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeMacHostsPages), arg0, arg1)
-}
-
-// DescribeMacHostsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeMacHostsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeMacHostsInput, arg2 func(*ec2.DescribeMacHostsOutput, 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, "DescribeMacHostsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeMacHostsPagesWithContext indicates an expected call of DescribeMacHostsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeMacHostsPagesWithContext(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, "DescribeMacHostsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeMacHostsPagesWithContext), varargs...)
-}
-
-// DescribeMacHostsRequest mocks base method.
-func (m *MockEC2API) DescribeMacHostsRequest(arg0 *ec2.DescribeMacHostsInput) (*request.Request, *ec2.DescribeMacHostsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeMacHostsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeMacHostsOutput)
-	return ret0, ret1
-}
-
-// DescribeMacHostsRequest indicates an expected call of DescribeMacHostsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeMacHostsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMacHostsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeMacHostsRequest), arg0)
-}
-
-// DescribeMacHostsWithContext mocks base method.
-func (m *MockEC2API) DescribeMacHostsWithContext(arg0 context.Context, arg1 *ec2.DescribeMacHostsInput, arg2 ...request.Option) (*ec2.DescribeMacHostsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeMacHostsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeMacHostsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeMacHostsWithContext indicates an expected call of DescribeMacHostsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeMacHostsWithContext(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, "DescribeMacHostsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeMacHostsWithContext), varargs...)
-}
-
-// DescribeManagedPrefixLists mocks base method.
-func (m *MockEC2API) DescribeManagedPrefixLists(arg0 *ec2.DescribeManagedPrefixListsInput) (*ec2.DescribeManagedPrefixListsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeManagedPrefixLists", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeManagedPrefixListsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeManagedPrefixLists indicates an expected call of DescribeManagedPrefixLists.
-func (mr *MockEC2APIMockRecorder) DescribeManagedPrefixLists(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeManagedPrefixLists", reflect.TypeOf((*MockEC2API)(nil).DescribeManagedPrefixLists), arg0)
-}
-
-// DescribeManagedPrefixListsPages mocks base method.
-func (m *MockEC2API) DescribeManagedPrefixListsPages(arg0 *ec2.DescribeManagedPrefixListsInput, arg1 func(*ec2.DescribeManagedPrefixListsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeManagedPrefixListsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeManagedPrefixListsPages indicates an expected call of DescribeManagedPrefixListsPages.
-func (mr *MockEC2APIMockRecorder) DescribeManagedPrefixListsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeManagedPrefixListsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeManagedPrefixListsPages), arg0, arg1)
-}
-
-// DescribeManagedPrefixListsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeManagedPrefixListsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeManagedPrefixListsInput, arg2 func(*ec2.DescribeManagedPrefixListsOutput, 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, "DescribeManagedPrefixListsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeManagedPrefixListsPagesWithContext indicates an expected call of DescribeManagedPrefixListsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeManagedPrefixListsPagesWithContext(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, "DescribeManagedPrefixListsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeManagedPrefixListsPagesWithContext), varargs...)
-}
-
-// DescribeManagedPrefixListsRequest mocks base method.
-func (m *MockEC2API) DescribeManagedPrefixListsRequest(arg0 *ec2.DescribeManagedPrefixListsInput) (*request.Request, *ec2.DescribeManagedPrefixListsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeManagedPrefixListsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeManagedPrefixListsOutput)
-	return ret0, ret1
-}
-
-// DescribeManagedPrefixListsRequest indicates an expected call of DescribeManagedPrefixListsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeManagedPrefixListsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeManagedPrefixListsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeManagedPrefixListsRequest), arg0)
-}
-
-// DescribeManagedPrefixListsWithContext mocks base method.
-func (m *MockEC2API) DescribeManagedPrefixListsWithContext(arg0 context.Context, arg1 *ec2.DescribeManagedPrefixListsInput, arg2 ...request.Option) (*ec2.DescribeManagedPrefixListsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeManagedPrefixListsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeManagedPrefixListsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeManagedPrefixListsWithContext indicates an expected call of DescribeManagedPrefixListsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeManagedPrefixListsWithContext(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, "DescribeManagedPrefixListsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeManagedPrefixListsWithContext), varargs...)
-}
-
-// DescribeMovingAddresses mocks base method.
-func (m *MockEC2API) DescribeMovingAddresses(arg0 *ec2.DescribeMovingAddressesInput) (*ec2.DescribeMovingAddressesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeMovingAddresses", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeMovingAddressesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeMovingAddresses indicates an expected call of DescribeMovingAddresses.
-func (mr *MockEC2APIMockRecorder) DescribeMovingAddresses(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMovingAddresses", reflect.TypeOf((*MockEC2API)(nil).DescribeMovingAddresses), arg0)
-}
-
-// DescribeMovingAddressesPages mocks base method.
-func (m *MockEC2API) DescribeMovingAddressesPages(arg0 *ec2.DescribeMovingAddressesInput, arg1 func(*ec2.DescribeMovingAddressesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeMovingAddressesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeMovingAddressesPages indicates an expected call of DescribeMovingAddressesPages.
-func (mr *MockEC2APIMockRecorder) DescribeMovingAddressesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMovingAddressesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeMovingAddressesPages), arg0, arg1)
-}
-
-// DescribeMovingAddressesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeMovingAddressesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeMovingAddressesInput, arg2 func(*ec2.DescribeMovingAddressesOutput, 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, "DescribeMovingAddressesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeMovingAddressesPagesWithContext indicates an expected call of DescribeMovingAddressesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeMovingAddressesPagesWithContext(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, "DescribeMovingAddressesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeMovingAddressesPagesWithContext), varargs...)
-}
-
-// DescribeMovingAddressesRequest mocks base method.
-func (m *MockEC2API) DescribeMovingAddressesRequest(arg0 *ec2.DescribeMovingAddressesInput) (*request.Request, *ec2.DescribeMovingAddressesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeMovingAddressesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeMovingAddressesOutput)
-	return ret0, ret1
-}
-
-// DescribeMovingAddressesRequest indicates an expected call of DescribeMovingAddressesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeMovingAddressesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMovingAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeMovingAddressesRequest), arg0)
-}
-
-// DescribeMovingAddressesWithContext mocks base method.
-func (m *MockEC2API) DescribeMovingAddressesWithContext(arg0 context.Context, arg1 *ec2.DescribeMovingAddressesInput, arg2 ...request.Option) (*ec2.DescribeMovingAddressesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeMovingAddressesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeMovingAddressesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeMovingAddressesWithContext indicates an expected call of DescribeMovingAddressesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeMovingAddressesWithContext(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, "DescribeMovingAddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeMovingAddressesWithContext), varargs...)
-}
-
-// DescribeNatGateways mocks base method.
-func (m *MockEC2API) DescribeNatGateways(arg0 *ec2.DescribeNatGatewaysInput) (*ec2.DescribeNatGatewaysOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNatGateways", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeNatGatewaysOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeNatGateways indicates an expected call of DescribeNatGateways.
-func (mr *MockEC2APIMockRecorder) DescribeNatGateways(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeNatGateways), arg0)
-}
-
-// DescribeNatGatewaysPages mocks base method.
-func (m *MockEC2API) DescribeNatGatewaysPages(arg0 *ec2.DescribeNatGatewaysInput, arg1 func(*ec2.DescribeNatGatewaysOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNatGatewaysPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeNatGatewaysPages indicates an expected call of DescribeNatGatewaysPages.
-func (mr *MockEC2APIMockRecorder) DescribeNatGatewaysPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNatGatewaysPages), arg0, arg1)
-}
-
-// DescribeNatGatewaysPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeNatGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNatGatewaysInput, arg2 func(*ec2.DescribeNatGatewaysOutput, 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, "DescribeNatGatewaysPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeNatGatewaysPagesWithContext indicates an expected call of DescribeNatGatewaysPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeNatGatewaysPagesWithContext(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, "DescribeNatGatewaysPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNatGatewaysPagesWithContext), varargs...)
-}
-
-// DescribeNatGatewaysRequest mocks base method.
-func (m *MockEC2API) DescribeNatGatewaysRequest(arg0 *ec2.DescribeNatGatewaysInput) (*request.Request, *ec2.DescribeNatGatewaysOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNatGatewaysRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeNatGatewaysOutput)
-	return ret0, ret1
-}
-
-// DescribeNatGatewaysRequest indicates an expected call of DescribeNatGatewaysRequest.
-func (mr *MockEC2APIMockRecorder) DescribeNatGatewaysRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNatGatewaysRequest), arg0)
-}
-
-// DescribeNatGatewaysWithContext mocks base method.
-func (m *MockEC2API) DescribeNatGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeNatGatewaysInput, arg2 ...request.Option) (*ec2.DescribeNatGatewaysOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeNatGatewaysWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeNatGatewaysOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeNatGatewaysWithContext indicates an expected call of DescribeNatGatewaysWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeNatGatewaysWithContext(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, "DescribeNatGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNatGatewaysWithContext), varargs...)
-}
-
-// DescribeNetworkAcls mocks base method.
-func (m *MockEC2API) DescribeNetworkAcls(arg0 *ec2.DescribeNetworkAclsInput) (*ec2.DescribeNetworkAclsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNetworkAcls", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeNetworkAclsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeNetworkAcls indicates an expected call of DescribeNetworkAcls.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkAcls(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkAcls", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkAcls), arg0)
-}
-
-// DescribeNetworkAclsPages mocks base method.
-func (m *MockEC2API) DescribeNetworkAclsPages(arg0 *ec2.DescribeNetworkAclsInput, arg1 func(*ec2.DescribeNetworkAclsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNetworkAclsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeNetworkAclsPages indicates an expected call of DescribeNetworkAclsPages.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkAclsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkAclsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkAclsPages), arg0, arg1)
-}
-
-// DescribeNetworkAclsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeNetworkAclsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkAclsInput, arg2 func(*ec2.DescribeNetworkAclsOutput, 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, "DescribeNetworkAclsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeNetworkAclsPagesWithContext indicates an expected call of DescribeNetworkAclsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkAclsPagesWithContext(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, "DescribeNetworkAclsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkAclsPagesWithContext), varargs...)
-}
-
-// DescribeNetworkAclsRequest mocks base method.
-func (m *MockEC2API) DescribeNetworkAclsRequest(arg0 *ec2.DescribeNetworkAclsInput) (*request.Request, *ec2.DescribeNetworkAclsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNetworkAclsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeNetworkAclsOutput)
-	return ret0, ret1
-}
-
-// DescribeNetworkAclsRequest indicates an expected call of DescribeNetworkAclsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkAclsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkAclsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkAclsRequest), arg0)
-}
-
-// DescribeNetworkAclsWithContext mocks base method.
-func (m *MockEC2API) DescribeNetworkAclsWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkAclsInput, arg2 ...request.Option) (*ec2.DescribeNetworkAclsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeNetworkAclsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeNetworkAclsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeNetworkAclsWithContext indicates an expected call of DescribeNetworkAclsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkAclsWithContext(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, "DescribeNetworkAclsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkAclsWithContext), varargs...)
-}
-
-// DescribeNetworkInsightsAccessScopeAnalyses mocks base method.
-func (m *MockEC2API) DescribeNetworkInsightsAccessScopeAnalyses(arg0 *ec2.DescribeNetworkInsightsAccessScopeAnalysesInput) (*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopeAnalyses", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeNetworkInsightsAccessScopeAnalyses indicates an expected call of DescribeNetworkInsightsAccessScopeAnalyses.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAccessScopeAnalyses(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAccessScopeAnalyses", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAccessScopeAnalyses), arg0)
-}
-
-// DescribeNetworkInsightsAccessScopeAnalysesPages mocks base method.
-func (m *MockEC2API) DescribeNetworkInsightsAccessScopeAnalysesPages(arg0 *ec2.DescribeNetworkInsightsAccessScopeAnalysesInput, arg1 func(*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopeAnalysesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeNetworkInsightsAccessScopeAnalysesPages indicates an expected call of DescribeNetworkInsightsAccessScopeAnalysesPages.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAccessScopeAnalysesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAccessScopeAnalysesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAccessScopeAnalysesPages), arg0, arg1)
-}
-
-// DescribeNetworkInsightsAccessScopeAnalysesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeNetworkInsightsAccessScopeAnalysesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInsightsAccessScopeAnalysesInput, arg2 func(*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput, 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, "DescribeNetworkInsightsAccessScopeAnalysesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeNetworkInsightsAccessScopeAnalysesPagesWithContext indicates an expected call of DescribeNetworkInsightsAccessScopeAnalysesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAccessScopeAnalysesPagesWithContext(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, "DescribeNetworkInsightsAccessScopeAnalysesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAccessScopeAnalysesPagesWithContext), varargs...)
-}
-
-// DescribeNetworkInsightsAccessScopeAnalysesRequest mocks base method.
-func (m *MockEC2API) DescribeNetworkInsightsAccessScopeAnalysesRequest(arg0 *ec2.DescribeNetworkInsightsAccessScopeAnalysesInput) (*request.Request, *ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopeAnalysesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput)
-	return ret0, ret1
-}
-
-// DescribeNetworkInsightsAccessScopeAnalysesRequest indicates an expected call of DescribeNetworkInsightsAccessScopeAnalysesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAccessScopeAnalysesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAccessScopeAnalysesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAccessScopeAnalysesRequest), arg0)
-}
-
-// DescribeNetworkInsightsAccessScopeAnalysesWithContext mocks base method.
-func (m *MockEC2API) DescribeNetworkInsightsAccessScopeAnalysesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInsightsAccessScopeAnalysesInput, arg2 ...request.Option) (*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopeAnalysesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeNetworkInsightsAccessScopeAnalysesWithContext indicates an expected call of DescribeNetworkInsightsAccessScopeAnalysesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAccessScopeAnalysesWithContext(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, "DescribeNetworkInsightsAccessScopeAnalysesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAccessScopeAnalysesWithContext), varargs...)
-}
-
-// DescribeNetworkInsightsAccessScopes mocks base method.
-func (m *MockEC2API) DescribeNetworkInsightsAccessScopes(arg0 *ec2.DescribeNetworkInsightsAccessScopesInput) (*ec2.DescribeNetworkInsightsAccessScopesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopes", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsAccessScopesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeNetworkInsightsAccessScopes indicates an expected call of DescribeNetworkInsightsAccessScopes.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAccessScopes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAccessScopes", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAccessScopes), arg0)
-}
-
-// DescribeNetworkInsightsAccessScopesPages mocks base method.
-func (m *MockEC2API) DescribeNetworkInsightsAccessScopesPages(arg0 *ec2.DescribeNetworkInsightsAccessScopesInput, arg1 func(*ec2.DescribeNetworkInsightsAccessScopesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeNetworkInsightsAccessScopesPages indicates an expected call of DescribeNetworkInsightsAccessScopesPages.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAccessScopesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAccessScopesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAccessScopesPages), arg0, arg1)
-}
-
-// DescribeNetworkInsightsAccessScopesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeNetworkInsightsAccessScopesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInsightsAccessScopesInput, arg2 func(*ec2.DescribeNetworkInsightsAccessScopesOutput, 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, "DescribeNetworkInsightsAccessScopesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeNetworkInsightsAccessScopesPagesWithContext indicates an expected call of DescribeNetworkInsightsAccessScopesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAccessScopesPagesWithContext(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, "DescribeNetworkInsightsAccessScopesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAccessScopesPagesWithContext), varargs...)
-}
-
-// DescribeNetworkInsightsAccessScopesRequest mocks base method.
-func (m *MockEC2API) DescribeNetworkInsightsAccessScopesRequest(arg0 *ec2.DescribeNetworkInsightsAccessScopesInput) (*request.Request, *ec2.DescribeNetworkInsightsAccessScopesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeNetworkInsightsAccessScopesOutput)
-	return ret0, ret1
-}
-
-// DescribeNetworkInsightsAccessScopesRequest indicates an expected call of DescribeNetworkInsightsAccessScopesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAccessScopesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAccessScopesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAccessScopesRequest), arg0)
-}
-
-// DescribeNetworkInsightsAccessScopesWithContext mocks base method.
-func (m *MockEC2API) DescribeNetworkInsightsAccessScopesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInsightsAccessScopesInput, arg2 ...request.Option) (*ec2.DescribeNetworkInsightsAccessScopesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsAccessScopesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeNetworkInsightsAccessScopesWithContext indicates an expected call of DescribeNetworkInsightsAccessScopesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAccessScopesWithContext(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, "DescribeNetworkInsightsAccessScopesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAccessScopesWithContext), varargs...)
-}
-
-// DescribeNetworkInsightsAnalyses mocks base method.
-func (m *MockEC2API) DescribeNetworkInsightsAnalyses(arg0 *ec2.DescribeNetworkInsightsAnalysesInput) (*ec2.DescribeNetworkInsightsAnalysesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAnalyses", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsAnalysesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeNetworkInsightsAnalyses indicates an expected call of DescribeNetworkInsightsAnalyses.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAnalyses(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAnalyses", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAnalyses), arg0)
-}
-
-// DescribeNetworkInsightsAnalysesPages mocks base method.
-func (m *MockEC2API) DescribeNetworkInsightsAnalysesPages(arg0 *ec2.DescribeNetworkInsightsAnalysesInput, arg1 func(*ec2.DescribeNetworkInsightsAnalysesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAnalysesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeNetworkInsightsAnalysesPages indicates an expected call of DescribeNetworkInsightsAnalysesPages.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAnalysesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAnalysesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAnalysesPages), arg0, arg1)
-}
-
-// DescribeNetworkInsightsAnalysesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeNetworkInsightsAnalysesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInsightsAnalysesInput, arg2 func(*ec2.DescribeNetworkInsightsAnalysesOutput, 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, "DescribeNetworkInsightsAnalysesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeNetworkInsightsAnalysesPagesWithContext indicates an expected call of DescribeNetworkInsightsAnalysesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAnalysesPagesWithContext(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, "DescribeNetworkInsightsAnalysesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAnalysesPagesWithContext), varargs...)
-}
-
-// DescribeNetworkInsightsAnalysesRequest mocks base method.
-func (m *MockEC2API) DescribeNetworkInsightsAnalysesRequest(arg0 *ec2.DescribeNetworkInsightsAnalysesInput) (*request.Request, *ec2.DescribeNetworkInsightsAnalysesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAnalysesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeNetworkInsightsAnalysesOutput)
-	return ret0, ret1
-}
-
-// DescribeNetworkInsightsAnalysesRequest indicates an expected call of DescribeNetworkInsightsAnalysesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAnalysesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAnalysesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAnalysesRequest), arg0)
-}
-
-// DescribeNetworkInsightsAnalysesWithContext mocks base method.
-func (m *MockEC2API) DescribeNetworkInsightsAnalysesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInsightsAnalysesInput, arg2 ...request.Option) (*ec2.DescribeNetworkInsightsAnalysesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAnalysesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsAnalysesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeNetworkInsightsAnalysesWithContext indicates an expected call of DescribeNetworkInsightsAnalysesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAnalysesWithContext(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, "DescribeNetworkInsightsAnalysesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAnalysesWithContext), varargs...)
-}
-
-// DescribeNetworkInsightsPaths mocks base method.
-func (m *MockEC2API) DescribeNetworkInsightsPaths(arg0 *ec2.DescribeNetworkInsightsPathsInput) (*ec2.DescribeNetworkInsightsPathsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNetworkInsightsPaths", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsPathsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeNetworkInsightsPaths indicates an expected call of DescribeNetworkInsightsPaths.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsPaths(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsPaths", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsPaths), arg0)
-}
-
-// DescribeNetworkInsightsPathsPages mocks base method.
-func (m *MockEC2API) DescribeNetworkInsightsPathsPages(arg0 *ec2.DescribeNetworkInsightsPathsInput, arg1 func(*ec2.DescribeNetworkInsightsPathsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNetworkInsightsPathsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeNetworkInsightsPathsPages indicates an expected call of DescribeNetworkInsightsPathsPages.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsPathsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsPathsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsPathsPages), arg0, arg1)
-}
-
-// DescribeNetworkInsightsPathsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeNetworkInsightsPathsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInsightsPathsInput, arg2 func(*ec2.DescribeNetworkInsightsPathsOutput, 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, "DescribeNetworkInsightsPathsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeNetworkInsightsPathsPagesWithContext indicates an expected call of DescribeNetworkInsightsPathsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsPathsPagesWithContext(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, "DescribeNetworkInsightsPathsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsPathsPagesWithContext), varargs...)
-}
-
-// DescribeNetworkInsightsPathsRequest mocks base method.
-func (m *MockEC2API) DescribeNetworkInsightsPathsRequest(arg0 *ec2.DescribeNetworkInsightsPathsInput) (*request.Request, *ec2.DescribeNetworkInsightsPathsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNetworkInsightsPathsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeNetworkInsightsPathsOutput)
-	return ret0, ret1
-}
-
-// DescribeNetworkInsightsPathsRequest indicates an expected call of DescribeNetworkInsightsPathsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsPathsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsPathsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsPathsRequest), arg0)
-}
-
-// DescribeNetworkInsightsPathsWithContext mocks base method.
-func (m *MockEC2API) DescribeNetworkInsightsPathsWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInsightsPathsInput, arg2 ...request.Option) (*ec2.DescribeNetworkInsightsPathsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeNetworkInsightsPathsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsPathsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeNetworkInsightsPathsWithContext indicates an expected call of DescribeNetworkInsightsPathsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsPathsWithContext(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, "DescribeNetworkInsightsPathsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsPathsWithContext), varargs...)
-}
-
-// DescribeNetworkInterfaceAttribute mocks base method.
-func (m *MockEC2API) DescribeNetworkInterfaceAttribute(arg0 *ec2.DescribeNetworkInterfaceAttributeInput) (*ec2.DescribeNetworkInterfaceAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNetworkInterfaceAttribute", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeNetworkInterfaceAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeNetworkInterfaceAttribute indicates an expected call of DescribeNetworkInterfaceAttribute.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfaceAttribute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaceAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfaceAttribute), arg0)
-}
-
-// DescribeNetworkInterfaceAttributeRequest mocks base method.
-func (m *MockEC2API) DescribeNetworkInterfaceAttributeRequest(arg0 *ec2.DescribeNetworkInterfaceAttributeInput) (*request.Request, *ec2.DescribeNetworkInterfaceAttributeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNetworkInterfaceAttributeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeNetworkInterfaceAttributeOutput)
-	return ret0, ret1
-}
-
-// DescribeNetworkInterfaceAttributeRequest indicates an expected call of DescribeNetworkInterfaceAttributeRequest.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfaceAttributeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfaceAttributeRequest), arg0)
-}
-
-// DescribeNetworkInterfaceAttributeWithContext mocks base method.
-func (m *MockEC2API) DescribeNetworkInterfaceAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfaceAttributeInput, arg2 ...request.Option) (*ec2.DescribeNetworkInterfaceAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeNetworkInterfaceAttributeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeNetworkInterfaceAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeNetworkInterfaceAttributeWithContext indicates an expected call of DescribeNetworkInterfaceAttributeWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfaceAttributeWithContext(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, "DescribeNetworkInterfaceAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfaceAttributeWithContext), varargs...)
-}
-
-// DescribeNetworkInterfacePermissions mocks base method.
-func (m *MockEC2API) DescribeNetworkInterfacePermissions(arg0 *ec2.DescribeNetworkInterfacePermissionsInput) (*ec2.DescribeNetworkInterfacePermissionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNetworkInterfacePermissions", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeNetworkInterfacePermissionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeNetworkInterfacePermissions indicates an expected call of DescribeNetworkInterfacePermissions.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacePermissions(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacePermissions", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacePermissions), arg0)
-}
-
-// DescribeNetworkInterfacePermissionsPages mocks base method.
-func (m *MockEC2API) DescribeNetworkInterfacePermissionsPages(arg0 *ec2.DescribeNetworkInterfacePermissionsInput, arg1 func(*ec2.DescribeNetworkInterfacePermissionsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNetworkInterfacePermissionsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeNetworkInterfacePermissionsPages indicates an expected call of DescribeNetworkInterfacePermissionsPages.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacePermissionsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacePermissionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacePermissionsPages), arg0, arg1)
-}
-
-// DescribeNetworkInterfacePermissionsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeNetworkInterfacePermissionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfacePermissionsInput, arg2 func(*ec2.DescribeNetworkInterfacePermissionsOutput, 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, "DescribeNetworkInterfacePermissionsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeNetworkInterfacePermissionsPagesWithContext indicates an expected call of DescribeNetworkInterfacePermissionsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacePermissionsPagesWithContext(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, "DescribeNetworkInterfacePermissionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacePermissionsPagesWithContext), varargs...)
-}
-
-// DescribeNetworkInterfacePermissionsRequest mocks base method.
-func (m *MockEC2API) DescribeNetworkInterfacePermissionsRequest(arg0 *ec2.DescribeNetworkInterfacePermissionsInput) (*request.Request, *ec2.DescribeNetworkInterfacePermissionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNetworkInterfacePermissionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeNetworkInterfacePermissionsOutput)
-	return ret0, ret1
-}
-
-// DescribeNetworkInterfacePermissionsRequest indicates an expected call of DescribeNetworkInterfacePermissionsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacePermissionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacePermissionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacePermissionsRequest), arg0)
-}
-
-// DescribeNetworkInterfacePermissionsWithContext mocks base method.
-func (m *MockEC2API) DescribeNetworkInterfacePermissionsWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfacePermissionsInput, arg2 ...request.Option) (*ec2.DescribeNetworkInterfacePermissionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeNetworkInterfacePermissionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeNetworkInterfacePermissionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeNetworkInterfacePermissionsWithContext indicates an expected call of DescribeNetworkInterfacePermissionsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacePermissionsWithContext(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, "DescribeNetworkInterfacePermissionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacePermissionsWithContext), varargs...)
-}
-
-// DescribeNetworkInterfaces mocks base method.
-func (m *MockEC2API) DescribeNetworkInterfaces(arg0 *ec2.DescribeNetworkInterfacesInput) (*ec2.DescribeNetworkInterfacesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNetworkInterfaces", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeNetworkInterfacesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeNetworkInterfaces indicates an expected call of DescribeNetworkInterfaces.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfaces(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaces", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfaces), arg0)
-}
-
-// DescribeNetworkInterfacesPages mocks base method.
-func (m *MockEC2API) DescribeNetworkInterfacesPages(arg0 *ec2.DescribeNetworkInterfacesInput, arg1 func(*ec2.DescribeNetworkInterfacesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNetworkInterfacesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeNetworkInterfacesPages indicates an expected call of DescribeNetworkInterfacesPages.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacesPages), arg0, arg1)
-}
-
-// DescribeNetworkInterfacesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeNetworkInterfacesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfacesInput, arg2 func(*ec2.DescribeNetworkInterfacesOutput, 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, "DescribeNetworkInterfacesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeNetworkInterfacesPagesWithContext indicates an expected call of DescribeNetworkInterfacesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacesPagesWithContext(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, "DescribeNetworkInterfacesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacesPagesWithContext), varargs...)
-}
-
-// DescribeNetworkInterfacesRequest mocks base method.
-func (m *MockEC2API) DescribeNetworkInterfacesRequest(arg0 *ec2.DescribeNetworkInterfacesInput) (*request.Request, *ec2.DescribeNetworkInterfacesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeNetworkInterfacesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeNetworkInterfacesOutput)
-	return ret0, ret1
-}
-
-// DescribeNetworkInterfacesRequest indicates an expected call of DescribeNetworkInterfacesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacesRequest), arg0)
-}
-
-// DescribeNetworkInterfacesWithContext mocks base method.
-func (m *MockEC2API) DescribeNetworkInterfacesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfacesInput, arg2 ...request.Option) (*ec2.DescribeNetworkInterfacesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeNetworkInterfacesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeNetworkInterfacesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeNetworkInterfacesWithContext indicates an expected call of DescribeNetworkInterfacesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacesWithContext(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, "DescribeNetworkInterfacesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacesWithContext), varargs...)
-}
-
-// DescribePlacementGroups mocks base method.
-func (m *MockEC2API) DescribePlacementGroups(arg0 *ec2.DescribePlacementGroupsInput) (*ec2.DescribePlacementGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribePlacementGroups", arg0)
-	ret0, _ := ret[0].(*ec2.DescribePlacementGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribePlacementGroups indicates an expected call of DescribePlacementGroups.
-func (mr *MockEC2APIMockRecorder) DescribePlacementGroups(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePlacementGroups", reflect.TypeOf((*MockEC2API)(nil).DescribePlacementGroups), arg0)
-}
-
-// DescribePlacementGroupsRequest mocks base method.
-func (m *MockEC2API) DescribePlacementGroupsRequest(arg0 *ec2.DescribePlacementGroupsInput) (*request.Request, *ec2.DescribePlacementGroupsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribePlacementGroupsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribePlacementGroupsOutput)
-	return ret0, ret1
-}
-
-// DescribePlacementGroupsRequest indicates an expected call of DescribePlacementGroupsRequest.
-func (mr *MockEC2APIMockRecorder) DescribePlacementGroupsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePlacementGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribePlacementGroupsRequest), arg0)
-}
-
-// DescribePlacementGroupsWithContext mocks base method.
-func (m *MockEC2API) DescribePlacementGroupsWithContext(arg0 context.Context, arg1 *ec2.DescribePlacementGroupsInput, arg2 ...request.Option) (*ec2.DescribePlacementGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribePlacementGroupsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribePlacementGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribePlacementGroupsWithContext indicates an expected call of DescribePlacementGroupsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribePlacementGroupsWithContext(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, "DescribePlacementGroupsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribePlacementGroupsWithContext), varargs...)
-}
-
-// DescribePrefixLists mocks base method.
-func (m *MockEC2API) DescribePrefixLists(arg0 *ec2.DescribePrefixListsInput) (*ec2.DescribePrefixListsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribePrefixLists", arg0)
-	ret0, _ := ret[0].(*ec2.DescribePrefixListsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribePrefixLists indicates an expected call of DescribePrefixLists.
-func (mr *MockEC2APIMockRecorder) DescribePrefixLists(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrefixLists", reflect.TypeOf((*MockEC2API)(nil).DescribePrefixLists), arg0)
-}
-
-// DescribePrefixListsPages mocks base method.
-func (m *MockEC2API) DescribePrefixListsPages(arg0 *ec2.DescribePrefixListsInput, arg1 func(*ec2.DescribePrefixListsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribePrefixListsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribePrefixListsPages indicates an expected call of DescribePrefixListsPages.
-func (mr *MockEC2APIMockRecorder) DescribePrefixListsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrefixListsPages", reflect.TypeOf((*MockEC2API)(nil).DescribePrefixListsPages), arg0, arg1)
-}
-
-// DescribePrefixListsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribePrefixListsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribePrefixListsInput, arg2 func(*ec2.DescribePrefixListsOutput, 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, "DescribePrefixListsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribePrefixListsPagesWithContext indicates an expected call of DescribePrefixListsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribePrefixListsPagesWithContext(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, "DescribePrefixListsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribePrefixListsPagesWithContext), varargs...)
-}
-
-// DescribePrefixListsRequest mocks base method.
-func (m *MockEC2API) DescribePrefixListsRequest(arg0 *ec2.DescribePrefixListsInput) (*request.Request, *ec2.DescribePrefixListsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribePrefixListsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribePrefixListsOutput)
-	return ret0, ret1
-}
-
-// DescribePrefixListsRequest indicates an expected call of DescribePrefixListsRequest.
-func (mr *MockEC2APIMockRecorder) DescribePrefixListsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrefixListsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribePrefixListsRequest), arg0)
-}
-
-// DescribePrefixListsWithContext mocks base method.
-func (m *MockEC2API) DescribePrefixListsWithContext(arg0 context.Context, arg1 *ec2.DescribePrefixListsInput, arg2 ...request.Option) (*ec2.DescribePrefixListsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribePrefixListsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribePrefixListsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribePrefixListsWithContext indicates an expected call of DescribePrefixListsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribePrefixListsWithContext(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, "DescribePrefixListsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribePrefixListsWithContext), varargs...)
-}
-
-// DescribePrincipalIdFormat mocks base method.
-func (m *MockEC2API) DescribePrincipalIdFormat(arg0 *ec2.DescribePrincipalIdFormatInput) (*ec2.DescribePrincipalIdFormatOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribePrincipalIdFormat", arg0)
-	ret0, _ := ret[0].(*ec2.DescribePrincipalIdFormatOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribePrincipalIdFormat indicates an expected call of DescribePrincipalIdFormat.
-func (mr *MockEC2APIMockRecorder) DescribePrincipalIdFormat(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrincipalIdFormat", reflect.TypeOf((*MockEC2API)(nil).DescribePrincipalIdFormat), arg0)
-}
-
-// DescribePrincipalIdFormatPages mocks base method.
-func (m *MockEC2API) DescribePrincipalIdFormatPages(arg0 *ec2.DescribePrincipalIdFormatInput, arg1 func(*ec2.DescribePrincipalIdFormatOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribePrincipalIdFormatPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribePrincipalIdFormatPages indicates an expected call of DescribePrincipalIdFormatPages.
-func (mr *MockEC2APIMockRecorder) DescribePrincipalIdFormatPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrincipalIdFormatPages", reflect.TypeOf((*MockEC2API)(nil).DescribePrincipalIdFormatPages), arg0, arg1)
-}
-
-// DescribePrincipalIdFormatPagesWithContext mocks base method.
-func (m *MockEC2API) DescribePrincipalIdFormatPagesWithContext(arg0 context.Context, arg1 *ec2.DescribePrincipalIdFormatInput, arg2 func(*ec2.DescribePrincipalIdFormatOutput, 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, "DescribePrincipalIdFormatPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribePrincipalIdFormatPagesWithContext indicates an expected call of DescribePrincipalIdFormatPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribePrincipalIdFormatPagesWithContext(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, "DescribePrincipalIdFormatPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribePrincipalIdFormatPagesWithContext), varargs...)
-}
-
-// DescribePrincipalIdFormatRequest mocks base method.
-func (m *MockEC2API) DescribePrincipalIdFormatRequest(arg0 *ec2.DescribePrincipalIdFormatInput) (*request.Request, *ec2.DescribePrincipalIdFormatOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribePrincipalIdFormatRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribePrincipalIdFormatOutput)
-	return ret0, ret1
-}
-
-// DescribePrincipalIdFormatRequest indicates an expected call of DescribePrincipalIdFormatRequest.
-func (mr *MockEC2APIMockRecorder) DescribePrincipalIdFormatRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrincipalIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).DescribePrincipalIdFormatRequest), arg0)
-}
-
-// DescribePrincipalIdFormatWithContext mocks base method.
-func (m *MockEC2API) DescribePrincipalIdFormatWithContext(arg0 context.Context, arg1 *ec2.DescribePrincipalIdFormatInput, arg2 ...request.Option) (*ec2.DescribePrincipalIdFormatOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribePrincipalIdFormatWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribePrincipalIdFormatOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribePrincipalIdFormatWithContext indicates an expected call of DescribePrincipalIdFormatWithContext.
-func (mr *MockEC2APIMockRecorder) DescribePrincipalIdFormatWithContext(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, "DescribePrincipalIdFormatWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribePrincipalIdFormatWithContext), varargs...)
-}
-
-// DescribePublicIpv4Pools mocks base method.
-func (m *MockEC2API) DescribePublicIpv4Pools(arg0 *ec2.DescribePublicIpv4PoolsInput) (*ec2.DescribePublicIpv4PoolsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribePublicIpv4Pools", arg0)
-	ret0, _ := ret[0].(*ec2.DescribePublicIpv4PoolsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribePublicIpv4Pools indicates an expected call of DescribePublicIpv4Pools.
-func (mr *MockEC2APIMockRecorder) DescribePublicIpv4Pools(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublicIpv4Pools", reflect.TypeOf((*MockEC2API)(nil).DescribePublicIpv4Pools), arg0)
-}
-
-// DescribePublicIpv4PoolsPages mocks base method.
-func (m *MockEC2API) DescribePublicIpv4PoolsPages(arg0 *ec2.DescribePublicIpv4PoolsInput, arg1 func(*ec2.DescribePublicIpv4PoolsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribePublicIpv4PoolsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribePublicIpv4PoolsPages indicates an expected call of DescribePublicIpv4PoolsPages.
-func (mr *MockEC2APIMockRecorder) DescribePublicIpv4PoolsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublicIpv4PoolsPages", reflect.TypeOf((*MockEC2API)(nil).DescribePublicIpv4PoolsPages), arg0, arg1)
-}
-
-// DescribePublicIpv4PoolsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribePublicIpv4PoolsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribePublicIpv4PoolsInput, arg2 func(*ec2.DescribePublicIpv4PoolsOutput, 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, "DescribePublicIpv4PoolsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribePublicIpv4PoolsPagesWithContext indicates an expected call of DescribePublicIpv4PoolsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribePublicIpv4PoolsPagesWithContext(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, "DescribePublicIpv4PoolsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribePublicIpv4PoolsPagesWithContext), varargs...)
-}
-
-// DescribePublicIpv4PoolsRequest mocks base method.
-func (m *MockEC2API) DescribePublicIpv4PoolsRequest(arg0 *ec2.DescribePublicIpv4PoolsInput) (*request.Request, *ec2.DescribePublicIpv4PoolsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribePublicIpv4PoolsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribePublicIpv4PoolsOutput)
-	return ret0, ret1
-}
-
-// DescribePublicIpv4PoolsRequest indicates an expected call of DescribePublicIpv4PoolsRequest.
-func (mr *MockEC2APIMockRecorder) DescribePublicIpv4PoolsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublicIpv4PoolsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribePublicIpv4PoolsRequest), arg0)
-}
-
-// DescribePublicIpv4PoolsWithContext mocks base method.
-func (m *MockEC2API) DescribePublicIpv4PoolsWithContext(arg0 context.Context, arg1 *ec2.DescribePublicIpv4PoolsInput, arg2 ...request.Option) (*ec2.DescribePublicIpv4PoolsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribePublicIpv4PoolsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribePublicIpv4PoolsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribePublicIpv4PoolsWithContext indicates an expected call of DescribePublicIpv4PoolsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribePublicIpv4PoolsWithContext(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, "DescribePublicIpv4PoolsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribePublicIpv4PoolsWithContext), varargs...)
-}
-
-// DescribeRegions mocks base method.
-func (m *MockEC2API) DescribeRegions(arg0 *ec2.DescribeRegionsInput) (*ec2.DescribeRegionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeRegions", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeRegionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeRegions indicates an expected call of DescribeRegions.
-func (mr *MockEC2APIMockRecorder) DescribeRegions(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegions", reflect.TypeOf((*MockEC2API)(nil).DescribeRegions), arg0)
-}
-
-// DescribeRegionsRequest mocks base method.
-func (m *MockEC2API) DescribeRegionsRequest(arg0 *ec2.DescribeRegionsInput) (*request.Request, *ec2.DescribeRegionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeRegionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeRegionsOutput)
-	return ret0, ret1
-}
-
-// DescribeRegionsRequest indicates an expected call of DescribeRegionsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeRegionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeRegionsRequest), arg0)
-}
-
-// DescribeRegionsWithContext mocks base method.
-func (m *MockEC2API) DescribeRegionsWithContext(arg0 context.Context, arg1 *ec2.DescribeRegionsInput, arg2 ...request.Option) (*ec2.DescribeRegionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeRegionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeRegionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeRegionsWithContext indicates an expected call of DescribeRegionsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeRegionsWithContext(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, "DescribeRegionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeRegionsWithContext), varargs...)
-}
-
-// DescribeReplaceRootVolumeTasks mocks base method.
-func (m *MockEC2API) DescribeReplaceRootVolumeTasks(arg0 *ec2.DescribeReplaceRootVolumeTasksInput) (*ec2.DescribeReplaceRootVolumeTasksOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeReplaceRootVolumeTasks", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeReplaceRootVolumeTasksOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeReplaceRootVolumeTasks indicates an expected call of DescribeReplaceRootVolumeTasks.
-func (mr *MockEC2APIMockRecorder) DescribeReplaceRootVolumeTasks(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplaceRootVolumeTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeReplaceRootVolumeTasks), arg0)
-}
-
-// DescribeReplaceRootVolumeTasksPages mocks base method.
-func (m *MockEC2API) DescribeReplaceRootVolumeTasksPages(arg0 *ec2.DescribeReplaceRootVolumeTasksInput, arg1 func(*ec2.DescribeReplaceRootVolumeTasksOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeReplaceRootVolumeTasksPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeReplaceRootVolumeTasksPages indicates an expected call of DescribeReplaceRootVolumeTasksPages.
-func (mr *MockEC2APIMockRecorder) DescribeReplaceRootVolumeTasksPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplaceRootVolumeTasksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeReplaceRootVolumeTasksPages), arg0, arg1)
-}
-
-// DescribeReplaceRootVolumeTasksPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeReplaceRootVolumeTasksPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeReplaceRootVolumeTasksInput, arg2 func(*ec2.DescribeReplaceRootVolumeTasksOutput, 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, "DescribeReplaceRootVolumeTasksPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeReplaceRootVolumeTasksPagesWithContext indicates an expected call of DescribeReplaceRootVolumeTasksPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeReplaceRootVolumeTasksPagesWithContext(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, "DescribeReplaceRootVolumeTasksPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReplaceRootVolumeTasksPagesWithContext), varargs...)
-}
-
-// DescribeReplaceRootVolumeTasksRequest mocks base method.
-func (m *MockEC2API) DescribeReplaceRootVolumeTasksRequest(arg0 *ec2.DescribeReplaceRootVolumeTasksInput) (*request.Request, *ec2.DescribeReplaceRootVolumeTasksOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeReplaceRootVolumeTasksRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeReplaceRootVolumeTasksOutput)
-	return ret0, ret1
-}
-
-// DescribeReplaceRootVolumeTasksRequest indicates an expected call of DescribeReplaceRootVolumeTasksRequest.
-func (mr *MockEC2APIMockRecorder) DescribeReplaceRootVolumeTasksRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplaceRootVolumeTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReplaceRootVolumeTasksRequest), arg0)
-}
-
-// DescribeReplaceRootVolumeTasksWithContext mocks base method.
-func (m *MockEC2API) DescribeReplaceRootVolumeTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeReplaceRootVolumeTasksInput, arg2 ...request.Option) (*ec2.DescribeReplaceRootVolumeTasksOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeReplaceRootVolumeTasksWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeReplaceRootVolumeTasksOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeReplaceRootVolumeTasksWithContext indicates an expected call of DescribeReplaceRootVolumeTasksWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeReplaceRootVolumeTasksWithContext(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, "DescribeReplaceRootVolumeTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReplaceRootVolumeTasksWithContext), varargs...)
-}
-
-// DescribeReservedInstances mocks base method.
-func (m *MockEC2API) DescribeReservedInstances(arg0 *ec2.DescribeReservedInstancesInput) (*ec2.DescribeReservedInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeReservedInstances", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeReservedInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeReservedInstances indicates an expected call of DescribeReservedInstances.
-func (mr *MockEC2APIMockRecorder) DescribeReservedInstances(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstances), arg0)
-}
-
-// DescribeReservedInstancesListings mocks base method.
-func (m *MockEC2API) DescribeReservedInstancesListings(arg0 *ec2.DescribeReservedInstancesListingsInput) (*ec2.DescribeReservedInstancesListingsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeReservedInstancesListings", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeReservedInstancesListingsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeReservedInstancesListings indicates an expected call of DescribeReservedInstancesListings.
-func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesListings(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesListings", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesListings), arg0)
-}
-
-// DescribeReservedInstancesListingsRequest mocks base method.
-func (m *MockEC2API) DescribeReservedInstancesListingsRequest(arg0 *ec2.DescribeReservedInstancesListingsInput) (*request.Request, *ec2.DescribeReservedInstancesListingsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeReservedInstancesListingsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeReservedInstancesListingsOutput)
-	return ret0, ret1
-}
-
-// DescribeReservedInstancesListingsRequest indicates an expected call of DescribeReservedInstancesListingsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesListingsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesListingsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesListingsRequest), arg0)
-}
-
-// DescribeReservedInstancesListingsWithContext mocks base method.
-func (m *MockEC2API) DescribeReservedInstancesListingsWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesListingsInput, arg2 ...request.Option) (*ec2.DescribeReservedInstancesListingsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeReservedInstancesListingsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeReservedInstancesListingsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeReservedInstancesListingsWithContext indicates an expected call of DescribeReservedInstancesListingsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesListingsWithContext(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, "DescribeReservedInstancesListingsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesListingsWithContext), varargs...)
-}
-
-// DescribeReservedInstancesModifications mocks base method.
-func (m *MockEC2API) DescribeReservedInstancesModifications(arg0 *ec2.DescribeReservedInstancesModificationsInput) (*ec2.DescribeReservedInstancesModificationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeReservedInstancesModifications", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeReservedInstancesModificationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeReservedInstancesModifications indicates an expected call of DescribeReservedInstancesModifications.
-func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesModifications(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesModifications", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesModifications), arg0)
-}
-
-// DescribeReservedInstancesModificationsPages mocks base method.
-func (m *MockEC2API) DescribeReservedInstancesModificationsPages(arg0 *ec2.DescribeReservedInstancesModificationsInput, arg1 func(*ec2.DescribeReservedInstancesModificationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeReservedInstancesModificationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeReservedInstancesModificationsPages indicates an expected call of DescribeReservedInstancesModificationsPages.
-func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesModificationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesModificationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesModificationsPages), arg0, arg1)
-}
-
-// DescribeReservedInstancesModificationsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeReservedInstancesModificationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesModificationsInput, arg2 func(*ec2.DescribeReservedInstancesModificationsOutput, 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, "DescribeReservedInstancesModificationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeReservedInstancesModificationsPagesWithContext indicates an expected call of DescribeReservedInstancesModificationsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesModificationsPagesWithContext(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, "DescribeReservedInstancesModificationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesModificationsPagesWithContext), varargs...)
-}
-
-// DescribeReservedInstancesModificationsRequest mocks base method.
-func (m *MockEC2API) DescribeReservedInstancesModificationsRequest(arg0 *ec2.DescribeReservedInstancesModificationsInput) (*request.Request, *ec2.DescribeReservedInstancesModificationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeReservedInstancesModificationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeReservedInstancesModificationsOutput)
-	return ret0, ret1
-}
-
-// DescribeReservedInstancesModificationsRequest indicates an expected call of DescribeReservedInstancesModificationsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesModificationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesModificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesModificationsRequest), arg0)
-}
-
-// DescribeReservedInstancesModificationsWithContext mocks base method.
-func (m *MockEC2API) DescribeReservedInstancesModificationsWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesModificationsInput, arg2 ...request.Option) (*ec2.DescribeReservedInstancesModificationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeReservedInstancesModificationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeReservedInstancesModificationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeReservedInstancesModificationsWithContext indicates an expected call of DescribeReservedInstancesModificationsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesModificationsWithContext(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, "DescribeReservedInstancesModificationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesModificationsWithContext), varargs...)
-}
-
-// DescribeReservedInstancesOfferings mocks base method.
-func (m *MockEC2API) DescribeReservedInstancesOfferings(arg0 *ec2.DescribeReservedInstancesOfferingsInput) (*ec2.DescribeReservedInstancesOfferingsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeReservedInstancesOfferings", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeReservedInstancesOfferingsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeReservedInstancesOfferings indicates an expected call of DescribeReservedInstancesOfferings.
-func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesOfferings(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesOfferings", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesOfferings), arg0)
-}
-
-// DescribeReservedInstancesOfferingsPages mocks base method.
-func (m *MockEC2API) DescribeReservedInstancesOfferingsPages(arg0 *ec2.DescribeReservedInstancesOfferingsInput, arg1 func(*ec2.DescribeReservedInstancesOfferingsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeReservedInstancesOfferingsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeReservedInstancesOfferingsPages indicates an expected call of DescribeReservedInstancesOfferingsPages.
-func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesOfferingsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesOfferingsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesOfferingsPages), arg0, arg1)
-}
-
-// DescribeReservedInstancesOfferingsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeReservedInstancesOfferingsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesOfferingsInput, arg2 func(*ec2.DescribeReservedInstancesOfferingsOutput, 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, "DescribeReservedInstancesOfferingsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeReservedInstancesOfferingsPagesWithContext indicates an expected call of DescribeReservedInstancesOfferingsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesOfferingsPagesWithContext(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, "DescribeReservedInstancesOfferingsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesOfferingsPagesWithContext), varargs...)
-}
-
-// DescribeReservedInstancesOfferingsRequest mocks base method.
-func (m *MockEC2API) DescribeReservedInstancesOfferingsRequest(arg0 *ec2.DescribeReservedInstancesOfferingsInput) (*request.Request, *ec2.DescribeReservedInstancesOfferingsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeReservedInstancesOfferingsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeReservedInstancesOfferingsOutput)
-	return ret0, ret1
-}
-
-// DescribeReservedInstancesOfferingsRequest indicates an expected call of DescribeReservedInstancesOfferingsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesOfferingsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesOfferingsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesOfferingsRequest), arg0)
-}
-
-// DescribeReservedInstancesOfferingsWithContext mocks base method.
-func (m *MockEC2API) DescribeReservedInstancesOfferingsWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesOfferingsInput, arg2 ...request.Option) (*ec2.DescribeReservedInstancesOfferingsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeReservedInstancesOfferingsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeReservedInstancesOfferingsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeReservedInstancesOfferingsWithContext indicates an expected call of DescribeReservedInstancesOfferingsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesOfferingsWithContext(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, "DescribeReservedInstancesOfferingsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesOfferingsWithContext), varargs...)
-}
-
-// DescribeReservedInstancesRequest mocks base method.
-func (m *MockEC2API) DescribeReservedInstancesRequest(arg0 *ec2.DescribeReservedInstancesInput) (*request.Request, *ec2.DescribeReservedInstancesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeReservedInstancesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeReservedInstancesOutput)
-	return ret0, ret1
-}
-
-// DescribeReservedInstancesRequest indicates an expected call of DescribeReservedInstancesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesRequest), arg0)
-}
-
-// DescribeReservedInstancesWithContext mocks base method.
-func (m *MockEC2API) DescribeReservedInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesInput, arg2 ...request.Option) (*ec2.DescribeReservedInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeReservedInstancesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeReservedInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeReservedInstancesWithContext indicates an expected call of DescribeReservedInstancesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesWithContext(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, "DescribeReservedInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesWithContext), varargs...)
-}
-
-// DescribeRouteTables mocks base method.
-func (m *MockEC2API) DescribeRouteTables(arg0 *ec2.DescribeRouteTablesInput) (*ec2.DescribeRouteTablesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeRouteTables", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeRouteTablesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeRouteTables indicates an expected call of DescribeRouteTables.
-func (mr *MockEC2APIMockRecorder) DescribeRouteTables(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRouteTables", reflect.TypeOf((*MockEC2API)(nil).DescribeRouteTables), arg0)
-}
-
-// DescribeRouteTablesPages mocks base method.
-func (m *MockEC2API) DescribeRouteTablesPages(arg0 *ec2.DescribeRouteTablesInput, arg1 func(*ec2.DescribeRouteTablesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeRouteTablesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeRouteTablesPages indicates an expected call of DescribeRouteTablesPages.
-func (mr *MockEC2APIMockRecorder) DescribeRouteTablesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRouteTablesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeRouteTablesPages), arg0, arg1)
-}
-
-// DescribeRouteTablesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeRouteTablesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeRouteTablesInput, arg2 func(*ec2.DescribeRouteTablesOutput, 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, "DescribeRouteTablesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeRouteTablesPagesWithContext indicates an expected call of DescribeRouteTablesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeRouteTablesPagesWithContext(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, "DescribeRouteTablesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeRouteTablesPagesWithContext), varargs...)
-}
-
-// DescribeRouteTablesRequest mocks base method.
-func (m *MockEC2API) DescribeRouteTablesRequest(arg0 *ec2.DescribeRouteTablesInput) (*request.Request, *ec2.DescribeRouteTablesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeRouteTablesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeRouteTablesOutput)
-	return ret0, ret1
-}
-
-// DescribeRouteTablesRequest indicates an expected call of DescribeRouteTablesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeRouteTablesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRouteTablesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeRouteTablesRequest), arg0)
-}
-
-// DescribeRouteTablesWithContext mocks base method.
-func (m *MockEC2API) DescribeRouteTablesWithContext(arg0 context.Context, arg1 *ec2.DescribeRouteTablesInput, arg2 ...request.Option) (*ec2.DescribeRouteTablesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeRouteTablesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeRouteTablesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeRouteTablesWithContext indicates an expected call of DescribeRouteTablesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeRouteTablesWithContext(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, "DescribeRouteTablesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeRouteTablesWithContext), varargs...)
-}
-
-// DescribeScheduledInstanceAvailability mocks base method.
-func (m *MockEC2API) DescribeScheduledInstanceAvailability(arg0 *ec2.DescribeScheduledInstanceAvailabilityInput) (*ec2.DescribeScheduledInstanceAvailabilityOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeScheduledInstanceAvailability", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeScheduledInstanceAvailabilityOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeScheduledInstanceAvailability indicates an expected call of DescribeScheduledInstanceAvailability.
-func (mr *MockEC2APIMockRecorder) DescribeScheduledInstanceAvailability(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailability", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstanceAvailability), arg0)
-}
-
-// DescribeScheduledInstanceAvailabilityPages mocks base method.
-func (m *MockEC2API) DescribeScheduledInstanceAvailabilityPages(arg0 *ec2.DescribeScheduledInstanceAvailabilityInput, arg1 func(*ec2.DescribeScheduledInstanceAvailabilityOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeScheduledInstanceAvailabilityPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeScheduledInstanceAvailabilityPages indicates an expected call of DescribeScheduledInstanceAvailabilityPages.
-func (mr *MockEC2APIMockRecorder) DescribeScheduledInstanceAvailabilityPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailabilityPages", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstanceAvailabilityPages), arg0, arg1)
-}
-
-// DescribeScheduledInstanceAvailabilityPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeScheduledInstanceAvailabilityPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeScheduledInstanceAvailabilityInput, arg2 func(*ec2.DescribeScheduledInstanceAvailabilityOutput, 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, "DescribeScheduledInstanceAvailabilityPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeScheduledInstanceAvailabilityPagesWithContext indicates an expected call of DescribeScheduledInstanceAvailabilityPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeScheduledInstanceAvailabilityPagesWithContext(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, "DescribeScheduledInstanceAvailabilityPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstanceAvailabilityPagesWithContext), varargs...)
-}
-
-// DescribeScheduledInstanceAvailabilityRequest mocks base method.
-func (m *MockEC2API) DescribeScheduledInstanceAvailabilityRequest(arg0 *ec2.DescribeScheduledInstanceAvailabilityInput) (*request.Request, *ec2.DescribeScheduledInstanceAvailabilityOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeScheduledInstanceAvailabilityRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeScheduledInstanceAvailabilityOutput)
-	return ret0, ret1
-}
-
-// DescribeScheduledInstanceAvailabilityRequest indicates an expected call of DescribeScheduledInstanceAvailabilityRequest.
-func (mr *MockEC2APIMockRecorder) DescribeScheduledInstanceAvailabilityRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailabilityRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstanceAvailabilityRequest), arg0)
-}
-
-// DescribeScheduledInstanceAvailabilityWithContext mocks base method.
-func (m *MockEC2API) DescribeScheduledInstanceAvailabilityWithContext(arg0 context.Context, arg1 *ec2.DescribeScheduledInstanceAvailabilityInput, arg2 ...request.Option) (*ec2.DescribeScheduledInstanceAvailabilityOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeScheduledInstanceAvailabilityWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeScheduledInstanceAvailabilityOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeScheduledInstanceAvailabilityWithContext indicates an expected call of DescribeScheduledInstanceAvailabilityWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeScheduledInstanceAvailabilityWithContext(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, "DescribeScheduledInstanceAvailabilityWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstanceAvailabilityWithContext), varargs...)
-}
-
-// DescribeScheduledInstances mocks base method.
-func (m *MockEC2API) DescribeScheduledInstances(arg0 *ec2.DescribeScheduledInstancesInput) (*ec2.DescribeScheduledInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeScheduledInstances", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeScheduledInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeScheduledInstances indicates an expected call of DescribeScheduledInstances.
-func (mr *MockEC2APIMockRecorder) DescribeScheduledInstances(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstances), arg0)
-}
-
-// DescribeScheduledInstancesPages mocks base method.
-func (m *MockEC2API) DescribeScheduledInstancesPages(arg0 *ec2.DescribeScheduledInstancesInput, arg1 func(*ec2.DescribeScheduledInstancesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeScheduledInstancesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeScheduledInstancesPages indicates an expected call of DescribeScheduledInstancesPages.
-func (mr *MockEC2APIMockRecorder) DescribeScheduledInstancesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstancesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstancesPages), arg0, arg1)
-}
-
-// DescribeScheduledInstancesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeScheduledInstancesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeScheduledInstancesInput, arg2 func(*ec2.DescribeScheduledInstancesOutput, 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, "DescribeScheduledInstancesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeScheduledInstancesPagesWithContext indicates an expected call of DescribeScheduledInstancesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeScheduledInstancesPagesWithContext(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, "DescribeScheduledInstancesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstancesPagesWithContext), varargs...)
-}
-
-// DescribeScheduledInstancesRequest mocks base method.
-func (m *MockEC2API) DescribeScheduledInstancesRequest(arg0 *ec2.DescribeScheduledInstancesInput) (*request.Request, *ec2.DescribeScheduledInstancesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeScheduledInstancesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeScheduledInstancesOutput)
-	return ret0, ret1
-}
-
-// DescribeScheduledInstancesRequest indicates an expected call of DescribeScheduledInstancesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeScheduledInstancesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstancesRequest), arg0)
-}
-
-// DescribeScheduledInstancesWithContext mocks base method.
-func (m *MockEC2API) DescribeScheduledInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeScheduledInstancesInput, arg2 ...request.Option) (*ec2.DescribeScheduledInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeScheduledInstancesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeScheduledInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeScheduledInstancesWithContext indicates an expected call of DescribeScheduledInstancesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeScheduledInstancesWithContext(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, "DescribeScheduledInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstancesWithContext), varargs...)
-}
-
-// DescribeSecurityGroupReferences mocks base method.
-func (m *MockEC2API) DescribeSecurityGroupReferences(arg0 *ec2.DescribeSecurityGroupReferencesInput) (*ec2.DescribeSecurityGroupReferencesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSecurityGroupReferences", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeSecurityGroupReferencesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSecurityGroupReferences indicates an expected call of DescribeSecurityGroupReferences.
-func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupReferences(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupReferences", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupReferences), arg0)
-}
-
-// DescribeSecurityGroupReferencesRequest mocks base method.
-func (m *MockEC2API) DescribeSecurityGroupReferencesRequest(arg0 *ec2.DescribeSecurityGroupReferencesInput) (*request.Request, *ec2.DescribeSecurityGroupReferencesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSecurityGroupReferencesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeSecurityGroupReferencesOutput)
-	return ret0, ret1
-}
-
-// DescribeSecurityGroupReferencesRequest indicates an expected call of DescribeSecurityGroupReferencesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupReferencesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupReferencesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupReferencesRequest), arg0)
-}
-
-// DescribeSecurityGroupReferencesWithContext mocks base method.
-func (m *MockEC2API) DescribeSecurityGroupReferencesWithContext(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupReferencesInput, arg2 ...request.Option) (*ec2.DescribeSecurityGroupReferencesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeSecurityGroupReferencesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeSecurityGroupReferencesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSecurityGroupReferencesWithContext indicates an expected call of DescribeSecurityGroupReferencesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupReferencesWithContext(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, "DescribeSecurityGroupReferencesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupReferencesWithContext), varargs...)
-}
-
-// DescribeSecurityGroupRules mocks base method.
-func (m *MockEC2API) DescribeSecurityGroupRules(arg0 *ec2.DescribeSecurityGroupRulesInput) (*ec2.DescribeSecurityGroupRulesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSecurityGroupRules", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeSecurityGroupRulesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSecurityGroupRules indicates an expected call of DescribeSecurityGroupRules.
-func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupRules(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupRules", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupRules), arg0)
-}
-
-// DescribeSecurityGroupRulesPages mocks base method.
-func (m *MockEC2API) DescribeSecurityGroupRulesPages(arg0 *ec2.DescribeSecurityGroupRulesInput, arg1 func(*ec2.DescribeSecurityGroupRulesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSecurityGroupRulesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeSecurityGroupRulesPages indicates an expected call of DescribeSecurityGroupRulesPages.
-func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupRulesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupRulesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupRulesPages), arg0, arg1)
-}
-
-// DescribeSecurityGroupRulesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeSecurityGroupRulesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupRulesInput, arg2 func(*ec2.DescribeSecurityGroupRulesOutput, 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, "DescribeSecurityGroupRulesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeSecurityGroupRulesPagesWithContext indicates an expected call of DescribeSecurityGroupRulesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupRulesPagesWithContext(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, "DescribeSecurityGroupRulesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupRulesPagesWithContext), varargs...)
-}
-
-// DescribeSecurityGroupRulesRequest mocks base method.
-func (m *MockEC2API) DescribeSecurityGroupRulesRequest(arg0 *ec2.DescribeSecurityGroupRulesInput) (*request.Request, *ec2.DescribeSecurityGroupRulesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSecurityGroupRulesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeSecurityGroupRulesOutput)
-	return ret0, ret1
-}
-
-// DescribeSecurityGroupRulesRequest indicates an expected call of DescribeSecurityGroupRulesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupRulesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupRulesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupRulesRequest), arg0)
-}
-
-// DescribeSecurityGroupRulesWithContext mocks base method.
-func (m *MockEC2API) DescribeSecurityGroupRulesWithContext(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupRulesInput, arg2 ...request.Option) (*ec2.DescribeSecurityGroupRulesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeSecurityGroupRulesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeSecurityGroupRulesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSecurityGroupRulesWithContext indicates an expected call of DescribeSecurityGroupRulesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupRulesWithContext(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, "DescribeSecurityGroupRulesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupRulesWithContext), varargs...)
-}
-
-// DescribeSecurityGroups mocks base method.
-func (m *MockEC2API) DescribeSecurityGroups(arg0 *ec2.DescribeSecurityGroupsInput) (*ec2.DescribeSecurityGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSecurityGroups", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeSecurityGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSecurityGroups indicates an expected call of DescribeSecurityGroups.
-func (mr *MockEC2APIMockRecorder) DescribeSecurityGroups(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroups", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroups), arg0)
-}
-
-// DescribeSecurityGroupsPages mocks base method.
-func (m *MockEC2API) DescribeSecurityGroupsPages(arg0 *ec2.DescribeSecurityGroupsInput, arg1 func(*ec2.DescribeSecurityGroupsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSecurityGroupsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeSecurityGroupsPages indicates an expected call of DescribeSecurityGroupsPages.
-func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupsPages), arg0, arg1)
-}
-
-// DescribeSecurityGroupsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeSecurityGroupsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupsInput, arg2 func(*ec2.DescribeSecurityGroupsOutput, 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, "DescribeSecurityGroupsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeSecurityGroupsPagesWithContext indicates an expected call of DescribeSecurityGroupsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupsPagesWithContext(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, "DescribeSecurityGroupsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupsPagesWithContext), varargs...)
-}
-
-// DescribeSecurityGroupsRequest mocks base method.
-func (m *MockEC2API) DescribeSecurityGroupsRequest(arg0 *ec2.DescribeSecurityGroupsInput) (*request.Request, *ec2.DescribeSecurityGroupsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSecurityGroupsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeSecurityGroupsOutput)
-	return ret0, ret1
-}
-
-// DescribeSecurityGroupsRequest indicates an expected call of DescribeSecurityGroupsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupsRequest), arg0)
-}
-
-// DescribeSecurityGroupsWithContext mocks base method.
-func (m *MockEC2API) DescribeSecurityGroupsWithContext(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupsInput, arg2 ...request.Option) (*ec2.DescribeSecurityGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeSecurityGroupsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeSecurityGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSecurityGroupsWithContext indicates an expected call of DescribeSecurityGroupsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupsWithContext(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, "DescribeSecurityGroupsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupsWithContext), varargs...)
-}
-
-// DescribeSnapshotAttribute mocks base method.
-func (m *MockEC2API) DescribeSnapshotAttribute(arg0 *ec2.DescribeSnapshotAttributeInput) (*ec2.DescribeSnapshotAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSnapshotAttribute", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeSnapshotAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSnapshotAttribute indicates an expected call of DescribeSnapshotAttribute.
-func (mr *MockEC2APIMockRecorder) DescribeSnapshotAttribute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotAttribute), arg0)
-}
-
-// DescribeSnapshotAttributeRequest mocks base method.
-func (m *MockEC2API) DescribeSnapshotAttributeRequest(arg0 *ec2.DescribeSnapshotAttributeInput) (*request.Request, *ec2.DescribeSnapshotAttributeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSnapshotAttributeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeSnapshotAttributeOutput)
-	return ret0, ret1
-}
-
-// DescribeSnapshotAttributeRequest indicates an expected call of DescribeSnapshotAttributeRequest.
-func (mr *MockEC2APIMockRecorder) DescribeSnapshotAttributeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotAttributeRequest), arg0)
-}
-
-// DescribeSnapshotAttributeWithContext mocks base method.
-func (m *MockEC2API) DescribeSnapshotAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeSnapshotAttributeInput, arg2 ...request.Option) (*ec2.DescribeSnapshotAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeSnapshotAttributeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeSnapshotAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSnapshotAttributeWithContext indicates an expected call of DescribeSnapshotAttributeWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeSnapshotAttributeWithContext(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, "DescribeSnapshotAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotAttributeWithContext), varargs...)
-}
-
-// DescribeSnapshotTierStatus mocks base method.
-func (m *MockEC2API) DescribeSnapshotTierStatus(arg0 *ec2.DescribeSnapshotTierStatusInput) (*ec2.DescribeSnapshotTierStatusOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSnapshotTierStatus", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeSnapshotTierStatusOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSnapshotTierStatus indicates an expected call of DescribeSnapshotTierStatus.
-func (mr *MockEC2APIMockRecorder) DescribeSnapshotTierStatus(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotTierStatus", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotTierStatus), arg0)
-}
-
-// DescribeSnapshotTierStatusPages mocks base method.
-func (m *MockEC2API) DescribeSnapshotTierStatusPages(arg0 *ec2.DescribeSnapshotTierStatusInput, arg1 func(*ec2.DescribeSnapshotTierStatusOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSnapshotTierStatusPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeSnapshotTierStatusPages indicates an expected call of DescribeSnapshotTierStatusPages.
-func (mr *MockEC2APIMockRecorder) DescribeSnapshotTierStatusPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotTierStatusPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotTierStatusPages), arg0, arg1)
-}
-
-// DescribeSnapshotTierStatusPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeSnapshotTierStatusPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSnapshotTierStatusInput, arg2 func(*ec2.DescribeSnapshotTierStatusOutput, 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, "DescribeSnapshotTierStatusPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeSnapshotTierStatusPagesWithContext indicates an expected call of DescribeSnapshotTierStatusPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeSnapshotTierStatusPagesWithContext(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, "DescribeSnapshotTierStatusPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotTierStatusPagesWithContext), varargs...)
-}
-
-// DescribeSnapshotTierStatusRequest mocks base method.
-func (m *MockEC2API) DescribeSnapshotTierStatusRequest(arg0 *ec2.DescribeSnapshotTierStatusInput) (*request.Request, *ec2.DescribeSnapshotTierStatusOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSnapshotTierStatusRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeSnapshotTierStatusOutput)
-	return ret0, ret1
-}
-
-// DescribeSnapshotTierStatusRequest indicates an expected call of DescribeSnapshotTierStatusRequest.
-func (mr *MockEC2APIMockRecorder) DescribeSnapshotTierStatusRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotTierStatusRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotTierStatusRequest), arg0)
-}
-
-// DescribeSnapshotTierStatusWithContext mocks base method.
-func (m *MockEC2API) DescribeSnapshotTierStatusWithContext(arg0 context.Context, arg1 *ec2.DescribeSnapshotTierStatusInput, arg2 ...request.Option) (*ec2.DescribeSnapshotTierStatusOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeSnapshotTierStatusWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeSnapshotTierStatusOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSnapshotTierStatusWithContext indicates an expected call of DescribeSnapshotTierStatusWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeSnapshotTierStatusWithContext(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, "DescribeSnapshotTierStatusWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotTierStatusWithContext), varargs...)
-}
-
-// DescribeSnapshots mocks base method.
-func (m *MockEC2API) DescribeSnapshots(arg0 *ec2.DescribeSnapshotsInput) (*ec2.DescribeSnapshotsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSnapshots", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeSnapshotsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSnapshots indicates an expected call of DescribeSnapshots.
-func (mr *MockEC2APIMockRecorder) DescribeSnapshots(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshots", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshots), arg0)
-}
-
-// DescribeSnapshotsPages mocks base method.
-func (m *MockEC2API) DescribeSnapshotsPages(arg0 *ec2.DescribeSnapshotsInput, arg1 func(*ec2.DescribeSnapshotsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSnapshotsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeSnapshotsPages indicates an expected call of DescribeSnapshotsPages.
-func (mr *MockEC2APIMockRecorder) DescribeSnapshotsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotsPages), arg0, arg1)
-}
-
-// DescribeSnapshotsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeSnapshotsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSnapshotsInput, arg2 func(*ec2.DescribeSnapshotsOutput, 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, "DescribeSnapshotsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeSnapshotsPagesWithContext indicates an expected call of DescribeSnapshotsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeSnapshotsPagesWithContext(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, "DescribeSnapshotsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotsPagesWithContext), varargs...)
-}
-
-// DescribeSnapshotsRequest mocks base method.
-func (m *MockEC2API) DescribeSnapshotsRequest(arg0 *ec2.DescribeSnapshotsInput) (*request.Request, *ec2.DescribeSnapshotsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSnapshotsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeSnapshotsOutput)
-	return ret0, ret1
-}
-
-// DescribeSnapshotsRequest indicates an expected call of DescribeSnapshotsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeSnapshotsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotsRequest), arg0)
-}
-
-// DescribeSnapshotsWithContext mocks base method.
-func (m *MockEC2API) DescribeSnapshotsWithContext(arg0 context.Context, arg1 *ec2.DescribeSnapshotsInput, arg2 ...request.Option) (*ec2.DescribeSnapshotsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeSnapshotsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeSnapshotsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSnapshotsWithContext indicates an expected call of DescribeSnapshotsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeSnapshotsWithContext(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, "DescribeSnapshotsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotsWithContext), varargs...)
-}
-
-// DescribeSpotDatafeedSubscription mocks base method.
-func (m *MockEC2API) DescribeSpotDatafeedSubscription(arg0 *ec2.DescribeSpotDatafeedSubscriptionInput) (*ec2.DescribeSpotDatafeedSubscriptionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSpotDatafeedSubscription", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeSpotDatafeedSubscriptionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSpotDatafeedSubscription indicates an expected call of DescribeSpotDatafeedSubscription.
-func (mr *MockEC2APIMockRecorder) DescribeSpotDatafeedSubscription(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotDatafeedSubscription", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotDatafeedSubscription), arg0)
-}
-
-// DescribeSpotDatafeedSubscriptionRequest mocks base method.
-func (m *MockEC2API) DescribeSpotDatafeedSubscriptionRequest(arg0 *ec2.DescribeSpotDatafeedSubscriptionInput) (*request.Request, *ec2.DescribeSpotDatafeedSubscriptionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSpotDatafeedSubscriptionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeSpotDatafeedSubscriptionOutput)
-	return ret0, ret1
-}
-
-// DescribeSpotDatafeedSubscriptionRequest indicates an expected call of DescribeSpotDatafeedSubscriptionRequest.
-func (mr *MockEC2APIMockRecorder) DescribeSpotDatafeedSubscriptionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotDatafeedSubscriptionRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotDatafeedSubscriptionRequest), arg0)
-}
-
-// DescribeSpotDatafeedSubscriptionWithContext mocks base method.
-func (m *MockEC2API) DescribeSpotDatafeedSubscriptionWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotDatafeedSubscriptionInput, arg2 ...request.Option) (*ec2.DescribeSpotDatafeedSubscriptionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeSpotDatafeedSubscriptionWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeSpotDatafeedSubscriptionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSpotDatafeedSubscriptionWithContext indicates an expected call of DescribeSpotDatafeedSubscriptionWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeSpotDatafeedSubscriptionWithContext(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, "DescribeSpotDatafeedSubscriptionWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotDatafeedSubscriptionWithContext), varargs...)
-}
-
-// DescribeSpotFleetInstances mocks base method.
-func (m *MockEC2API) DescribeSpotFleetInstances(arg0 *ec2.DescribeSpotFleetInstancesInput) (*ec2.DescribeSpotFleetInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSpotFleetInstances", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeSpotFleetInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSpotFleetInstances indicates an expected call of DescribeSpotFleetInstances.
-func (mr *MockEC2APIMockRecorder) DescribeSpotFleetInstances(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetInstances), arg0)
-}
-
-// DescribeSpotFleetInstancesRequest mocks base method.
-func (m *MockEC2API) DescribeSpotFleetInstancesRequest(arg0 *ec2.DescribeSpotFleetInstancesInput) (*request.Request, *ec2.DescribeSpotFleetInstancesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSpotFleetInstancesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeSpotFleetInstancesOutput)
-	return ret0, ret1
-}
-
-// DescribeSpotFleetInstancesRequest indicates an expected call of DescribeSpotFleetInstancesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeSpotFleetInstancesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetInstancesRequest), arg0)
-}
-
-// DescribeSpotFleetInstancesWithContext mocks base method.
-func (m *MockEC2API) DescribeSpotFleetInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotFleetInstancesInput, arg2 ...request.Option) (*ec2.DescribeSpotFleetInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeSpotFleetInstancesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeSpotFleetInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSpotFleetInstancesWithContext indicates an expected call of DescribeSpotFleetInstancesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeSpotFleetInstancesWithContext(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, "DescribeSpotFleetInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetInstancesWithContext), varargs...)
-}
-
-// DescribeSpotFleetRequestHistory mocks base method.
-func (m *MockEC2API) DescribeSpotFleetRequestHistory(arg0 *ec2.DescribeSpotFleetRequestHistoryInput) (*ec2.DescribeSpotFleetRequestHistoryOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSpotFleetRequestHistory", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeSpotFleetRequestHistoryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSpotFleetRequestHistory indicates an expected call of DescribeSpotFleetRequestHistory.
-func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestHistory(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestHistory", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestHistory), arg0)
-}
-
-// DescribeSpotFleetRequestHistoryRequest mocks base method.
-func (m *MockEC2API) DescribeSpotFleetRequestHistoryRequest(arg0 *ec2.DescribeSpotFleetRequestHistoryInput) (*request.Request, *ec2.DescribeSpotFleetRequestHistoryOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSpotFleetRequestHistoryRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeSpotFleetRequestHistoryOutput)
-	return ret0, ret1
-}
-
-// DescribeSpotFleetRequestHistoryRequest indicates an expected call of DescribeSpotFleetRequestHistoryRequest.
-func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestHistoryRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestHistoryRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestHistoryRequest), arg0)
-}
-
-// DescribeSpotFleetRequestHistoryWithContext mocks base method.
-func (m *MockEC2API) DescribeSpotFleetRequestHistoryWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotFleetRequestHistoryInput, arg2 ...request.Option) (*ec2.DescribeSpotFleetRequestHistoryOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeSpotFleetRequestHistoryWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeSpotFleetRequestHistoryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSpotFleetRequestHistoryWithContext indicates an expected call of DescribeSpotFleetRequestHistoryWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestHistoryWithContext(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, "DescribeSpotFleetRequestHistoryWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestHistoryWithContext), varargs...)
-}
-
-// DescribeSpotFleetRequests mocks base method.
-func (m *MockEC2API) DescribeSpotFleetRequests(arg0 *ec2.DescribeSpotFleetRequestsInput) (*ec2.DescribeSpotFleetRequestsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSpotFleetRequests", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeSpotFleetRequestsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSpotFleetRequests indicates an expected call of DescribeSpotFleetRequests.
-func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequests(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequests", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequests), arg0)
-}
-
-// DescribeSpotFleetRequestsPages mocks base method.
-func (m *MockEC2API) DescribeSpotFleetRequestsPages(arg0 *ec2.DescribeSpotFleetRequestsInput, arg1 func(*ec2.DescribeSpotFleetRequestsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSpotFleetRequestsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeSpotFleetRequestsPages indicates an expected call of DescribeSpotFleetRequestsPages.
-func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestsPages), arg0, arg1)
-}
-
-// DescribeSpotFleetRequestsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeSpotFleetRequestsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotFleetRequestsInput, arg2 func(*ec2.DescribeSpotFleetRequestsOutput, 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, "DescribeSpotFleetRequestsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeSpotFleetRequestsPagesWithContext indicates an expected call of DescribeSpotFleetRequestsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestsPagesWithContext(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, "DescribeSpotFleetRequestsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestsPagesWithContext), varargs...)
-}
-
-// DescribeSpotFleetRequestsRequest mocks base method.
-func (m *MockEC2API) DescribeSpotFleetRequestsRequest(arg0 *ec2.DescribeSpotFleetRequestsInput) (*request.Request, *ec2.DescribeSpotFleetRequestsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSpotFleetRequestsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeSpotFleetRequestsOutput)
-	return ret0, ret1
-}
-
-// DescribeSpotFleetRequestsRequest indicates an expected call of DescribeSpotFleetRequestsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestsRequest), arg0)
-}
-
-// DescribeSpotFleetRequestsWithContext mocks base method.
-func (m *MockEC2API) DescribeSpotFleetRequestsWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotFleetRequestsInput, arg2 ...request.Option) (*ec2.DescribeSpotFleetRequestsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeSpotFleetRequestsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeSpotFleetRequestsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSpotFleetRequestsWithContext indicates an expected call of DescribeSpotFleetRequestsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestsWithContext(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, "DescribeSpotFleetRequestsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestsWithContext), varargs...)
-}
-
-// DescribeSpotInstanceRequests mocks base method.
-func (m *MockEC2API) DescribeSpotInstanceRequests(arg0 *ec2.DescribeSpotInstanceRequestsInput) (*ec2.DescribeSpotInstanceRequestsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSpotInstanceRequests", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeSpotInstanceRequestsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSpotInstanceRequests indicates an expected call of DescribeSpotInstanceRequests.
-func (mr *MockEC2APIMockRecorder) DescribeSpotInstanceRequests(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotInstanceRequests", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotInstanceRequests), arg0)
-}
-
-// DescribeSpotInstanceRequestsPages mocks base method.
-func (m *MockEC2API) DescribeSpotInstanceRequestsPages(arg0 *ec2.DescribeSpotInstanceRequestsInput, arg1 func(*ec2.DescribeSpotInstanceRequestsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSpotInstanceRequestsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeSpotInstanceRequestsPages indicates an expected call of DescribeSpotInstanceRequestsPages.
-func (mr *MockEC2APIMockRecorder) DescribeSpotInstanceRequestsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotInstanceRequestsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotInstanceRequestsPages), arg0, arg1)
-}
-
-// DescribeSpotInstanceRequestsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeSpotInstanceRequestsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotInstanceRequestsInput, arg2 func(*ec2.DescribeSpotInstanceRequestsOutput, 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, "DescribeSpotInstanceRequestsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeSpotInstanceRequestsPagesWithContext indicates an expected call of DescribeSpotInstanceRequestsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeSpotInstanceRequestsPagesWithContext(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, "DescribeSpotInstanceRequestsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotInstanceRequestsPagesWithContext), varargs...)
-}
-
-// DescribeSpotInstanceRequestsRequest mocks base method.
-func (m *MockEC2API) DescribeSpotInstanceRequestsRequest(arg0 *ec2.DescribeSpotInstanceRequestsInput) (*request.Request, *ec2.DescribeSpotInstanceRequestsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSpotInstanceRequestsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeSpotInstanceRequestsOutput)
-	return ret0, ret1
-}
-
-// DescribeSpotInstanceRequestsRequest indicates an expected call of DescribeSpotInstanceRequestsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeSpotInstanceRequestsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotInstanceRequestsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotInstanceRequestsRequest), arg0)
-}
-
-// DescribeSpotInstanceRequestsWithContext mocks base method.
-func (m *MockEC2API) DescribeSpotInstanceRequestsWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotInstanceRequestsInput, arg2 ...request.Option) (*ec2.DescribeSpotInstanceRequestsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeSpotInstanceRequestsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeSpotInstanceRequestsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSpotInstanceRequestsWithContext indicates an expected call of DescribeSpotInstanceRequestsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeSpotInstanceRequestsWithContext(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, "DescribeSpotInstanceRequestsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotInstanceRequestsWithContext), varargs...)
-}
-
-// DescribeSpotPriceHistory mocks base method.
-func (m *MockEC2API) DescribeSpotPriceHistory(arg0 *ec2.DescribeSpotPriceHistoryInput) (*ec2.DescribeSpotPriceHistoryOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSpotPriceHistory", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeSpotPriceHistoryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSpotPriceHistory indicates an expected call of DescribeSpotPriceHistory.
-func (mr *MockEC2APIMockRecorder) DescribeSpotPriceHistory(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotPriceHistory", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotPriceHistory), arg0)
-}
-
-// DescribeSpotPriceHistoryPages mocks base method.
-func (m *MockEC2API) DescribeSpotPriceHistoryPages(arg0 *ec2.DescribeSpotPriceHistoryInput, arg1 func(*ec2.DescribeSpotPriceHistoryOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSpotPriceHistoryPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeSpotPriceHistoryPages indicates an expected call of DescribeSpotPriceHistoryPages.
-func (mr *MockEC2APIMockRecorder) DescribeSpotPriceHistoryPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotPriceHistoryPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotPriceHistoryPages), arg0, arg1)
-}
-
-// DescribeSpotPriceHistoryPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeSpotPriceHistoryPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotPriceHistoryInput, arg2 func(*ec2.DescribeSpotPriceHistoryOutput, 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, "DescribeSpotPriceHistoryPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeSpotPriceHistoryPagesWithContext indicates an expected call of DescribeSpotPriceHistoryPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeSpotPriceHistoryPagesWithContext(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, "DescribeSpotPriceHistoryPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotPriceHistoryPagesWithContext), varargs...)
-}
-
-// DescribeSpotPriceHistoryRequest mocks base method.
-func (m *MockEC2API) DescribeSpotPriceHistoryRequest(arg0 *ec2.DescribeSpotPriceHistoryInput) (*request.Request, *ec2.DescribeSpotPriceHistoryOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSpotPriceHistoryRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeSpotPriceHistoryOutput)
-	return ret0, ret1
-}
-
-// DescribeSpotPriceHistoryRequest indicates an expected call of DescribeSpotPriceHistoryRequest.
-func (mr *MockEC2APIMockRecorder) DescribeSpotPriceHistoryRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotPriceHistoryRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotPriceHistoryRequest), arg0)
-}
-
-// DescribeSpotPriceHistoryWithContext mocks base method.
-func (m *MockEC2API) DescribeSpotPriceHistoryWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotPriceHistoryInput, arg2 ...request.Option) (*ec2.DescribeSpotPriceHistoryOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeSpotPriceHistoryWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeSpotPriceHistoryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSpotPriceHistoryWithContext indicates an expected call of DescribeSpotPriceHistoryWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeSpotPriceHistoryWithContext(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, "DescribeSpotPriceHistoryWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotPriceHistoryWithContext), varargs...)
-}
-
-// DescribeStaleSecurityGroups mocks base method.
-func (m *MockEC2API) DescribeStaleSecurityGroups(arg0 *ec2.DescribeStaleSecurityGroupsInput) (*ec2.DescribeStaleSecurityGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeStaleSecurityGroups", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeStaleSecurityGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeStaleSecurityGroups indicates an expected call of DescribeStaleSecurityGroups.
-func (mr *MockEC2APIMockRecorder) DescribeStaleSecurityGroups(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStaleSecurityGroups", reflect.TypeOf((*MockEC2API)(nil).DescribeStaleSecurityGroups), arg0)
-}
-
-// DescribeStaleSecurityGroupsPages mocks base method.
-func (m *MockEC2API) DescribeStaleSecurityGroupsPages(arg0 *ec2.DescribeStaleSecurityGroupsInput, arg1 func(*ec2.DescribeStaleSecurityGroupsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeStaleSecurityGroupsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeStaleSecurityGroupsPages indicates an expected call of DescribeStaleSecurityGroupsPages.
-func (mr *MockEC2APIMockRecorder) DescribeStaleSecurityGroupsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStaleSecurityGroupsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeStaleSecurityGroupsPages), arg0, arg1)
-}
-
-// DescribeStaleSecurityGroupsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeStaleSecurityGroupsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeStaleSecurityGroupsInput, arg2 func(*ec2.DescribeStaleSecurityGroupsOutput, 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, "DescribeStaleSecurityGroupsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeStaleSecurityGroupsPagesWithContext indicates an expected call of DescribeStaleSecurityGroupsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeStaleSecurityGroupsPagesWithContext(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, "DescribeStaleSecurityGroupsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeStaleSecurityGroupsPagesWithContext), varargs...)
-}
-
-// DescribeStaleSecurityGroupsRequest mocks base method.
-func (m *MockEC2API) DescribeStaleSecurityGroupsRequest(arg0 *ec2.DescribeStaleSecurityGroupsInput) (*request.Request, *ec2.DescribeStaleSecurityGroupsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeStaleSecurityGroupsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeStaleSecurityGroupsOutput)
-	return ret0, ret1
-}
-
-// DescribeStaleSecurityGroupsRequest indicates an expected call of DescribeStaleSecurityGroupsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeStaleSecurityGroupsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStaleSecurityGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeStaleSecurityGroupsRequest), arg0)
-}
-
-// DescribeStaleSecurityGroupsWithContext mocks base method.
-func (m *MockEC2API) DescribeStaleSecurityGroupsWithContext(arg0 context.Context, arg1 *ec2.DescribeStaleSecurityGroupsInput, arg2 ...request.Option) (*ec2.DescribeStaleSecurityGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeStaleSecurityGroupsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeStaleSecurityGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeStaleSecurityGroupsWithContext indicates an expected call of DescribeStaleSecurityGroupsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeStaleSecurityGroupsWithContext(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, "DescribeStaleSecurityGroupsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeStaleSecurityGroupsWithContext), varargs...)
-}
-
-// DescribeStoreImageTasks mocks base method.
-func (m *MockEC2API) DescribeStoreImageTasks(arg0 *ec2.DescribeStoreImageTasksInput) (*ec2.DescribeStoreImageTasksOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeStoreImageTasks", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeStoreImageTasksOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeStoreImageTasks indicates an expected call of DescribeStoreImageTasks.
-func (mr *MockEC2APIMockRecorder) DescribeStoreImageTasks(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStoreImageTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeStoreImageTasks), arg0)
-}
-
-// DescribeStoreImageTasksPages mocks base method.
-func (m *MockEC2API) DescribeStoreImageTasksPages(arg0 *ec2.DescribeStoreImageTasksInput, arg1 func(*ec2.DescribeStoreImageTasksOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeStoreImageTasksPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeStoreImageTasksPages indicates an expected call of DescribeStoreImageTasksPages.
-func (mr *MockEC2APIMockRecorder) DescribeStoreImageTasksPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStoreImageTasksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeStoreImageTasksPages), arg0, arg1)
-}
-
-// DescribeStoreImageTasksPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeStoreImageTasksPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeStoreImageTasksInput, arg2 func(*ec2.DescribeStoreImageTasksOutput, 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, "DescribeStoreImageTasksPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeStoreImageTasksPagesWithContext indicates an expected call of DescribeStoreImageTasksPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeStoreImageTasksPagesWithContext(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, "DescribeStoreImageTasksPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeStoreImageTasksPagesWithContext), varargs...)
-}
-
-// DescribeStoreImageTasksRequest mocks base method.
-func (m *MockEC2API) DescribeStoreImageTasksRequest(arg0 *ec2.DescribeStoreImageTasksInput) (*request.Request, *ec2.DescribeStoreImageTasksOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeStoreImageTasksRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeStoreImageTasksOutput)
-	return ret0, ret1
-}
-
-// DescribeStoreImageTasksRequest indicates an expected call of DescribeStoreImageTasksRequest.
-func (mr *MockEC2APIMockRecorder) DescribeStoreImageTasksRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStoreImageTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeStoreImageTasksRequest), arg0)
-}
-
-// DescribeStoreImageTasksWithContext mocks base method.
-func (m *MockEC2API) DescribeStoreImageTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeStoreImageTasksInput, arg2 ...request.Option) (*ec2.DescribeStoreImageTasksOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeStoreImageTasksWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeStoreImageTasksOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeStoreImageTasksWithContext indicates an expected call of DescribeStoreImageTasksWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeStoreImageTasksWithContext(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, "DescribeStoreImageTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeStoreImageTasksWithContext), varargs...)
-}
-
-// DescribeSubnets mocks base method.
-func (m *MockEC2API) DescribeSubnets(arg0 *ec2.DescribeSubnetsInput) (*ec2.DescribeSubnetsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSubnets", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeSubnetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSubnets indicates an expected call of DescribeSubnets.
-func (mr *MockEC2APIMockRecorder) DescribeSubnets(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnets", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnets), arg0)
-}
-
-// DescribeSubnetsPages mocks base method.
-func (m *MockEC2API) DescribeSubnetsPages(arg0 *ec2.DescribeSubnetsInput, arg1 func(*ec2.DescribeSubnetsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSubnetsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeSubnetsPages indicates an expected call of DescribeSubnetsPages.
-func (mr *MockEC2APIMockRecorder) DescribeSubnetsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsPages), arg0, arg1)
-}
-
-// DescribeSubnetsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeSubnetsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSubnetsInput, arg2 func(*ec2.DescribeSubnetsOutput, 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, "DescribeSubnetsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeSubnetsPagesWithContext indicates an expected call of DescribeSubnetsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeSubnetsPagesWithContext(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, "DescribeSubnetsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsPagesWithContext), varargs...)
-}
-
-// DescribeSubnetsRequest mocks base method.
-func (m *MockEC2API) DescribeSubnetsRequest(arg0 *ec2.DescribeSubnetsInput) (*request.Request, *ec2.DescribeSubnetsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeSubnetsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeSubnetsOutput)
-	return ret0, ret1
-}
-
-// DescribeSubnetsRequest indicates an expected call of DescribeSubnetsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeSubnetsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsRequest), arg0)
-}
-
-// DescribeSubnetsWithContext mocks base method.
-func (m *MockEC2API) DescribeSubnetsWithContext(arg0 context.Context, arg1 *ec2.DescribeSubnetsInput, arg2 ...request.Option) (*ec2.DescribeSubnetsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeSubnetsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeSubnetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeSubnetsWithContext indicates an expected call of DescribeSubnetsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeSubnetsWithContext(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, "DescribeSubnetsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsWithContext), varargs...)
-}
-
-// DescribeTags mocks base method.
-func (m *MockEC2API) DescribeTags(arg0 *ec2.DescribeTagsInput) (*ec2.DescribeTagsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTags", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeTagsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTags indicates an expected call of DescribeTags.
-func (mr *MockEC2APIMockRecorder) DescribeTags(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTags", reflect.TypeOf((*MockEC2API)(nil).DescribeTags), arg0)
-}
-
-// DescribeTagsPages mocks base method.
-func (m *MockEC2API) DescribeTagsPages(arg0 *ec2.DescribeTagsInput, arg1 func(*ec2.DescribeTagsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTagsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTagsPages indicates an expected call of DescribeTagsPages.
-func (mr *MockEC2APIMockRecorder) DescribeTagsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTagsPages), arg0, arg1)
-}
-
-// DescribeTagsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeTagsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTagsInput, arg2 func(*ec2.DescribeTagsOutput, bool) bool, arg3 ...request.Option) error {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1, arg2}
-	for _, a := range arg3 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTagsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTagsPagesWithContext indicates an expected call of DescribeTagsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTagsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTagsPagesWithContext), varargs...)
-}
-
-// DescribeTagsRequest mocks base method.
-func (m *MockEC2API) DescribeTagsRequest(arg0 *ec2.DescribeTagsInput) (*request.Request, *ec2.DescribeTagsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTagsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeTagsOutput)
-	return ret0, ret1
-}
-
-// DescribeTagsRequest indicates an expected call of DescribeTagsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeTagsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTagsRequest), arg0)
-}
-
-// DescribeTagsWithContext mocks base method.
-func (m *MockEC2API) DescribeTagsWithContext(arg0 context.Context, arg1 *ec2.DescribeTagsInput, arg2 ...request.Option) (*ec2.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].(*ec2.DescribeTagsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTagsWithContext indicates an expected call of DescribeTagsWithContext.
-func (mr *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeTagsWithContext), varargs...)
-}
-
-// DescribeTrafficMirrorFilterRules mocks base method.
-func (m *MockEC2API) DescribeTrafficMirrorFilterRules(arg0 *ec2.DescribeTrafficMirrorFilterRulesInput) (*ec2.DescribeTrafficMirrorFilterRulesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrafficMirrorFilterRules", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorFilterRulesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTrafficMirrorFilterRules indicates an expected call of DescribeTrafficMirrorFilterRules.
-func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorFilterRules(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFilterRules", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFilterRules), arg0)
-}
-
-// DescribeTrafficMirrorFilterRulesRequest mocks base method.
-func (m *MockEC2API) DescribeTrafficMirrorFilterRulesRequest(arg0 *ec2.DescribeTrafficMirrorFilterRulesInput) (*request.Request, *ec2.DescribeTrafficMirrorFilterRulesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrafficMirrorFilterRulesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeTrafficMirrorFilterRulesOutput)
-	return ret0, ret1
-}
-
-// DescribeTrafficMirrorFilterRulesRequest indicates an expected call of DescribeTrafficMirrorFilterRulesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorFilterRulesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFilterRulesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFilterRulesRequest), arg0)
-}
-
-// DescribeTrafficMirrorFilterRulesWithContext mocks base method.
-func (m *MockEC2API) DescribeTrafficMirrorFilterRulesWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorFilterRulesInput, arg2 ...request.Option) (*ec2.DescribeTrafficMirrorFilterRulesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTrafficMirrorFilterRulesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorFilterRulesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTrafficMirrorFilterRulesWithContext indicates an expected call of DescribeTrafficMirrorFilterRulesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorFilterRulesWithContext(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, "DescribeTrafficMirrorFilterRulesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFilterRulesWithContext), varargs...)
-}
-
-// DescribeTrafficMirrorFilters mocks base method.
-func (m *MockEC2API) DescribeTrafficMirrorFilters(arg0 *ec2.DescribeTrafficMirrorFiltersInput) (*ec2.DescribeTrafficMirrorFiltersOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrafficMirrorFilters", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorFiltersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTrafficMirrorFilters indicates an expected call of DescribeTrafficMirrorFilters.
-func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorFilters(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFilters", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFilters), arg0)
-}
-
-// DescribeTrafficMirrorFiltersPages mocks base method.
-func (m *MockEC2API) DescribeTrafficMirrorFiltersPages(arg0 *ec2.DescribeTrafficMirrorFiltersInput, arg1 func(*ec2.DescribeTrafficMirrorFiltersOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrafficMirrorFiltersPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTrafficMirrorFiltersPages indicates an expected call of DescribeTrafficMirrorFiltersPages.
-func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorFiltersPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFiltersPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFiltersPages), arg0, arg1)
-}
-
-// DescribeTrafficMirrorFiltersPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeTrafficMirrorFiltersPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorFiltersInput, arg2 func(*ec2.DescribeTrafficMirrorFiltersOutput, 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, "DescribeTrafficMirrorFiltersPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTrafficMirrorFiltersPagesWithContext indicates an expected call of DescribeTrafficMirrorFiltersPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorFiltersPagesWithContext(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, "DescribeTrafficMirrorFiltersPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFiltersPagesWithContext), varargs...)
-}
-
-// DescribeTrafficMirrorFiltersRequest mocks base method.
-func (m *MockEC2API) DescribeTrafficMirrorFiltersRequest(arg0 *ec2.DescribeTrafficMirrorFiltersInput) (*request.Request, *ec2.DescribeTrafficMirrorFiltersOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrafficMirrorFiltersRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeTrafficMirrorFiltersOutput)
-	return ret0, ret1
-}
-
-// DescribeTrafficMirrorFiltersRequest indicates an expected call of DescribeTrafficMirrorFiltersRequest.
-func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorFiltersRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFiltersRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFiltersRequest), arg0)
-}
-
-// DescribeTrafficMirrorFiltersWithContext mocks base method.
-func (m *MockEC2API) DescribeTrafficMirrorFiltersWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorFiltersInput, arg2 ...request.Option) (*ec2.DescribeTrafficMirrorFiltersOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTrafficMirrorFiltersWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorFiltersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTrafficMirrorFiltersWithContext indicates an expected call of DescribeTrafficMirrorFiltersWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorFiltersWithContext(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, "DescribeTrafficMirrorFiltersWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFiltersWithContext), varargs...)
-}
-
-// DescribeTrafficMirrorSessions mocks base method.
-func (m *MockEC2API) DescribeTrafficMirrorSessions(arg0 *ec2.DescribeTrafficMirrorSessionsInput) (*ec2.DescribeTrafficMirrorSessionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrafficMirrorSessions", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorSessionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTrafficMirrorSessions indicates an expected call of DescribeTrafficMirrorSessions.
-func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorSessions(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorSessions", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorSessions), arg0)
-}
-
-// DescribeTrafficMirrorSessionsPages mocks base method.
-func (m *MockEC2API) DescribeTrafficMirrorSessionsPages(arg0 *ec2.DescribeTrafficMirrorSessionsInput, arg1 func(*ec2.DescribeTrafficMirrorSessionsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrafficMirrorSessionsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTrafficMirrorSessionsPages indicates an expected call of DescribeTrafficMirrorSessionsPages.
-func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorSessionsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorSessionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorSessionsPages), arg0, arg1)
-}
-
-// DescribeTrafficMirrorSessionsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeTrafficMirrorSessionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorSessionsInput, arg2 func(*ec2.DescribeTrafficMirrorSessionsOutput, 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, "DescribeTrafficMirrorSessionsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTrafficMirrorSessionsPagesWithContext indicates an expected call of DescribeTrafficMirrorSessionsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorSessionsPagesWithContext(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, "DescribeTrafficMirrorSessionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorSessionsPagesWithContext), varargs...)
-}
-
-// DescribeTrafficMirrorSessionsRequest mocks base method.
-func (m *MockEC2API) DescribeTrafficMirrorSessionsRequest(arg0 *ec2.DescribeTrafficMirrorSessionsInput) (*request.Request, *ec2.DescribeTrafficMirrorSessionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrafficMirrorSessionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeTrafficMirrorSessionsOutput)
-	return ret0, ret1
-}
-
-// DescribeTrafficMirrorSessionsRequest indicates an expected call of DescribeTrafficMirrorSessionsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorSessionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorSessionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorSessionsRequest), arg0)
-}
-
-// DescribeTrafficMirrorSessionsWithContext mocks base method.
-func (m *MockEC2API) DescribeTrafficMirrorSessionsWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorSessionsInput, arg2 ...request.Option) (*ec2.DescribeTrafficMirrorSessionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTrafficMirrorSessionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorSessionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTrafficMirrorSessionsWithContext indicates an expected call of DescribeTrafficMirrorSessionsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorSessionsWithContext(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, "DescribeTrafficMirrorSessionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorSessionsWithContext), varargs...)
-}
-
-// DescribeTrafficMirrorTargets mocks base method.
-func (m *MockEC2API) DescribeTrafficMirrorTargets(arg0 *ec2.DescribeTrafficMirrorTargetsInput) (*ec2.DescribeTrafficMirrorTargetsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargets", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorTargetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTrafficMirrorTargets indicates an expected call of DescribeTrafficMirrorTargets.
-func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorTargets(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargets", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargets), arg0)
-}
-
-// DescribeTrafficMirrorTargetsPages mocks base method.
-func (m *MockEC2API) DescribeTrafficMirrorTargetsPages(arg0 *ec2.DescribeTrafficMirrorTargetsInput, arg1 func(*ec2.DescribeTrafficMirrorTargetsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargetsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTrafficMirrorTargetsPages indicates an expected call of DescribeTrafficMirrorTargetsPages.
-func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorTargetsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargetsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargetsPages), arg0, arg1)
-}
-
-// DescribeTrafficMirrorTargetsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeTrafficMirrorTargetsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorTargetsInput, arg2 func(*ec2.DescribeTrafficMirrorTargetsOutput, 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, "DescribeTrafficMirrorTargetsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTrafficMirrorTargetsPagesWithContext indicates an expected call of DescribeTrafficMirrorTargetsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorTargetsPagesWithContext(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, "DescribeTrafficMirrorTargetsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargetsPagesWithContext), varargs...)
-}
-
-// DescribeTrafficMirrorTargetsRequest mocks base method.
-func (m *MockEC2API) DescribeTrafficMirrorTargetsRequest(arg0 *ec2.DescribeTrafficMirrorTargetsInput) (*request.Request, *ec2.DescribeTrafficMirrorTargetsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargetsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeTrafficMirrorTargetsOutput)
-	return ret0, ret1
-}
-
-// DescribeTrafficMirrorTargetsRequest indicates an expected call of DescribeTrafficMirrorTargetsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorTargetsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargetsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargetsRequest), arg0)
-}
-
-// DescribeTrafficMirrorTargetsWithContext mocks base method.
-func (m *MockEC2API) DescribeTrafficMirrorTargetsWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorTargetsInput, arg2 ...request.Option) (*ec2.DescribeTrafficMirrorTargetsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargetsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorTargetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTrafficMirrorTargetsWithContext indicates an expected call of DescribeTrafficMirrorTargetsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorTargetsWithContext(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, "DescribeTrafficMirrorTargetsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargetsWithContext), varargs...)
-}
-
-// DescribeTransitGatewayAttachments mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayAttachments(arg0 *ec2.DescribeTransitGatewayAttachmentsInput) (*ec2.DescribeTransitGatewayAttachmentsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayAttachments", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayAttachmentsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayAttachments indicates an expected call of DescribeTransitGatewayAttachments.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayAttachments(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayAttachments", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayAttachments), arg0)
-}
-
-// DescribeTransitGatewayAttachmentsPages mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayAttachmentsPages(arg0 *ec2.DescribeTransitGatewayAttachmentsInput, arg1 func(*ec2.DescribeTransitGatewayAttachmentsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayAttachmentsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTransitGatewayAttachmentsPages indicates an expected call of DescribeTransitGatewayAttachmentsPages.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayAttachmentsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayAttachmentsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayAttachmentsPages), arg0, arg1)
-}
-
-// DescribeTransitGatewayAttachmentsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayAttachmentsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayAttachmentsInput, arg2 func(*ec2.DescribeTransitGatewayAttachmentsOutput, 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, "DescribeTransitGatewayAttachmentsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTransitGatewayAttachmentsPagesWithContext indicates an expected call of DescribeTransitGatewayAttachmentsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayAttachmentsPagesWithContext(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, "DescribeTransitGatewayAttachmentsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayAttachmentsPagesWithContext), varargs...)
-}
-
-// DescribeTransitGatewayAttachmentsRequest mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayAttachmentsRequest(arg0 *ec2.DescribeTransitGatewayAttachmentsInput) (*request.Request, *ec2.DescribeTransitGatewayAttachmentsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayAttachmentsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeTransitGatewayAttachmentsOutput)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayAttachmentsRequest indicates an expected call of DescribeTransitGatewayAttachmentsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayAttachmentsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayAttachmentsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayAttachmentsRequest), arg0)
-}
-
-// DescribeTransitGatewayAttachmentsWithContext mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayAttachmentsWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayAttachmentsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayAttachmentsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayAttachmentsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayAttachmentsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayAttachmentsWithContext indicates an expected call of DescribeTransitGatewayAttachmentsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayAttachmentsWithContext(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, "DescribeTransitGatewayAttachmentsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayAttachmentsWithContext), varargs...)
-}
-
-// DescribeTransitGatewayConnectPeers mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayConnectPeers(arg0 *ec2.DescribeTransitGatewayConnectPeersInput) (*ec2.DescribeTransitGatewayConnectPeersOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayConnectPeers", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayConnectPeersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayConnectPeers indicates an expected call of DescribeTransitGatewayConnectPeers.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnectPeers(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnectPeers", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnectPeers), arg0)
-}
-
-// DescribeTransitGatewayConnectPeersPages mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayConnectPeersPages(arg0 *ec2.DescribeTransitGatewayConnectPeersInput, arg1 func(*ec2.DescribeTransitGatewayConnectPeersOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayConnectPeersPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTransitGatewayConnectPeersPages indicates an expected call of DescribeTransitGatewayConnectPeersPages.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnectPeersPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnectPeersPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnectPeersPages), arg0, arg1)
-}
-
-// DescribeTransitGatewayConnectPeersPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayConnectPeersPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayConnectPeersInput, arg2 func(*ec2.DescribeTransitGatewayConnectPeersOutput, 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, "DescribeTransitGatewayConnectPeersPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTransitGatewayConnectPeersPagesWithContext indicates an expected call of DescribeTransitGatewayConnectPeersPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnectPeersPagesWithContext(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, "DescribeTransitGatewayConnectPeersPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnectPeersPagesWithContext), varargs...)
-}
-
-// DescribeTransitGatewayConnectPeersRequest mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayConnectPeersRequest(arg0 *ec2.DescribeTransitGatewayConnectPeersInput) (*request.Request, *ec2.DescribeTransitGatewayConnectPeersOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayConnectPeersRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeTransitGatewayConnectPeersOutput)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayConnectPeersRequest indicates an expected call of DescribeTransitGatewayConnectPeersRequest.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnectPeersRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnectPeersRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnectPeersRequest), arg0)
-}
-
-// DescribeTransitGatewayConnectPeersWithContext mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayConnectPeersWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayConnectPeersInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayConnectPeersOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayConnectPeersWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayConnectPeersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayConnectPeersWithContext indicates an expected call of DescribeTransitGatewayConnectPeersWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnectPeersWithContext(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, "DescribeTransitGatewayConnectPeersWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnectPeersWithContext), varargs...)
-}
-
-// DescribeTransitGatewayConnects mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayConnects(arg0 *ec2.DescribeTransitGatewayConnectsInput) (*ec2.DescribeTransitGatewayConnectsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayConnects", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayConnectsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayConnects indicates an expected call of DescribeTransitGatewayConnects.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnects(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnects", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnects), arg0)
-}
-
-// DescribeTransitGatewayConnectsPages mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayConnectsPages(arg0 *ec2.DescribeTransitGatewayConnectsInput, arg1 func(*ec2.DescribeTransitGatewayConnectsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayConnectsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTransitGatewayConnectsPages indicates an expected call of DescribeTransitGatewayConnectsPages.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnectsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnectsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnectsPages), arg0, arg1)
-}
-
-// DescribeTransitGatewayConnectsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayConnectsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayConnectsInput, arg2 func(*ec2.DescribeTransitGatewayConnectsOutput, 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, "DescribeTransitGatewayConnectsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTransitGatewayConnectsPagesWithContext indicates an expected call of DescribeTransitGatewayConnectsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnectsPagesWithContext(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, "DescribeTransitGatewayConnectsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnectsPagesWithContext), varargs...)
-}
-
-// DescribeTransitGatewayConnectsRequest mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayConnectsRequest(arg0 *ec2.DescribeTransitGatewayConnectsInput) (*request.Request, *ec2.DescribeTransitGatewayConnectsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayConnectsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeTransitGatewayConnectsOutput)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayConnectsRequest indicates an expected call of DescribeTransitGatewayConnectsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnectsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnectsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnectsRequest), arg0)
-}
-
-// DescribeTransitGatewayConnectsWithContext mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayConnectsWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayConnectsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayConnectsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayConnectsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayConnectsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayConnectsWithContext indicates an expected call of DescribeTransitGatewayConnectsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnectsWithContext(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, "DescribeTransitGatewayConnectsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnectsWithContext), varargs...)
-}
-
-// DescribeTransitGatewayMulticastDomains mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayMulticastDomains(arg0 *ec2.DescribeTransitGatewayMulticastDomainsInput) (*ec2.DescribeTransitGatewayMulticastDomainsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayMulticastDomains", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayMulticastDomainsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayMulticastDomains indicates an expected call of DescribeTransitGatewayMulticastDomains.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayMulticastDomains(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayMulticastDomains", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayMulticastDomains), arg0)
-}
-
-// DescribeTransitGatewayMulticastDomainsPages mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayMulticastDomainsPages(arg0 *ec2.DescribeTransitGatewayMulticastDomainsInput, arg1 func(*ec2.DescribeTransitGatewayMulticastDomainsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayMulticastDomainsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTransitGatewayMulticastDomainsPages indicates an expected call of DescribeTransitGatewayMulticastDomainsPages.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayMulticastDomainsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayMulticastDomainsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayMulticastDomainsPages), arg0, arg1)
-}
-
-// DescribeTransitGatewayMulticastDomainsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayMulticastDomainsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayMulticastDomainsInput, arg2 func(*ec2.DescribeTransitGatewayMulticastDomainsOutput, 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, "DescribeTransitGatewayMulticastDomainsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTransitGatewayMulticastDomainsPagesWithContext indicates an expected call of DescribeTransitGatewayMulticastDomainsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayMulticastDomainsPagesWithContext(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, "DescribeTransitGatewayMulticastDomainsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayMulticastDomainsPagesWithContext), varargs...)
-}
-
-// DescribeTransitGatewayMulticastDomainsRequest mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayMulticastDomainsRequest(arg0 *ec2.DescribeTransitGatewayMulticastDomainsInput) (*request.Request, *ec2.DescribeTransitGatewayMulticastDomainsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayMulticastDomainsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeTransitGatewayMulticastDomainsOutput)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayMulticastDomainsRequest indicates an expected call of DescribeTransitGatewayMulticastDomainsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayMulticastDomainsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayMulticastDomainsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayMulticastDomainsRequest), arg0)
-}
-
-// DescribeTransitGatewayMulticastDomainsWithContext mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayMulticastDomainsWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayMulticastDomainsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayMulticastDomainsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayMulticastDomainsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayMulticastDomainsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayMulticastDomainsWithContext indicates an expected call of DescribeTransitGatewayMulticastDomainsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayMulticastDomainsWithContext(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, "DescribeTransitGatewayMulticastDomainsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayMulticastDomainsWithContext), varargs...)
-}
-
-// DescribeTransitGatewayPeeringAttachments mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayPeeringAttachments(arg0 *ec2.DescribeTransitGatewayPeeringAttachmentsInput) (*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayPeeringAttachments", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayPeeringAttachments indicates an expected call of DescribeTransitGatewayPeeringAttachments.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayPeeringAttachments(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPeeringAttachments", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPeeringAttachments), arg0)
-}
-
-// DescribeTransitGatewayPeeringAttachmentsPages mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayPeeringAttachmentsPages(arg0 *ec2.DescribeTransitGatewayPeeringAttachmentsInput, arg1 func(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayPeeringAttachmentsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTransitGatewayPeeringAttachmentsPages indicates an expected call of DescribeTransitGatewayPeeringAttachmentsPages.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayPeeringAttachmentsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPeeringAttachmentsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPeeringAttachmentsPages), arg0, arg1)
-}
-
-// DescribeTransitGatewayPeeringAttachmentsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayPeeringAttachmentsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayPeeringAttachmentsInput, arg2 func(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, 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, "DescribeTransitGatewayPeeringAttachmentsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTransitGatewayPeeringAttachmentsPagesWithContext indicates an expected call of DescribeTransitGatewayPeeringAttachmentsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayPeeringAttachmentsPagesWithContext(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, "DescribeTransitGatewayPeeringAttachmentsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPeeringAttachmentsPagesWithContext), varargs...)
-}
-
-// DescribeTransitGatewayPeeringAttachmentsRequest mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayPeeringAttachmentsRequest(arg0 *ec2.DescribeTransitGatewayPeeringAttachmentsInput) (*request.Request, *ec2.DescribeTransitGatewayPeeringAttachmentsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayPeeringAttachmentsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayPeeringAttachmentsRequest indicates an expected call of DescribeTransitGatewayPeeringAttachmentsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayPeeringAttachmentsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPeeringAttachmentsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPeeringAttachmentsRequest), arg0)
-}
-
-// DescribeTransitGatewayPeeringAttachmentsWithContext mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayPeeringAttachmentsWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayPeeringAttachmentsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayPeeringAttachmentsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayPeeringAttachmentsWithContext indicates an expected call of DescribeTransitGatewayPeeringAttachmentsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayPeeringAttachmentsWithContext(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, "DescribeTransitGatewayPeeringAttachmentsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPeeringAttachmentsWithContext), varargs...)
-}
-
-// DescribeTransitGatewayPolicyTables mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayPolicyTables(arg0 *ec2.DescribeTransitGatewayPolicyTablesInput) (*ec2.DescribeTransitGatewayPolicyTablesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayPolicyTables", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayPolicyTablesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayPolicyTables indicates an expected call of DescribeTransitGatewayPolicyTables.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayPolicyTables(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPolicyTables", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPolicyTables), arg0)
-}
-
-// DescribeTransitGatewayPolicyTablesPages mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayPolicyTablesPages(arg0 *ec2.DescribeTransitGatewayPolicyTablesInput, arg1 func(*ec2.DescribeTransitGatewayPolicyTablesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayPolicyTablesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTransitGatewayPolicyTablesPages indicates an expected call of DescribeTransitGatewayPolicyTablesPages.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayPolicyTablesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPolicyTablesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPolicyTablesPages), arg0, arg1)
-}
-
-// DescribeTransitGatewayPolicyTablesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayPolicyTablesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayPolicyTablesInput, arg2 func(*ec2.DescribeTransitGatewayPolicyTablesOutput, 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, "DescribeTransitGatewayPolicyTablesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTransitGatewayPolicyTablesPagesWithContext indicates an expected call of DescribeTransitGatewayPolicyTablesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayPolicyTablesPagesWithContext(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, "DescribeTransitGatewayPolicyTablesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPolicyTablesPagesWithContext), varargs...)
-}
-
-// DescribeTransitGatewayPolicyTablesRequest mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayPolicyTablesRequest(arg0 *ec2.DescribeTransitGatewayPolicyTablesInput) (*request.Request, *ec2.DescribeTransitGatewayPolicyTablesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayPolicyTablesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeTransitGatewayPolicyTablesOutput)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayPolicyTablesRequest indicates an expected call of DescribeTransitGatewayPolicyTablesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayPolicyTablesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPolicyTablesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPolicyTablesRequest), arg0)
-}
-
-// DescribeTransitGatewayPolicyTablesWithContext mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayPolicyTablesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayPolicyTablesInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayPolicyTablesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayPolicyTablesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayPolicyTablesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayPolicyTablesWithContext indicates an expected call of DescribeTransitGatewayPolicyTablesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayPolicyTablesWithContext(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, "DescribeTransitGatewayPolicyTablesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPolicyTablesWithContext), varargs...)
-}
-
-// DescribeTransitGatewayRouteTableAnnouncements mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayRouteTableAnnouncements(arg0 *ec2.DescribeTransitGatewayRouteTableAnnouncementsInput) (*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTableAnnouncements", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayRouteTableAnnouncements indicates an expected call of DescribeTransitGatewayRouteTableAnnouncements.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTableAnnouncements(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTableAnnouncements", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTableAnnouncements), arg0)
-}
-
-// DescribeTransitGatewayRouteTableAnnouncementsPages mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayRouteTableAnnouncementsPages(arg0 *ec2.DescribeTransitGatewayRouteTableAnnouncementsInput, arg1 func(*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTableAnnouncementsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTransitGatewayRouteTableAnnouncementsPages indicates an expected call of DescribeTransitGatewayRouteTableAnnouncementsPages.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTableAnnouncementsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTableAnnouncementsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTableAnnouncementsPages), arg0, arg1)
-}
-
-// DescribeTransitGatewayRouteTableAnnouncementsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayRouteTableAnnouncementsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayRouteTableAnnouncementsInput, arg2 func(*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput, 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, "DescribeTransitGatewayRouteTableAnnouncementsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTransitGatewayRouteTableAnnouncementsPagesWithContext indicates an expected call of DescribeTransitGatewayRouteTableAnnouncementsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTableAnnouncementsPagesWithContext(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, "DescribeTransitGatewayRouteTableAnnouncementsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTableAnnouncementsPagesWithContext), varargs...)
-}
-
-// DescribeTransitGatewayRouteTableAnnouncementsRequest mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayRouteTableAnnouncementsRequest(arg0 *ec2.DescribeTransitGatewayRouteTableAnnouncementsInput) (*request.Request, *ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTableAnnouncementsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayRouteTableAnnouncementsRequest indicates an expected call of DescribeTransitGatewayRouteTableAnnouncementsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTableAnnouncementsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTableAnnouncementsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTableAnnouncementsRequest), arg0)
-}
-
-// DescribeTransitGatewayRouteTableAnnouncementsWithContext mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayRouteTableAnnouncementsWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayRouteTableAnnouncementsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTableAnnouncementsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayRouteTableAnnouncementsWithContext indicates an expected call of DescribeTransitGatewayRouteTableAnnouncementsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTableAnnouncementsWithContext(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, "DescribeTransitGatewayRouteTableAnnouncementsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTableAnnouncementsWithContext), varargs...)
-}
-
-// DescribeTransitGatewayRouteTables mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayRouteTables(arg0 *ec2.DescribeTransitGatewayRouteTablesInput) (*ec2.DescribeTransitGatewayRouteTablesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTables", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayRouteTablesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayRouteTables indicates an expected call of DescribeTransitGatewayRouteTables.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTables(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTables", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTables), arg0)
-}
-
-// DescribeTransitGatewayRouteTablesPages mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayRouteTablesPages(arg0 *ec2.DescribeTransitGatewayRouteTablesInput, arg1 func(*ec2.DescribeTransitGatewayRouteTablesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTablesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTransitGatewayRouteTablesPages indicates an expected call of DescribeTransitGatewayRouteTablesPages.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTablesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTablesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTablesPages), arg0, arg1)
-}
-
-// DescribeTransitGatewayRouteTablesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayRouteTablesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayRouteTablesInput, arg2 func(*ec2.DescribeTransitGatewayRouteTablesOutput, 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, "DescribeTransitGatewayRouteTablesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTransitGatewayRouteTablesPagesWithContext indicates an expected call of DescribeTransitGatewayRouteTablesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTablesPagesWithContext(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, "DescribeTransitGatewayRouteTablesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTablesPagesWithContext), varargs...)
-}
-
-// DescribeTransitGatewayRouteTablesRequest mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayRouteTablesRequest(arg0 *ec2.DescribeTransitGatewayRouteTablesInput) (*request.Request, *ec2.DescribeTransitGatewayRouteTablesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTablesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeTransitGatewayRouteTablesOutput)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayRouteTablesRequest indicates an expected call of DescribeTransitGatewayRouteTablesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTablesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTablesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTablesRequest), arg0)
-}
-
-// DescribeTransitGatewayRouteTablesWithContext mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayRouteTablesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayRouteTablesInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayRouteTablesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTablesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayRouteTablesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayRouteTablesWithContext indicates an expected call of DescribeTransitGatewayRouteTablesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTablesWithContext(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, "DescribeTransitGatewayRouteTablesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTablesWithContext), varargs...)
-}
-
-// DescribeTransitGatewayVpcAttachments mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayVpcAttachments(arg0 *ec2.DescribeTransitGatewayVpcAttachmentsInput) (*ec2.DescribeTransitGatewayVpcAttachmentsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayVpcAttachments", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayVpcAttachmentsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayVpcAttachments indicates an expected call of DescribeTransitGatewayVpcAttachments.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayVpcAttachments(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayVpcAttachments", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayVpcAttachments), arg0)
-}
-
-// DescribeTransitGatewayVpcAttachmentsPages mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayVpcAttachmentsPages(arg0 *ec2.DescribeTransitGatewayVpcAttachmentsInput, arg1 func(*ec2.DescribeTransitGatewayVpcAttachmentsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayVpcAttachmentsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTransitGatewayVpcAttachmentsPages indicates an expected call of DescribeTransitGatewayVpcAttachmentsPages.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayVpcAttachmentsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayVpcAttachmentsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayVpcAttachmentsPages), arg0, arg1)
-}
-
-// DescribeTransitGatewayVpcAttachmentsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayVpcAttachmentsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayVpcAttachmentsInput, arg2 func(*ec2.DescribeTransitGatewayVpcAttachmentsOutput, 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, "DescribeTransitGatewayVpcAttachmentsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTransitGatewayVpcAttachmentsPagesWithContext indicates an expected call of DescribeTransitGatewayVpcAttachmentsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayVpcAttachmentsPagesWithContext(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, "DescribeTransitGatewayVpcAttachmentsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayVpcAttachmentsPagesWithContext), varargs...)
-}
-
-// DescribeTransitGatewayVpcAttachmentsRequest mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayVpcAttachmentsRequest(arg0 *ec2.DescribeTransitGatewayVpcAttachmentsInput) (*request.Request, *ec2.DescribeTransitGatewayVpcAttachmentsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayVpcAttachmentsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeTransitGatewayVpcAttachmentsOutput)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayVpcAttachmentsRequest indicates an expected call of DescribeTransitGatewayVpcAttachmentsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayVpcAttachmentsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayVpcAttachmentsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayVpcAttachmentsRequest), arg0)
-}
-
-// DescribeTransitGatewayVpcAttachmentsWithContext mocks base method.
-func (m *MockEC2API) DescribeTransitGatewayVpcAttachmentsWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayVpcAttachmentsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayVpcAttachmentsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTransitGatewayVpcAttachmentsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayVpcAttachmentsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewayVpcAttachmentsWithContext indicates an expected call of DescribeTransitGatewayVpcAttachmentsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayVpcAttachmentsWithContext(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, "DescribeTransitGatewayVpcAttachmentsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayVpcAttachmentsWithContext), varargs...)
-}
-
-// DescribeTransitGateways mocks base method.
-func (m *MockEC2API) DescribeTransitGateways(arg0 *ec2.DescribeTransitGatewaysInput) (*ec2.DescribeTransitGatewaysOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGateways", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeTransitGatewaysOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTransitGateways indicates an expected call of DescribeTransitGateways.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGateways(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGateways), arg0)
-}
-
-// DescribeTransitGatewaysPages mocks base method.
-func (m *MockEC2API) DescribeTransitGatewaysPages(arg0 *ec2.DescribeTransitGatewaysInput, arg1 func(*ec2.DescribeTransitGatewaysOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewaysPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTransitGatewaysPages indicates an expected call of DescribeTransitGatewaysPages.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewaysPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewaysPages), arg0, arg1)
-}
-
-// DescribeTransitGatewaysPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeTransitGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewaysInput, arg2 func(*ec2.DescribeTransitGatewaysOutput, 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, "DescribeTransitGatewaysPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTransitGatewaysPagesWithContext indicates an expected call of DescribeTransitGatewaysPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewaysPagesWithContext(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, "DescribeTransitGatewaysPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewaysPagesWithContext), varargs...)
-}
-
-// DescribeTransitGatewaysRequest mocks base method.
-func (m *MockEC2API) DescribeTransitGatewaysRequest(arg0 *ec2.DescribeTransitGatewaysInput) (*request.Request, *ec2.DescribeTransitGatewaysOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTransitGatewaysRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeTransitGatewaysOutput)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewaysRequest indicates an expected call of DescribeTransitGatewaysRequest.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewaysRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewaysRequest), arg0)
-}
-
-// DescribeTransitGatewaysWithContext mocks base method.
-func (m *MockEC2API) DescribeTransitGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewaysInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewaysOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTransitGatewaysWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeTransitGatewaysOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTransitGatewaysWithContext indicates an expected call of DescribeTransitGatewaysWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTransitGatewaysWithContext(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, "DescribeTransitGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewaysWithContext), varargs...)
-}
-
-// DescribeTrunkInterfaceAssociations mocks base method.
-func (m *MockEC2API) DescribeTrunkInterfaceAssociations(arg0 *ec2.DescribeTrunkInterfaceAssociationsInput) (*ec2.DescribeTrunkInterfaceAssociationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrunkInterfaceAssociations", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeTrunkInterfaceAssociationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTrunkInterfaceAssociations indicates an expected call of DescribeTrunkInterfaceAssociations.
-func (mr *MockEC2APIMockRecorder) DescribeTrunkInterfaceAssociations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrunkInterfaceAssociations", reflect.TypeOf((*MockEC2API)(nil).DescribeTrunkInterfaceAssociations), arg0)
-}
-
-// DescribeTrunkInterfaceAssociationsPages mocks base method.
-func (m *MockEC2API) DescribeTrunkInterfaceAssociationsPages(arg0 *ec2.DescribeTrunkInterfaceAssociationsInput, arg1 func(*ec2.DescribeTrunkInterfaceAssociationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrunkInterfaceAssociationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTrunkInterfaceAssociationsPages indicates an expected call of DescribeTrunkInterfaceAssociationsPages.
-func (mr *MockEC2APIMockRecorder) DescribeTrunkInterfaceAssociationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrunkInterfaceAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTrunkInterfaceAssociationsPages), arg0, arg1)
-}
-
-// DescribeTrunkInterfaceAssociationsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeTrunkInterfaceAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTrunkInterfaceAssociationsInput, arg2 func(*ec2.DescribeTrunkInterfaceAssociationsOutput, 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, "DescribeTrunkInterfaceAssociationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeTrunkInterfaceAssociationsPagesWithContext indicates an expected call of DescribeTrunkInterfaceAssociationsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTrunkInterfaceAssociationsPagesWithContext(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, "DescribeTrunkInterfaceAssociationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrunkInterfaceAssociationsPagesWithContext), varargs...)
-}
-
-// DescribeTrunkInterfaceAssociationsRequest mocks base method.
-func (m *MockEC2API) DescribeTrunkInterfaceAssociationsRequest(arg0 *ec2.DescribeTrunkInterfaceAssociationsInput) (*request.Request, *ec2.DescribeTrunkInterfaceAssociationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeTrunkInterfaceAssociationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeTrunkInterfaceAssociationsOutput)
-	return ret0, ret1
-}
-
-// DescribeTrunkInterfaceAssociationsRequest indicates an expected call of DescribeTrunkInterfaceAssociationsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeTrunkInterfaceAssociationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrunkInterfaceAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTrunkInterfaceAssociationsRequest), arg0)
-}
-
-// DescribeTrunkInterfaceAssociationsWithContext mocks base method.
-func (m *MockEC2API) DescribeTrunkInterfaceAssociationsWithContext(arg0 context.Context, arg1 *ec2.DescribeTrunkInterfaceAssociationsInput, arg2 ...request.Option) (*ec2.DescribeTrunkInterfaceAssociationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeTrunkInterfaceAssociationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeTrunkInterfaceAssociationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeTrunkInterfaceAssociationsWithContext indicates an expected call of DescribeTrunkInterfaceAssociationsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeTrunkInterfaceAssociationsWithContext(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, "DescribeTrunkInterfaceAssociationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrunkInterfaceAssociationsWithContext), varargs...)
-}
-
-// DescribeVerifiedAccessEndpoints mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessEndpoints(arg0 *ec2.DescribeVerifiedAccessEndpointsInput) (*ec2.DescribeVerifiedAccessEndpointsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVerifiedAccessEndpoints", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessEndpointsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVerifiedAccessEndpoints indicates an expected call of DescribeVerifiedAccessEndpoints.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessEndpoints(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessEndpoints", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessEndpoints), arg0)
-}
-
-// DescribeVerifiedAccessEndpointsPages mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessEndpointsPages(arg0 *ec2.DescribeVerifiedAccessEndpointsInput, arg1 func(*ec2.DescribeVerifiedAccessEndpointsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVerifiedAccessEndpointsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVerifiedAccessEndpointsPages indicates an expected call of DescribeVerifiedAccessEndpointsPages.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessEndpointsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessEndpointsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessEndpointsPages), arg0, arg1)
-}
-
-// DescribeVerifiedAccessEndpointsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessEndpointsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessEndpointsInput, arg2 func(*ec2.DescribeVerifiedAccessEndpointsOutput, 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, "DescribeVerifiedAccessEndpointsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVerifiedAccessEndpointsPagesWithContext indicates an expected call of DescribeVerifiedAccessEndpointsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessEndpointsPagesWithContext(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, "DescribeVerifiedAccessEndpointsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessEndpointsPagesWithContext), varargs...)
-}
-
-// DescribeVerifiedAccessEndpointsRequest mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessEndpointsRequest(arg0 *ec2.DescribeVerifiedAccessEndpointsInput) (*request.Request, *ec2.DescribeVerifiedAccessEndpointsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVerifiedAccessEndpointsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeVerifiedAccessEndpointsOutput)
-	return ret0, ret1
-}
-
-// DescribeVerifiedAccessEndpointsRequest indicates an expected call of DescribeVerifiedAccessEndpointsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessEndpointsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessEndpointsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessEndpointsRequest), arg0)
-}
-
-// DescribeVerifiedAccessEndpointsWithContext mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessEndpointsWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessEndpointsInput, arg2 ...request.Option) (*ec2.DescribeVerifiedAccessEndpointsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeVerifiedAccessEndpointsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessEndpointsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVerifiedAccessEndpointsWithContext indicates an expected call of DescribeVerifiedAccessEndpointsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessEndpointsWithContext(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, "DescribeVerifiedAccessEndpointsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessEndpointsWithContext), varargs...)
-}
-
-// DescribeVerifiedAccessGroups mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessGroups(arg0 *ec2.DescribeVerifiedAccessGroupsInput) (*ec2.DescribeVerifiedAccessGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVerifiedAccessGroups", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVerifiedAccessGroups indicates an expected call of DescribeVerifiedAccessGroups.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessGroups(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessGroups", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessGroups), arg0)
-}
-
-// DescribeVerifiedAccessGroupsPages mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessGroupsPages(arg0 *ec2.DescribeVerifiedAccessGroupsInput, arg1 func(*ec2.DescribeVerifiedAccessGroupsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVerifiedAccessGroupsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVerifiedAccessGroupsPages indicates an expected call of DescribeVerifiedAccessGroupsPages.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessGroupsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessGroupsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessGroupsPages), arg0, arg1)
-}
-
-// DescribeVerifiedAccessGroupsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessGroupsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessGroupsInput, arg2 func(*ec2.DescribeVerifiedAccessGroupsOutput, 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, "DescribeVerifiedAccessGroupsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVerifiedAccessGroupsPagesWithContext indicates an expected call of DescribeVerifiedAccessGroupsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessGroupsPagesWithContext(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, "DescribeVerifiedAccessGroupsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessGroupsPagesWithContext), varargs...)
-}
-
-// DescribeVerifiedAccessGroupsRequest mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessGroupsRequest(arg0 *ec2.DescribeVerifiedAccessGroupsInput) (*request.Request, *ec2.DescribeVerifiedAccessGroupsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVerifiedAccessGroupsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeVerifiedAccessGroupsOutput)
-	return ret0, ret1
-}
-
-// DescribeVerifiedAccessGroupsRequest indicates an expected call of DescribeVerifiedAccessGroupsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessGroupsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessGroupsRequest), arg0)
-}
-
-// DescribeVerifiedAccessGroupsWithContext mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessGroupsWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessGroupsInput, arg2 ...request.Option) (*ec2.DescribeVerifiedAccessGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeVerifiedAccessGroupsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVerifiedAccessGroupsWithContext indicates an expected call of DescribeVerifiedAccessGroupsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessGroupsWithContext(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, "DescribeVerifiedAccessGroupsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessGroupsWithContext), varargs...)
-}
-
-// DescribeVerifiedAccessInstanceLoggingConfigurations mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessInstanceLoggingConfigurations(arg0 *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsInput) (*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstanceLoggingConfigurations", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVerifiedAccessInstanceLoggingConfigurations indicates an expected call of DescribeVerifiedAccessInstanceLoggingConfigurations.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessInstanceLoggingConfigurations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessInstanceLoggingConfigurations", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessInstanceLoggingConfigurations), arg0)
-}
-
-// DescribeVerifiedAccessInstanceLoggingConfigurationsPages mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessInstanceLoggingConfigurationsPages(arg0 *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsInput, arg1 func(*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstanceLoggingConfigurationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVerifiedAccessInstanceLoggingConfigurationsPages indicates an expected call of DescribeVerifiedAccessInstanceLoggingConfigurationsPages.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessInstanceLoggingConfigurationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessInstanceLoggingConfigurationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessInstanceLoggingConfigurationsPages), arg0, arg1)
-}
-
-// DescribeVerifiedAccessInstanceLoggingConfigurationsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessInstanceLoggingConfigurationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsInput, arg2 func(*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput, 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, "DescribeVerifiedAccessInstanceLoggingConfigurationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVerifiedAccessInstanceLoggingConfigurationsPagesWithContext indicates an expected call of DescribeVerifiedAccessInstanceLoggingConfigurationsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessInstanceLoggingConfigurationsPagesWithContext(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, "DescribeVerifiedAccessInstanceLoggingConfigurationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessInstanceLoggingConfigurationsPagesWithContext), varargs...)
-}
-
-// DescribeVerifiedAccessInstanceLoggingConfigurationsRequest mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessInstanceLoggingConfigurationsRequest(arg0 *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsInput) (*request.Request, *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstanceLoggingConfigurationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput)
-	return ret0, ret1
-}
-
-// DescribeVerifiedAccessInstanceLoggingConfigurationsRequest indicates an expected call of DescribeVerifiedAccessInstanceLoggingConfigurationsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessInstanceLoggingConfigurationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessInstanceLoggingConfigurationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessInstanceLoggingConfigurationsRequest), arg0)
-}
-
-// DescribeVerifiedAccessInstanceLoggingConfigurationsWithContext mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessInstanceLoggingConfigurationsWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsInput, arg2 ...request.Option) (*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstanceLoggingConfigurationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVerifiedAccessInstanceLoggingConfigurationsWithContext indicates an expected call of DescribeVerifiedAccessInstanceLoggingConfigurationsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessInstanceLoggingConfigurationsWithContext(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, "DescribeVerifiedAccessInstanceLoggingConfigurationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessInstanceLoggingConfigurationsWithContext), varargs...)
-}
-
-// DescribeVerifiedAccessInstances mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessInstances(arg0 *ec2.DescribeVerifiedAccessInstancesInput) (*ec2.DescribeVerifiedAccessInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstances", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVerifiedAccessInstances indicates an expected call of DescribeVerifiedAccessInstances.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessInstances(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessInstances), arg0)
-}
-
-// DescribeVerifiedAccessInstancesPages mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessInstancesPages(arg0 *ec2.DescribeVerifiedAccessInstancesInput, arg1 func(*ec2.DescribeVerifiedAccessInstancesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstancesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVerifiedAccessInstancesPages indicates an expected call of DescribeVerifiedAccessInstancesPages.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessInstancesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessInstancesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessInstancesPages), arg0, arg1)
-}
-
-// DescribeVerifiedAccessInstancesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessInstancesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessInstancesInput, arg2 func(*ec2.DescribeVerifiedAccessInstancesOutput, 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, "DescribeVerifiedAccessInstancesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVerifiedAccessInstancesPagesWithContext indicates an expected call of DescribeVerifiedAccessInstancesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessInstancesPagesWithContext(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, "DescribeVerifiedAccessInstancesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessInstancesPagesWithContext), varargs...)
-}
-
-// DescribeVerifiedAccessInstancesRequest mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessInstancesRequest(arg0 *ec2.DescribeVerifiedAccessInstancesInput) (*request.Request, *ec2.DescribeVerifiedAccessInstancesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstancesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeVerifiedAccessInstancesOutput)
-	return ret0, ret1
-}
-
-// DescribeVerifiedAccessInstancesRequest indicates an expected call of DescribeVerifiedAccessInstancesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessInstancesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessInstancesRequest), arg0)
-}
-
-// DescribeVerifiedAccessInstancesWithContext mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessInstancesInput, arg2 ...request.Option) (*ec2.DescribeVerifiedAccessInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstancesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVerifiedAccessInstancesWithContext indicates an expected call of DescribeVerifiedAccessInstancesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessInstancesWithContext(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, "DescribeVerifiedAccessInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessInstancesWithContext), varargs...)
-}
-
-// DescribeVerifiedAccessTrustProviders mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessTrustProviders(arg0 *ec2.DescribeVerifiedAccessTrustProvidersInput) (*ec2.DescribeVerifiedAccessTrustProvidersOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVerifiedAccessTrustProviders", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessTrustProvidersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVerifiedAccessTrustProviders indicates an expected call of DescribeVerifiedAccessTrustProviders.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessTrustProviders(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessTrustProviders", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessTrustProviders), arg0)
-}
-
-// DescribeVerifiedAccessTrustProvidersPages mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessTrustProvidersPages(arg0 *ec2.DescribeVerifiedAccessTrustProvidersInput, arg1 func(*ec2.DescribeVerifiedAccessTrustProvidersOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVerifiedAccessTrustProvidersPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVerifiedAccessTrustProvidersPages indicates an expected call of DescribeVerifiedAccessTrustProvidersPages.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessTrustProvidersPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessTrustProvidersPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessTrustProvidersPages), arg0, arg1)
-}
-
-// DescribeVerifiedAccessTrustProvidersPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessTrustProvidersPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessTrustProvidersInput, arg2 func(*ec2.DescribeVerifiedAccessTrustProvidersOutput, 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, "DescribeVerifiedAccessTrustProvidersPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVerifiedAccessTrustProvidersPagesWithContext indicates an expected call of DescribeVerifiedAccessTrustProvidersPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessTrustProvidersPagesWithContext(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, "DescribeVerifiedAccessTrustProvidersPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessTrustProvidersPagesWithContext), varargs...)
-}
-
-// DescribeVerifiedAccessTrustProvidersRequest mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessTrustProvidersRequest(arg0 *ec2.DescribeVerifiedAccessTrustProvidersInput) (*request.Request, *ec2.DescribeVerifiedAccessTrustProvidersOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVerifiedAccessTrustProvidersRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeVerifiedAccessTrustProvidersOutput)
-	return ret0, ret1
-}
-
-// DescribeVerifiedAccessTrustProvidersRequest indicates an expected call of DescribeVerifiedAccessTrustProvidersRequest.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessTrustProvidersRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessTrustProvidersRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessTrustProvidersRequest), arg0)
-}
-
-// DescribeVerifiedAccessTrustProvidersWithContext mocks base method.
-func (m *MockEC2API) DescribeVerifiedAccessTrustProvidersWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessTrustProvidersInput, arg2 ...request.Option) (*ec2.DescribeVerifiedAccessTrustProvidersOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeVerifiedAccessTrustProvidersWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessTrustProvidersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVerifiedAccessTrustProvidersWithContext indicates an expected call of DescribeVerifiedAccessTrustProvidersWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessTrustProvidersWithContext(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, "DescribeVerifiedAccessTrustProvidersWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessTrustProvidersWithContext), varargs...)
-}
-
-// DescribeVolumeAttribute mocks base method.
-func (m *MockEC2API) DescribeVolumeAttribute(arg0 *ec2.DescribeVolumeAttributeInput) (*ec2.DescribeVolumeAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVolumeAttribute", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeVolumeAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVolumeAttribute indicates an expected call of DescribeVolumeAttribute.
-func (mr *MockEC2APIMockRecorder) DescribeVolumeAttribute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeAttribute), arg0)
-}
-
-// DescribeVolumeAttributeRequest mocks base method.
-func (m *MockEC2API) DescribeVolumeAttributeRequest(arg0 *ec2.DescribeVolumeAttributeInput) (*request.Request, *ec2.DescribeVolumeAttributeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVolumeAttributeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeVolumeAttributeOutput)
-	return ret0, ret1
-}
-
-// DescribeVolumeAttributeRequest indicates an expected call of DescribeVolumeAttributeRequest.
-func (mr *MockEC2APIMockRecorder) DescribeVolumeAttributeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeAttributeRequest), arg0)
-}
-
-// DescribeVolumeAttributeWithContext mocks base method.
-func (m *MockEC2API) DescribeVolumeAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumeAttributeInput, arg2 ...request.Option) (*ec2.DescribeVolumeAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeVolumeAttributeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeVolumeAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVolumeAttributeWithContext indicates an expected call of DescribeVolumeAttributeWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVolumeAttributeWithContext(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, "DescribeVolumeAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeAttributeWithContext), varargs...)
-}
-
-// DescribeVolumeStatus mocks base method.
-func (m *MockEC2API) DescribeVolumeStatus(arg0 *ec2.DescribeVolumeStatusInput) (*ec2.DescribeVolumeStatusOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVolumeStatus", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeVolumeStatusOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVolumeStatus indicates an expected call of DescribeVolumeStatus.
-func (mr *MockEC2APIMockRecorder) DescribeVolumeStatus(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeStatus", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeStatus), arg0)
-}
-
-// DescribeVolumeStatusPages mocks base method.
-func (m *MockEC2API) DescribeVolumeStatusPages(arg0 *ec2.DescribeVolumeStatusInput, arg1 func(*ec2.DescribeVolumeStatusOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVolumeStatusPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVolumeStatusPages indicates an expected call of DescribeVolumeStatusPages.
-func (mr *MockEC2APIMockRecorder) DescribeVolumeStatusPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeStatusPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeStatusPages), arg0, arg1)
-}
-
-// DescribeVolumeStatusPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeVolumeStatusPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumeStatusInput, arg2 func(*ec2.DescribeVolumeStatusOutput, 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, "DescribeVolumeStatusPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVolumeStatusPagesWithContext indicates an expected call of DescribeVolumeStatusPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVolumeStatusPagesWithContext(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, "DescribeVolumeStatusPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeStatusPagesWithContext), varargs...)
-}
-
-// DescribeVolumeStatusRequest mocks base method.
-func (m *MockEC2API) DescribeVolumeStatusRequest(arg0 *ec2.DescribeVolumeStatusInput) (*request.Request, *ec2.DescribeVolumeStatusOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVolumeStatusRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeVolumeStatusOutput)
-	return ret0, ret1
-}
-
-// DescribeVolumeStatusRequest indicates an expected call of DescribeVolumeStatusRequest.
-func (mr *MockEC2APIMockRecorder) DescribeVolumeStatusRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeStatusRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeStatusRequest), arg0)
-}
-
-// DescribeVolumeStatusWithContext mocks base method.
-func (m *MockEC2API) DescribeVolumeStatusWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumeStatusInput, arg2 ...request.Option) (*ec2.DescribeVolumeStatusOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeVolumeStatusWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeVolumeStatusOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVolumeStatusWithContext indicates an expected call of DescribeVolumeStatusWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVolumeStatusWithContext(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, "DescribeVolumeStatusWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeStatusWithContext), varargs...)
-}
-
-// DescribeVolumes mocks base method.
-func (m *MockEC2API) DescribeVolumes(arg0 *ec2.DescribeVolumesInput) (*ec2.DescribeVolumesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVolumes", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeVolumesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVolumes indicates an expected call of DescribeVolumes.
-func (mr *MockEC2APIMockRecorder) DescribeVolumes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumes", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumes), arg0)
-}
-
-// DescribeVolumesModifications mocks base method.
-func (m *MockEC2API) DescribeVolumesModifications(arg0 *ec2.DescribeVolumesModificationsInput) (*ec2.DescribeVolumesModificationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVolumesModifications", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeVolumesModificationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVolumesModifications indicates an expected call of DescribeVolumesModifications.
-func (mr *MockEC2APIMockRecorder) DescribeVolumesModifications(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesModifications", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesModifications), arg0)
-}
-
-// DescribeVolumesModificationsPages mocks base method.
-func (m *MockEC2API) DescribeVolumesModificationsPages(arg0 *ec2.DescribeVolumesModificationsInput, arg1 func(*ec2.DescribeVolumesModificationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVolumesModificationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVolumesModificationsPages indicates an expected call of DescribeVolumesModificationsPages.
-func (mr *MockEC2APIMockRecorder) DescribeVolumesModificationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesModificationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesModificationsPages), arg0, arg1)
-}
-
-// DescribeVolumesModificationsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeVolumesModificationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesModificationsInput, arg2 func(*ec2.DescribeVolumesModificationsOutput, 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, "DescribeVolumesModificationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVolumesModificationsPagesWithContext indicates an expected call of DescribeVolumesModificationsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVolumesModificationsPagesWithContext(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, "DescribeVolumesModificationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesModificationsPagesWithContext), varargs...)
-}
-
-// DescribeVolumesModificationsRequest mocks base method.
-func (m *MockEC2API) DescribeVolumesModificationsRequest(arg0 *ec2.DescribeVolumesModificationsInput) (*request.Request, *ec2.DescribeVolumesModificationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVolumesModificationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeVolumesModificationsOutput)
-	return ret0, ret1
-}
-
-// DescribeVolumesModificationsRequest indicates an expected call of DescribeVolumesModificationsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeVolumesModificationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesModificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesModificationsRequest), arg0)
-}
-
-// DescribeVolumesModificationsWithContext mocks base method.
-func (m *MockEC2API) DescribeVolumesModificationsWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesModificationsInput, arg2 ...request.Option) (*ec2.DescribeVolumesModificationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeVolumesModificationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeVolumesModificationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVolumesModificationsWithContext indicates an expected call of DescribeVolumesModificationsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVolumesModificationsWithContext(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, "DescribeVolumesModificationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesModificationsWithContext), varargs...)
-}
-
-// DescribeVolumesPages mocks base method.
-func (m *MockEC2API) DescribeVolumesPages(arg0 *ec2.DescribeVolumesInput, arg1 func(*ec2.DescribeVolumesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVolumesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVolumesPages indicates an expected call of DescribeVolumesPages.
-func (mr *MockEC2APIMockRecorder) DescribeVolumesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesPages), arg0, arg1)
-}
-
-// DescribeVolumesPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeVolumesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesInput, arg2 func(*ec2.DescribeVolumesOutput, 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, "DescribeVolumesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVolumesPagesWithContext indicates an expected call of DescribeVolumesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVolumesPagesWithContext(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, "DescribeVolumesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesPagesWithContext), varargs...)
-}
-
-// DescribeVolumesRequest mocks base method.
-func (m *MockEC2API) DescribeVolumesRequest(arg0 *ec2.DescribeVolumesInput) (*request.Request, *ec2.DescribeVolumesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVolumesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeVolumesOutput)
-	return ret0, ret1
-}
-
-// DescribeVolumesRequest indicates an expected call of DescribeVolumesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeVolumesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesRequest), arg0)
-}
-
-// DescribeVolumesWithContext mocks base method.
-func (m *MockEC2API) DescribeVolumesWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesInput, arg2 ...request.Option) (*ec2.DescribeVolumesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeVolumesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeVolumesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVolumesWithContext indicates an expected call of DescribeVolumesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVolumesWithContext(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, "DescribeVolumesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesWithContext), varargs...)
-}
-
-// DescribeVpcAttribute mocks base method.
-func (m *MockEC2API) DescribeVpcAttribute(arg0 *ec2.DescribeVpcAttributeInput) (*ec2.DescribeVpcAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcAttribute", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeVpcAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpcAttribute indicates an expected call of DescribeVpcAttribute.
-func (mr *MockEC2APIMockRecorder) DescribeVpcAttribute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcAttribute), arg0)
-}
-
-// DescribeVpcAttributeRequest mocks base method.
-func (m *MockEC2API) DescribeVpcAttributeRequest(arg0 *ec2.DescribeVpcAttributeInput) (*request.Request, *ec2.DescribeVpcAttributeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcAttributeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeVpcAttributeOutput)
-	return ret0, ret1
-}
-
-// DescribeVpcAttributeRequest indicates an expected call of DescribeVpcAttributeRequest.
-func (mr *MockEC2APIMockRecorder) DescribeVpcAttributeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcAttributeRequest), arg0)
-}
-
-// DescribeVpcAttributeWithContext mocks base method.
-func (m *MockEC2API) DescribeVpcAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcAttributeInput, arg2 ...request.Option) (*ec2.DescribeVpcAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeVpcAttributeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeVpcAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpcAttributeWithContext indicates an expected call of DescribeVpcAttributeWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVpcAttributeWithContext(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, "DescribeVpcAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcAttributeWithContext), varargs...)
-}
-
-// DescribeVpcClassicLink mocks base method.
-func (m *MockEC2API) DescribeVpcClassicLink(arg0 *ec2.DescribeVpcClassicLinkInput) (*ec2.DescribeVpcClassicLinkOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcClassicLink", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeVpcClassicLinkOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpcClassicLink indicates an expected call of DescribeVpcClassicLink.
-func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLink(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLink", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLink), arg0)
-}
-
-// DescribeVpcClassicLinkDnsSupport mocks base method.
-func (m *MockEC2API) DescribeVpcClassicLinkDnsSupport(arg0 *ec2.DescribeVpcClassicLinkDnsSupportInput) (*ec2.DescribeVpcClassicLinkDnsSupportOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcClassicLinkDnsSupport", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeVpcClassicLinkDnsSupportOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpcClassicLinkDnsSupport indicates an expected call of DescribeVpcClassicLinkDnsSupport.
-func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkDnsSupport(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkDnsSupport", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkDnsSupport), arg0)
-}
-
-// DescribeVpcClassicLinkDnsSupportPages mocks base method.
-func (m *MockEC2API) DescribeVpcClassicLinkDnsSupportPages(arg0 *ec2.DescribeVpcClassicLinkDnsSupportInput, arg1 func(*ec2.DescribeVpcClassicLinkDnsSupportOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcClassicLinkDnsSupportPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVpcClassicLinkDnsSupportPages indicates an expected call of DescribeVpcClassicLinkDnsSupportPages.
-func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkDnsSupportPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkDnsSupportPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkDnsSupportPages), arg0, arg1)
-}
-
-// DescribeVpcClassicLinkDnsSupportPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeVpcClassicLinkDnsSupportPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcClassicLinkDnsSupportInput, arg2 func(*ec2.DescribeVpcClassicLinkDnsSupportOutput, 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, "DescribeVpcClassicLinkDnsSupportPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVpcClassicLinkDnsSupportPagesWithContext indicates an expected call of DescribeVpcClassicLinkDnsSupportPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkDnsSupportPagesWithContext(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, "DescribeVpcClassicLinkDnsSupportPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkDnsSupportPagesWithContext), varargs...)
-}
-
-// DescribeVpcClassicLinkDnsSupportRequest mocks base method.
-func (m *MockEC2API) DescribeVpcClassicLinkDnsSupportRequest(arg0 *ec2.DescribeVpcClassicLinkDnsSupportInput) (*request.Request, *ec2.DescribeVpcClassicLinkDnsSupportOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcClassicLinkDnsSupportRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeVpcClassicLinkDnsSupportOutput)
-	return ret0, ret1
-}
-
-// DescribeVpcClassicLinkDnsSupportRequest indicates an expected call of DescribeVpcClassicLinkDnsSupportRequest.
-func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkDnsSupportRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkDnsSupportRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkDnsSupportRequest), arg0)
-}
-
-// DescribeVpcClassicLinkDnsSupportWithContext mocks base method.
-func (m *MockEC2API) DescribeVpcClassicLinkDnsSupportWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcClassicLinkDnsSupportInput, arg2 ...request.Option) (*ec2.DescribeVpcClassicLinkDnsSupportOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeVpcClassicLinkDnsSupportWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeVpcClassicLinkDnsSupportOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpcClassicLinkDnsSupportWithContext indicates an expected call of DescribeVpcClassicLinkDnsSupportWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkDnsSupportWithContext(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, "DescribeVpcClassicLinkDnsSupportWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkDnsSupportWithContext), varargs...)
-}
-
-// DescribeVpcClassicLinkRequest mocks base method.
-func (m *MockEC2API) DescribeVpcClassicLinkRequest(arg0 *ec2.DescribeVpcClassicLinkInput) (*request.Request, *ec2.DescribeVpcClassicLinkOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcClassicLinkRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeVpcClassicLinkOutput)
-	return ret0, ret1
-}
-
-// DescribeVpcClassicLinkRequest indicates an expected call of DescribeVpcClassicLinkRequest.
-func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkRequest), arg0)
-}
-
-// DescribeVpcClassicLinkWithContext mocks base method.
-func (m *MockEC2API) DescribeVpcClassicLinkWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcClassicLinkInput, arg2 ...request.Option) (*ec2.DescribeVpcClassicLinkOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeVpcClassicLinkWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeVpcClassicLinkOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpcClassicLinkWithContext indicates an expected call of DescribeVpcClassicLinkWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkWithContext(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, "DescribeVpcClassicLinkWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkWithContext), varargs...)
-}
-
-// DescribeVpcEndpointConnectionNotifications mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointConnectionNotifications(arg0 *ec2.DescribeVpcEndpointConnectionNotificationsInput) (*ec2.DescribeVpcEndpointConnectionNotificationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionNotifications", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointConnectionNotificationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpcEndpointConnectionNotifications indicates an expected call of DescribeVpcEndpointConnectionNotifications.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionNotifications(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionNotifications", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionNotifications), arg0)
-}
-
-// DescribeVpcEndpointConnectionNotificationsPages mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointConnectionNotificationsPages(arg0 *ec2.DescribeVpcEndpointConnectionNotificationsInput, arg1 func(*ec2.DescribeVpcEndpointConnectionNotificationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionNotificationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVpcEndpointConnectionNotificationsPages indicates an expected call of DescribeVpcEndpointConnectionNotificationsPages.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionNotificationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionNotificationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionNotificationsPages), arg0, arg1)
-}
-
-// DescribeVpcEndpointConnectionNotificationsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointConnectionNotificationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointConnectionNotificationsInput, arg2 func(*ec2.DescribeVpcEndpointConnectionNotificationsOutput, 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, "DescribeVpcEndpointConnectionNotificationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVpcEndpointConnectionNotificationsPagesWithContext indicates an expected call of DescribeVpcEndpointConnectionNotificationsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionNotificationsPagesWithContext(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, "DescribeVpcEndpointConnectionNotificationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionNotificationsPagesWithContext), varargs...)
-}
-
-// DescribeVpcEndpointConnectionNotificationsRequest mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointConnectionNotificationsRequest(arg0 *ec2.DescribeVpcEndpointConnectionNotificationsInput) (*request.Request, *ec2.DescribeVpcEndpointConnectionNotificationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionNotificationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeVpcEndpointConnectionNotificationsOutput)
-	return ret0, ret1
-}
-
-// DescribeVpcEndpointConnectionNotificationsRequest indicates an expected call of DescribeVpcEndpointConnectionNotificationsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionNotificationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionNotificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionNotificationsRequest), arg0)
-}
-
-// DescribeVpcEndpointConnectionNotificationsWithContext mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointConnectionNotificationsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointConnectionNotificationsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointConnectionNotificationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionNotificationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointConnectionNotificationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpcEndpointConnectionNotificationsWithContext indicates an expected call of DescribeVpcEndpointConnectionNotificationsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionNotificationsWithContext(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, "DescribeVpcEndpointConnectionNotificationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionNotificationsWithContext), varargs...)
-}
-
-// DescribeVpcEndpointConnections mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointConnections(arg0 *ec2.DescribeVpcEndpointConnectionsInput) (*ec2.DescribeVpcEndpointConnectionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcEndpointConnections", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointConnectionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpcEndpointConnections indicates an expected call of DescribeVpcEndpointConnections.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnections(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnections", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnections), arg0)
-}
-
-// DescribeVpcEndpointConnectionsPages mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointConnectionsPages(arg0 *ec2.DescribeVpcEndpointConnectionsInput, arg1 func(*ec2.DescribeVpcEndpointConnectionsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVpcEndpointConnectionsPages indicates an expected call of DescribeVpcEndpointConnectionsPages.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionsPages), arg0, arg1)
-}
-
-// DescribeVpcEndpointConnectionsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointConnectionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointConnectionsInput, arg2 func(*ec2.DescribeVpcEndpointConnectionsOutput, 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, "DescribeVpcEndpointConnectionsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVpcEndpointConnectionsPagesWithContext indicates an expected call of DescribeVpcEndpointConnectionsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionsPagesWithContext(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, "DescribeVpcEndpointConnectionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionsPagesWithContext), varargs...)
-}
-
-// DescribeVpcEndpointConnectionsRequest mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointConnectionsRequest(arg0 *ec2.DescribeVpcEndpointConnectionsInput) (*request.Request, *ec2.DescribeVpcEndpointConnectionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeVpcEndpointConnectionsOutput)
-	return ret0, ret1
-}
-
-// DescribeVpcEndpointConnectionsRequest indicates an expected call of DescribeVpcEndpointConnectionsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionsRequest), arg0)
-}
-
-// DescribeVpcEndpointConnectionsWithContext mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointConnectionsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointConnectionsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointConnectionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointConnectionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpcEndpointConnectionsWithContext indicates an expected call of DescribeVpcEndpointConnectionsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionsWithContext(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, "DescribeVpcEndpointConnectionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionsWithContext), varargs...)
-}
-
-// DescribeVpcEndpointServiceConfigurations mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointServiceConfigurations(arg0 *ec2.DescribeVpcEndpointServiceConfigurationsInput) (*ec2.DescribeVpcEndpointServiceConfigurationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcEndpointServiceConfigurations", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServiceConfigurationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpcEndpointServiceConfigurations indicates an expected call of DescribeVpcEndpointServiceConfigurations.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServiceConfigurations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServiceConfigurations", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServiceConfigurations), arg0)
-}
-
-// DescribeVpcEndpointServiceConfigurationsPages mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointServiceConfigurationsPages(arg0 *ec2.DescribeVpcEndpointServiceConfigurationsInput, arg1 func(*ec2.DescribeVpcEndpointServiceConfigurationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcEndpointServiceConfigurationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVpcEndpointServiceConfigurationsPages indicates an expected call of DescribeVpcEndpointServiceConfigurationsPages.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServiceConfigurationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServiceConfigurationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServiceConfigurationsPages), arg0, arg1)
-}
-
-// DescribeVpcEndpointServiceConfigurationsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointServiceConfigurationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointServiceConfigurationsInput, arg2 func(*ec2.DescribeVpcEndpointServiceConfigurationsOutput, 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, "DescribeVpcEndpointServiceConfigurationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVpcEndpointServiceConfigurationsPagesWithContext indicates an expected call of DescribeVpcEndpointServiceConfigurationsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServiceConfigurationsPagesWithContext(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, "DescribeVpcEndpointServiceConfigurationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServiceConfigurationsPagesWithContext), varargs...)
-}
-
-// DescribeVpcEndpointServiceConfigurationsRequest mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointServiceConfigurationsRequest(arg0 *ec2.DescribeVpcEndpointServiceConfigurationsInput) (*request.Request, *ec2.DescribeVpcEndpointServiceConfigurationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcEndpointServiceConfigurationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeVpcEndpointServiceConfigurationsOutput)
-	return ret0, ret1
-}
-
-// DescribeVpcEndpointServiceConfigurationsRequest indicates an expected call of DescribeVpcEndpointServiceConfigurationsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServiceConfigurationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServiceConfigurationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServiceConfigurationsRequest), arg0)
-}
-
-// DescribeVpcEndpointServiceConfigurationsWithContext mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointServiceConfigurationsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointServiceConfigurationsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointServiceConfigurationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeVpcEndpointServiceConfigurationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServiceConfigurationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpcEndpointServiceConfigurationsWithContext indicates an expected call of DescribeVpcEndpointServiceConfigurationsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServiceConfigurationsWithContext(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, "DescribeVpcEndpointServiceConfigurationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServiceConfigurationsWithContext), varargs...)
-}
-
-// DescribeVpcEndpointServicePermissions mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointServicePermissions(arg0 *ec2.DescribeVpcEndpointServicePermissionsInput) (*ec2.DescribeVpcEndpointServicePermissionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcEndpointServicePermissions", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServicePermissionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpcEndpointServicePermissions indicates an expected call of DescribeVpcEndpointServicePermissions.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicePermissions(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicePermissions", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicePermissions), arg0)
-}
-
-// DescribeVpcEndpointServicePermissionsPages mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointServicePermissionsPages(arg0 *ec2.DescribeVpcEndpointServicePermissionsInput, arg1 func(*ec2.DescribeVpcEndpointServicePermissionsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcEndpointServicePermissionsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVpcEndpointServicePermissionsPages indicates an expected call of DescribeVpcEndpointServicePermissionsPages.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicePermissionsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicePermissionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicePermissionsPages), arg0, arg1)
-}
-
-// DescribeVpcEndpointServicePermissionsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointServicePermissionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointServicePermissionsInput, arg2 func(*ec2.DescribeVpcEndpointServicePermissionsOutput, 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, "DescribeVpcEndpointServicePermissionsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVpcEndpointServicePermissionsPagesWithContext indicates an expected call of DescribeVpcEndpointServicePermissionsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicePermissionsPagesWithContext(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, "DescribeVpcEndpointServicePermissionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicePermissionsPagesWithContext), varargs...)
-}
-
-// DescribeVpcEndpointServicePermissionsRequest mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointServicePermissionsRequest(arg0 *ec2.DescribeVpcEndpointServicePermissionsInput) (*request.Request, *ec2.DescribeVpcEndpointServicePermissionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcEndpointServicePermissionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeVpcEndpointServicePermissionsOutput)
-	return ret0, ret1
-}
-
-// DescribeVpcEndpointServicePermissionsRequest indicates an expected call of DescribeVpcEndpointServicePermissionsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicePermissionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicePermissionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicePermissionsRequest), arg0)
-}
-
-// DescribeVpcEndpointServicePermissionsWithContext mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointServicePermissionsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointServicePermissionsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointServicePermissionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeVpcEndpointServicePermissionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServicePermissionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpcEndpointServicePermissionsWithContext indicates an expected call of DescribeVpcEndpointServicePermissionsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicePermissionsWithContext(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, "DescribeVpcEndpointServicePermissionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicePermissionsWithContext), varargs...)
-}
-
-// DescribeVpcEndpointServices mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointServices(arg0 *ec2.DescribeVpcEndpointServicesInput) (*ec2.DescribeVpcEndpointServicesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcEndpointServices", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServicesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpcEndpointServices indicates an expected call of DescribeVpcEndpointServices.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServices(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServices", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServices), arg0)
-}
-
-// DescribeVpcEndpointServicesRequest mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointServicesRequest(arg0 *ec2.DescribeVpcEndpointServicesInput) (*request.Request, *ec2.DescribeVpcEndpointServicesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcEndpointServicesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeVpcEndpointServicesOutput)
-	return ret0, ret1
-}
-
-// DescribeVpcEndpointServicesRequest indicates an expected call of DescribeVpcEndpointServicesRequest.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicesRequest), arg0)
-}
-
-// DescribeVpcEndpointServicesWithContext mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointServicesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointServicesInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointServicesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeVpcEndpointServicesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServicesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpcEndpointServicesWithContext indicates an expected call of DescribeVpcEndpointServicesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicesWithContext(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, "DescribeVpcEndpointServicesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicesWithContext), varargs...)
-}
-
-// DescribeVpcEndpoints mocks base method.
-func (m *MockEC2API) DescribeVpcEndpoints(arg0 *ec2.DescribeVpcEndpointsInput) (*ec2.DescribeVpcEndpointsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcEndpoints", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpcEndpoints indicates an expected call of DescribeVpcEndpoints.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpoints(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpoints", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpoints), arg0)
-}
-
-// DescribeVpcEndpointsPages mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointsPages(arg0 *ec2.DescribeVpcEndpointsInput, arg1 func(*ec2.DescribeVpcEndpointsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcEndpointsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVpcEndpointsPages indicates an expected call of DescribeVpcEndpointsPages.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointsPages), arg0, arg1)
-}
-
-// DescribeVpcEndpointsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointsInput, arg2 func(*ec2.DescribeVpcEndpointsOutput, 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, "DescribeVpcEndpointsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVpcEndpointsPagesWithContext indicates an expected call of DescribeVpcEndpointsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointsPagesWithContext(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, "DescribeVpcEndpointsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointsPagesWithContext), varargs...)
-}
-
-// DescribeVpcEndpointsRequest mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointsRequest(arg0 *ec2.DescribeVpcEndpointsInput) (*request.Request, *ec2.DescribeVpcEndpointsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcEndpointsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeVpcEndpointsOutput)
-	return ret0, ret1
-}
-
-// DescribeVpcEndpointsRequest indicates an expected call of DescribeVpcEndpointsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointsRequest), arg0)
-}
-
-// DescribeVpcEndpointsWithContext mocks base method.
-func (m *MockEC2API) DescribeVpcEndpointsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeVpcEndpointsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpcEndpointsWithContext indicates an expected call of DescribeVpcEndpointsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointsWithContext(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, "DescribeVpcEndpointsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointsWithContext), varargs...)
-}
-
-// DescribeVpcPeeringConnections mocks base method.
-func (m *MockEC2API) DescribeVpcPeeringConnections(arg0 *ec2.DescribeVpcPeeringConnectionsInput) (*ec2.DescribeVpcPeeringConnectionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcPeeringConnections", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeVpcPeeringConnectionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpcPeeringConnections indicates an expected call of DescribeVpcPeeringConnections.
-func (mr *MockEC2APIMockRecorder) DescribeVpcPeeringConnections(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnections", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcPeeringConnections), arg0)
-}
-
-// DescribeVpcPeeringConnectionsPages mocks base method.
-func (m *MockEC2API) DescribeVpcPeeringConnectionsPages(arg0 *ec2.DescribeVpcPeeringConnectionsInput, arg1 func(*ec2.DescribeVpcPeeringConnectionsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcPeeringConnectionsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVpcPeeringConnectionsPages indicates an expected call of DescribeVpcPeeringConnectionsPages.
-func (mr *MockEC2APIMockRecorder) DescribeVpcPeeringConnectionsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnectionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcPeeringConnectionsPages), arg0, arg1)
-}
-
-// DescribeVpcPeeringConnectionsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeVpcPeeringConnectionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcPeeringConnectionsInput, arg2 func(*ec2.DescribeVpcPeeringConnectionsOutput, 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, "DescribeVpcPeeringConnectionsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVpcPeeringConnectionsPagesWithContext indicates an expected call of DescribeVpcPeeringConnectionsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVpcPeeringConnectionsPagesWithContext(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, "DescribeVpcPeeringConnectionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcPeeringConnectionsPagesWithContext), varargs...)
-}
-
-// DescribeVpcPeeringConnectionsRequest mocks base method.
-func (m *MockEC2API) DescribeVpcPeeringConnectionsRequest(arg0 *ec2.DescribeVpcPeeringConnectionsInput) (*request.Request, *ec2.DescribeVpcPeeringConnectionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcPeeringConnectionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeVpcPeeringConnectionsOutput)
-	return ret0, ret1
-}
-
-// DescribeVpcPeeringConnectionsRequest indicates an expected call of DescribeVpcPeeringConnectionsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeVpcPeeringConnectionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcPeeringConnectionsRequest), arg0)
-}
-
-// DescribeVpcPeeringConnectionsWithContext mocks base method.
-func (m *MockEC2API) DescribeVpcPeeringConnectionsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcPeeringConnectionsInput, arg2 ...request.Option) (*ec2.DescribeVpcPeeringConnectionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeVpcPeeringConnectionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeVpcPeeringConnectionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpcPeeringConnectionsWithContext indicates an expected call of DescribeVpcPeeringConnectionsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVpcPeeringConnectionsWithContext(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, "DescribeVpcPeeringConnectionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcPeeringConnectionsWithContext), varargs...)
-}
-
-// DescribeVpcs mocks base method.
-func (m *MockEC2API) DescribeVpcs(arg0 *ec2.DescribeVpcsInput) (*ec2.DescribeVpcsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcs", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeVpcsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpcs indicates an expected call of DescribeVpcs.
-func (mr *MockEC2APIMockRecorder) DescribeVpcs(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcs", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcs), arg0)
-}
-
-// DescribeVpcsPages mocks base method.
-func (m *MockEC2API) DescribeVpcsPages(arg0 *ec2.DescribeVpcsInput, arg1 func(*ec2.DescribeVpcsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVpcsPages indicates an expected call of DescribeVpcsPages.
-func (mr *MockEC2APIMockRecorder) DescribeVpcsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcsPages), arg0, arg1)
-}
-
-// DescribeVpcsPagesWithContext mocks base method.
-func (m *MockEC2API) DescribeVpcsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcsInput, arg2 func(*ec2.DescribeVpcsOutput, 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, "DescribeVpcsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DescribeVpcsPagesWithContext indicates an expected call of DescribeVpcsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVpcsPagesWithContext(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, "DescribeVpcsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcsPagesWithContext), varargs...)
-}
-
-// DescribeVpcsRequest mocks base method.
-func (m *MockEC2API) DescribeVpcsRequest(arg0 *ec2.DescribeVpcsInput) (*request.Request, *ec2.DescribeVpcsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpcsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeVpcsOutput)
-	return ret0, ret1
-}
-
-// DescribeVpcsRequest indicates an expected call of DescribeVpcsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeVpcsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcsRequest), arg0)
-}
-
-// DescribeVpcsWithContext mocks base method.
-func (m *MockEC2API) DescribeVpcsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcsInput, arg2 ...request.Option) (*ec2.DescribeVpcsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeVpcsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeVpcsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpcsWithContext indicates an expected call of DescribeVpcsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVpcsWithContext(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, "DescribeVpcsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcsWithContext), varargs...)
-}
-
-// DescribeVpnConnections mocks base method.
-func (m *MockEC2API) DescribeVpnConnections(arg0 *ec2.DescribeVpnConnectionsInput) (*ec2.DescribeVpnConnectionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpnConnections", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeVpnConnectionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpnConnections indicates an expected call of DescribeVpnConnections.
-func (mr *MockEC2APIMockRecorder) DescribeVpnConnections(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnConnections", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnConnections), arg0)
-}
-
-// DescribeVpnConnectionsRequest mocks base method.
-func (m *MockEC2API) DescribeVpnConnectionsRequest(arg0 *ec2.DescribeVpnConnectionsInput) (*request.Request, *ec2.DescribeVpnConnectionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpnConnectionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeVpnConnectionsOutput)
-	return ret0, ret1
-}
-
-// DescribeVpnConnectionsRequest indicates an expected call of DescribeVpnConnectionsRequest.
-func (mr *MockEC2APIMockRecorder) DescribeVpnConnectionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnConnectionsRequest), arg0)
-}
-
-// DescribeVpnConnectionsWithContext mocks base method.
-func (m *MockEC2API) DescribeVpnConnectionsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpnConnectionsInput, arg2 ...request.Option) (*ec2.DescribeVpnConnectionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeVpnConnectionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeVpnConnectionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpnConnectionsWithContext indicates an expected call of DescribeVpnConnectionsWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVpnConnectionsWithContext(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, "DescribeVpnConnectionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnConnectionsWithContext), varargs...)
-}
-
-// DescribeVpnGateways mocks base method.
-func (m *MockEC2API) DescribeVpnGateways(arg0 *ec2.DescribeVpnGatewaysInput) (*ec2.DescribeVpnGatewaysOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpnGateways", arg0)
-	ret0, _ := ret[0].(*ec2.DescribeVpnGatewaysOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpnGateways indicates an expected call of DescribeVpnGateways.
-func (mr *MockEC2APIMockRecorder) DescribeVpnGateways(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnGateways), arg0)
-}
-
-// DescribeVpnGatewaysRequest mocks base method.
-func (m *MockEC2API) DescribeVpnGatewaysRequest(arg0 *ec2.DescribeVpnGatewaysInput) (*request.Request, *ec2.DescribeVpnGatewaysOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeVpnGatewaysRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DescribeVpnGatewaysOutput)
-	return ret0, ret1
-}
-
-// DescribeVpnGatewaysRequest indicates an expected call of DescribeVpnGatewaysRequest.
-func (mr *MockEC2APIMockRecorder) DescribeVpnGatewaysRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnGatewaysRequest), arg0)
-}
-
-// DescribeVpnGatewaysWithContext mocks base method.
-func (m *MockEC2API) DescribeVpnGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeVpnGatewaysInput, arg2 ...request.Option) (*ec2.DescribeVpnGatewaysOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeVpnGatewaysWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DescribeVpnGatewaysOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeVpnGatewaysWithContext indicates an expected call of DescribeVpnGatewaysWithContext.
-func (mr *MockEC2APIMockRecorder) DescribeVpnGatewaysWithContext(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, "DescribeVpnGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnGatewaysWithContext), varargs...)
-}
-
-// DetachClassicLinkVpc mocks base method.
-func (m *MockEC2API) DetachClassicLinkVpc(arg0 *ec2.DetachClassicLinkVpcInput) (*ec2.DetachClassicLinkVpcOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DetachClassicLinkVpc", arg0)
-	ret0, _ := ret[0].(*ec2.DetachClassicLinkVpcOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DetachClassicLinkVpc indicates an expected call of DetachClassicLinkVpc.
-func (mr *MockEC2APIMockRecorder) DetachClassicLinkVpc(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachClassicLinkVpc", reflect.TypeOf((*MockEC2API)(nil).DetachClassicLinkVpc), arg0)
-}
-
-// DetachClassicLinkVpcRequest mocks base method.
-func (m *MockEC2API) DetachClassicLinkVpcRequest(arg0 *ec2.DetachClassicLinkVpcInput) (*request.Request, *ec2.DetachClassicLinkVpcOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DetachClassicLinkVpcRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DetachClassicLinkVpcOutput)
-	return ret0, ret1
-}
-
-// DetachClassicLinkVpcRequest indicates an expected call of DetachClassicLinkVpcRequest.
-func (mr *MockEC2APIMockRecorder) DetachClassicLinkVpcRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachClassicLinkVpcRequest", reflect.TypeOf((*MockEC2API)(nil).DetachClassicLinkVpcRequest), arg0)
-}
-
-// DetachClassicLinkVpcWithContext mocks base method.
-func (m *MockEC2API) DetachClassicLinkVpcWithContext(arg0 context.Context, arg1 *ec2.DetachClassicLinkVpcInput, arg2 ...request.Option) (*ec2.DetachClassicLinkVpcOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DetachClassicLinkVpcWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DetachClassicLinkVpcOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DetachClassicLinkVpcWithContext indicates an expected call of DetachClassicLinkVpcWithContext.
-func (mr *MockEC2APIMockRecorder) DetachClassicLinkVpcWithContext(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, "DetachClassicLinkVpcWithContext", reflect.TypeOf((*MockEC2API)(nil).DetachClassicLinkVpcWithContext), varargs...)
-}
-
-// DetachInternetGateway mocks base method.
-func (m *MockEC2API) DetachInternetGateway(arg0 *ec2.DetachInternetGatewayInput) (*ec2.DetachInternetGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DetachInternetGateway", arg0)
-	ret0, _ := ret[0].(*ec2.DetachInternetGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DetachInternetGateway indicates an expected call of DetachInternetGateway.
-func (mr *MockEC2APIMockRecorder) DetachInternetGateway(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachInternetGateway", reflect.TypeOf((*MockEC2API)(nil).DetachInternetGateway), arg0)
-}
-
-// DetachInternetGatewayRequest mocks base method.
-func (m *MockEC2API) DetachInternetGatewayRequest(arg0 *ec2.DetachInternetGatewayInput) (*request.Request, *ec2.DetachInternetGatewayOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DetachInternetGatewayRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DetachInternetGatewayOutput)
-	return ret0, ret1
-}
-
-// DetachInternetGatewayRequest indicates an expected call of DetachInternetGatewayRequest.
-func (mr *MockEC2APIMockRecorder) DetachInternetGatewayRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DetachInternetGatewayRequest), arg0)
-}
-
-// DetachInternetGatewayWithContext mocks base method.
-func (m *MockEC2API) DetachInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.DetachInternetGatewayInput, arg2 ...request.Option) (*ec2.DetachInternetGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DetachInternetGatewayWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DetachInternetGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DetachInternetGatewayWithContext indicates an expected call of DetachInternetGatewayWithContext.
-func (mr *MockEC2APIMockRecorder) DetachInternetGatewayWithContext(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, "DetachInternetGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DetachInternetGatewayWithContext), varargs...)
-}
-
-// DetachNetworkInterface mocks base method.
-func (m *MockEC2API) DetachNetworkInterface(arg0 *ec2.DetachNetworkInterfaceInput) (*ec2.DetachNetworkInterfaceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DetachNetworkInterface", arg0)
-	ret0, _ := ret[0].(*ec2.DetachNetworkInterfaceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DetachNetworkInterface indicates an expected call of DetachNetworkInterface.
-func (mr *MockEC2APIMockRecorder) DetachNetworkInterface(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachNetworkInterface", reflect.TypeOf((*MockEC2API)(nil).DetachNetworkInterface), arg0)
-}
-
-// DetachNetworkInterfaceRequest mocks base method.
-func (m *MockEC2API) DetachNetworkInterfaceRequest(arg0 *ec2.DetachNetworkInterfaceInput) (*request.Request, *ec2.DetachNetworkInterfaceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DetachNetworkInterfaceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DetachNetworkInterfaceOutput)
-	return ret0, ret1
-}
-
-// DetachNetworkInterfaceRequest indicates an expected call of DetachNetworkInterfaceRequest.
-func (mr *MockEC2APIMockRecorder) DetachNetworkInterfaceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachNetworkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).DetachNetworkInterfaceRequest), arg0)
-}
-
-// DetachNetworkInterfaceWithContext mocks base method.
-func (m *MockEC2API) DetachNetworkInterfaceWithContext(arg0 context.Context, arg1 *ec2.DetachNetworkInterfaceInput, arg2 ...request.Option) (*ec2.DetachNetworkInterfaceOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DetachNetworkInterfaceWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DetachNetworkInterfaceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DetachNetworkInterfaceWithContext indicates an expected call of DetachNetworkInterfaceWithContext.
-func (mr *MockEC2APIMockRecorder) DetachNetworkInterfaceWithContext(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, "DetachNetworkInterfaceWithContext", reflect.TypeOf((*MockEC2API)(nil).DetachNetworkInterfaceWithContext), varargs...)
-}
-
-// DetachVerifiedAccessTrustProvider mocks base method.
-func (m *MockEC2API) DetachVerifiedAccessTrustProvider(arg0 *ec2.DetachVerifiedAccessTrustProviderInput) (*ec2.DetachVerifiedAccessTrustProviderOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DetachVerifiedAccessTrustProvider", arg0)
-	ret0, _ := ret[0].(*ec2.DetachVerifiedAccessTrustProviderOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DetachVerifiedAccessTrustProvider indicates an expected call of DetachVerifiedAccessTrustProvider.
-func (mr *MockEC2APIMockRecorder) DetachVerifiedAccessTrustProvider(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVerifiedAccessTrustProvider", reflect.TypeOf((*MockEC2API)(nil).DetachVerifiedAccessTrustProvider), arg0)
-}
-
-// DetachVerifiedAccessTrustProviderRequest mocks base method.
-func (m *MockEC2API) DetachVerifiedAccessTrustProviderRequest(arg0 *ec2.DetachVerifiedAccessTrustProviderInput) (*request.Request, *ec2.DetachVerifiedAccessTrustProviderOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DetachVerifiedAccessTrustProviderRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DetachVerifiedAccessTrustProviderOutput)
-	return ret0, ret1
-}
-
-// DetachVerifiedAccessTrustProviderRequest indicates an expected call of DetachVerifiedAccessTrustProviderRequest.
-func (mr *MockEC2APIMockRecorder) DetachVerifiedAccessTrustProviderRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVerifiedAccessTrustProviderRequest", reflect.TypeOf((*MockEC2API)(nil).DetachVerifiedAccessTrustProviderRequest), arg0)
-}
-
-// DetachVerifiedAccessTrustProviderWithContext mocks base method.
-func (m *MockEC2API) DetachVerifiedAccessTrustProviderWithContext(arg0 context.Context, arg1 *ec2.DetachVerifiedAccessTrustProviderInput, arg2 ...request.Option) (*ec2.DetachVerifiedAccessTrustProviderOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DetachVerifiedAccessTrustProviderWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DetachVerifiedAccessTrustProviderOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DetachVerifiedAccessTrustProviderWithContext indicates an expected call of DetachVerifiedAccessTrustProviderWithContext.
-func (mr *MockEC2APIMockRecorder) DetachVerifiedAccessTrustProviderWithContext(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, "DetachVerifiedAccessTrustProviderWithContext", reflect.TypeOf((*MockEC2API)(nil).DetachVerifiedAccessTrustProviderWithContext), varargs...)
-}
-
-// DetachVolume mocks base method.
-func (m *MockEC2API) DetachVolume(arg0 *ec2.DetachVolumeInput) (*ec2.VolumeAttachment, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DetachVolume", arg0)
-	ret0, _ := ret[0].(*ec2.VolumeAttachment)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DetachVolume indicates an expected call of DetachVolume.
-func (mr *MockEC2APIMockRecorder) DetachVolume(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVolume", reflect.TypeOf((*MockEC2API)(nil).DetachVolume), arg0)
-}
-
-// DetachVolumeRequest mocks base method.
-func (m *MockEC2API) DetachVolumeRequest(arg0 *ec2.DetachVolumeInput) (*request.Request, *ec2.VolumeAttachment) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DetachVolumeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.VolumeAttachment)
-	return ret0, ret1
-}
-
-// DetachVolumeRequest indicates an expected call of DetachVolumeRequest.
-func (mr *MockEC2APIMockRecorder) DetachVolumeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).DetachVolumeRequest), arg0)
-}
-
-// DetachVolumeWithContext mocks base method.
-func (m *MockEC2API) DetachVolumeWithContext(arg0 context.Context, arg1 *ec2.DetachVolumeInput, arg2 ...request.Option) (*ec2.VolumeAttachment, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DetachVolumeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.VolumeAttachment)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DetachVolumeWithContext indicates an expected call of DetachVolumeWithContext.
-func (mr *MockEC2APIMockRecorder) DetachVolumeWithContext(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, "DetachVolumeWithContext", reflect.TypeOf((*MockEC2API)(nil).DetachVolumeWithContext), varargs...)
-}
-
-// DetachVpnGateway mocks base method.
-func (m *MockEC2API) DetachVpnGateway(arg0 *ec2.DetachVpnGatewayInput) (*ec2.DetachVpnGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DetachVpnGateway", arg0)
-	ret0, _ := ret[0].(*ec2.DetachVpnGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DetachVpnGateway indicates an expected call of DetachVpnGateway.
-func (mr *MockEC2APIMockRecorder) DetachVpnGateway(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVpnGateway", reflect.TypeOf((*MockEC2API)(nil).DetachVpnGateway), arg0)
-}
-
-// DetachVpnGatewayRequest mocks base method.
-func (m *MockEC2API) DetachVpnGatewayRequest(arg0 *ec2.DetachVpnGatewayInput) (*request.Request, *ec2.DetachVpnGatewayOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DetachVpnGatewayRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DetachVpnGatewayOutput)
-	return ret0, ret1
-}
-
-// DetachVpnGatewayRequest indicates an expected call of DetachVpnGatewayRequest.
-func (mr *MockEC2APIMockRecorder) DetachVpnGatewayRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVpnGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DetachVpnGatewayRequest), arg0)
-}
-
-// DetachVpnGatewayWithContext mocks base method.
-func (m *MockEC2API) DetachVpnGatewayWithContext(arg0 context.Context, arg1 *ec2.DetachVpnGatewayInput, arg2 ...request.Option) (*ec2.DetachVpnGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DetachVpnGatewayWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DetachVpnGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DetachVpnGatewayWithContext indicates an expected call of DetachVpnGatewayWithContext.
-func (mr *MockEC2APIMockRecorder) DetachVpnGatewayWithContext(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, "DetachVpnGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DetachVpnGatewayWithContext), varargs...)
-}
-
-// DisableAddressTransfer mocks base method.
-func (m *MockEC2API) DisableAddressTransfer(arg0 *ec2.DisableAddressTransferInput) (*ec2.DisableAddressTransferOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableAddressTransfer", arg0)
-	ret0, _ := ret[0].(*ec2.DisableAddressTransferOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableAddressTransfer indicates an expected call of DisableAddressTransfer.
-func (mr *MockEC2APIMockRecorder) DisableAddressTransfer(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableAddressTransfer", reflect.TypeOf((*MockEC2API)(nil).DisableAddressTransfer), arg0)
-}
-
-// DisableAddressTransferRequest mocks base method.
-func (m *MockEC2API) DisableAddressTransferRequest(arg0 *ec2.DisableAddressTransferInput) (*request.Request, *ec2.DisableAddressTransferOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableAddressTransferRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisableAddressTransferOutput)
-	return ret0, ret1
-}
-
-// DisableAddressTransferRequest indicates an expected call of DisableAddressTransferRequest.
-func (mr *MockEC2APIMockRecorder) DisableAddressTransferRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableAddressTransferRequest", reflect.TypeOf((*MockEC2API)(nil).DisableAddressTransferRequest), arg0)
-}
-
-// DisableAddressTransferWithContext mocks base method.
-func (m *MockEC2API) DisableAddressTransferWithContext(arg0 context.Context, arg1 *ec2.DisableAddressTransferInput, arg2 ...request.Option) (*ec2.DisableAddressTransferOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisableAddressTransferWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisableAddressTransferOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableAddressTransferWithContext indicates an expected call of DisableAddressTransferWithContext.
-func (mr *MockEC2APIMockRecorder) DisableAddressTransferWithContext(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, "DisableAddressTransferWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableAddressTransferWithContext), varargs...)
-}
-
-// DisableAwsNetworkPerformanceMetricSubscription mocks base method.
-func (m *MockEC2API) DisableAwsNetworkPerformanceMetricSubscription(arg0 *ec2.DisableAwsNetworkPerformanceMetricSubscriptionInput) (*ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableAwsNetworkPerformanceMetricSubscription", arg0)
-	ret0, _ := ret[0].(*ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableAwsNetworkPerformanceMetricSubscription indicates an expected call of DisableAwsNetworkPerformanceMetricSubscription.
-func (mr *MockEC2APIMockRecorder) DisableAwsNetworkPerformanceMetricSubscription(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableAwsNetworkPerformanceMetricSubscription", reflect.TypeOf((*MockEC2API)(nil).DisableAwsNetworkPerformanceMetricSubscription), arg0)
-}
-
-// DisableAwsNetworkPerformanceMetricSubscriptionRequest mocks base method.
-func (m *MockEC2API) DisableAwsNetworkPerformanceMetricSubscriptionRequest(arg0 *ec2.DisableAwsNetworkPerformanceMetricSubscriptionInput) (*request.Request, *ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableAwsNetworkPerformanceMetricSubscriptionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput)
-	return ret0, ret1
-}
-
-// DisableAwsNetworkPerformanceMetricSubscriptionRequest indicates an expected call of DisableAwsNetworkPerformanceMetricSubscriptionRequest.
-func (mr *MockEC2APIMockRecorder) DisableAwsNetworkPerformanceMetricSubscriptionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableAwsNetworkPerformanceMetricSubscriptionRequest", reflect.TypeOf((*MockEC2API)(nil).DisableAwsNetworkPerformanceMetricSubscriptionRequest), arg0)
-}
-
-// DisableAwsNetworkPerformanceMetricSubscriptionWithContext mocks base method.
-func (m *MockEC2API) DisableAwsNetworkPerformanceMetricSubscriptionWithContext(arg0 context.Context, arg1 *ec2.DisableAwsNetworkPerformanceMetricSubscriptionInput, arg2 ...request.Option) (*ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisableAwsNetworkPerformanceMetricSubscriptionWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableAwsNetworkPerformanceMetricSubscriptionWithContext indicates an expected call of DisableAwsNetworkPerformanceMetricSubscriptionWithContext.
-func (mr *MockEC2APIMockRecorder) DisableAwsNetworkPerformanceMetricSubscriptionWithContext(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, "DisableAwsNetworkPerformanceMetricSubscriptionWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableAwsNetworkPerformanceMetricSubscriptionWithContext), varargs...)
-}
-
-// DisableEbsEncryptionByDefault mocks base method.
-func (m *MockEC2API) DisableEbsEncryptionByDefault(arg0 *ec2.DisableEbsEncryptionByDefaultInput) (*ec2.DisableEbsEncryptionByDefaultOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableEbsEncryptionByDefault", arg0)
-	ret0, _ := ret[0].(*ec2.DisableEbsEncryptionByDefaultOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableEbsEncryptionByDefault indicates an expected call of DisableEbsEncryptionByDefault.
-func (mr *MockEC2APIMockRecorder) DisableEbsEncryptionByDefault(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableEbsEncryptionByDefault", reflect.TypeOf((*MockEC2API)(nil).DisableEbsEncryptionByDefault), arg0)
-}
-
-// DisableEbsEncryptionByDefaultRequest mocks base method.
-func (m *MockEC2API) DisableEbsEncryptionByDefaultRequest(arg0 *ec2.DisableEbsEncryptionByDefaultInput) (*request.Request, *ec2.DisableEbsEncryptionByDefaultOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableEbsEncryptionByDefaultRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisableEbsEncryptionByDefaultOutput)
-	return ret0, ret1
-}
-
-// DisableEbsEncryptionByDefaultRequest indicates an expected call of DisableEbsEncryptionByDefaultRequest.
-func (mr *MockEC2APIMockRecorder) DisableEbsEncryptionByDefaultRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableEbsEncryptionByDefaultRequest", reflect.TypeOf((*MockEC2API)(nil).DisableEbsEncryptionByDefaultRequest), arg0)
-}
-
-// DisableEbsEncryptionByDefaultWithContext mocks base method.
-func (m *MockEC2API) DisableEbsEncryptionByDefaultWithContext(arg0 context.Context, arg1 *ec2.DisableEbsEncryptionByDefaultInput, arg2 ...request.Option) (*ec2.DisableEbsEncryptionByDefaultOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisableEbsEncryptionByDefaultWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisableEbsEncryptionByDefaultOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableEbsEncryptionByDefaultWithContext indicates an expected call of DisableEbsEncryptionByDefaultWithContext.
-func (mr *MockEC2APIMockRecorder) DisableEbsEncryptionByDefaultWithContext(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, "DisableEbsEncryptionByDefaultWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableEbsEncryptionByDefaultWithContext), varargs...)
-}
-
-// DisableFastLaunch mocks base method.
-func (m *MockEC2API) DisableFastLaunch(arg0 *ec2.DisableFastLaunchInput) (*ec2.DisableFastLaunchOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableFastLaunch", arg0)
-	ret0, _ := ret[0].(*ec2.DisableFastLaunchOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableFastLaunch indicates an expected call of DisableFastLaunch.
-func (mr *MockEC2APIMockRecorder) DisableFastLaunch(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableFastLaunch", reflect.TypeOf((*MockEC2API)(nil).DisableFastLaunch), arg0)
-}
-
-// DisableFastLaunchRequest mocks base method.
-func (m *MockEC2API) DisableFastLaunchRequest(arg0 *ec2.DisableFastLaunchInput) (*request.Request, *ec2.DisableFastLaunchOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableFastLaunchRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisableFastLaunchOutput)
-	return ret0, ret1
-}
-
-// DisableFastLaunchRequest indicates an expected call of DisableFastLaunchRequest.
-func (mr *MockEC2APIMockRecorder) DisableFastLaunchRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableFastLaunchRequest", reflect.TypeOf((*MockEC2API)(nil).DisableFastLaunchRequest), arg0)
-}
-
-// DisableFastLaunchWithContext mocks base method.
-func (m *MockEC2API) DisableFastLaunchWithContext(arg0 context.Context, arg1 *ec2.DisableFastLaunchInput, arg2 ...request.Option) (*ec2.DisableFastLaunchOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisableFastLaunchWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisableFastLaunchOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableFastLaunchWithContext indicates an expected call of DisableFastLaunchWithContext.
-func (mr *MockEC2APIMockRecorder) DisableFastLaunchWithContext(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, "DisableFastLaunchWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableFastLaunchWithContext), varargs...)
-}
-
-// DisableFastSnapshotRestores mocks base method.
-func (m *MockEC2API) DisableFastSnapshotRestores(arg0 *ec2.DisableFastSnapshotRestoresInput) (*ec2.DisableFastSnapshotRestoresOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableFastSnapshotRestores", arg0)
-	ret0, _ := ret[0].(*ec2.DisableFastSnapshotRestoresOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableFastSnapshotRestores indicates an expected call of DisableFastSnapshotRestores.
-func (mr *MockEC2APIMockRecorder) DisableFastSnapshotRestores(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableFastSnapshotRestores", reflect.TypeOf((*MockEC2API)(nil).DisableFastSnapshotRestores), arg0)
-}
-
-// DisableFastSnapshotRestoresRequest mocks base method.
-func (m *MockEC2API) DisableFastSnapshotRestoresRequest(arg0 *ec2.DisableFastSnapshotRestoresInput) (*request.Request, *ec2.DisableFastSnapshotRestoresOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableFastSnapshotRestoresRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisableFastSnapshotRestoresOutput)
-	return ret0, ret1
-}
-
-// DisableFastSnapshotRestoresRequest indicates an expected call of DisableFastSnapshotRestoresRequest.
-func (mr *MockEC2APIMockRecorder) DisableFastSnapshotRestoresRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableFastSnapshotRestoresRequest", reflect.TypeOf((*MockEC2API)(nil).DisableFastSnapshotRestoresRequest), arg0)
-}
-
-// DisableFastSnapshotRestoresWithContext mocks base method.
-func (m *MockEC2API) DisableFastSnapshotRestoresWithContext(arg0 context.Context, arg1 *ec2.DisableFastSnapshotRestoresInput, arg2 ...request.Option) (*ec2.DisableFastSnapshotRestoresOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisableFastSnapshotRestoresWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisableFastSnapshotRestoresOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableFastSnapshotRestoresWithContext indicates an expected call of DisableFastSnapshotRestoresWithContext.
-func (mr *MockEC2APIMockRecorder) DisableFastSnapshotRestoresWithContext(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, "DisableFastSnapshotRestoresWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableFastSnapshotRestoresWithContext), varargs...)
-}
-
-// DisableImage mocks base method.
-func (m *MockEC2API) DisableImage(arg0 *ec2.DisableImageInput) (*ec2.DisableImageOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableImage", arg0)
-	ret0, _ := ret[0].(*ec2.DisableImageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableImage indicates an expected call of DisableImage.
-func (mr *MockEC2APIMockRecorder) DisableImage(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImage", reflect.TypeOf((*MockEC2API)(nil).DisableImage), arg0)
-}
-
-// DisableImageBlockPublicAccess mocks base method.
-func (m *MockEC2API) DisableImageBlockPublicAccess(arg0 *ec2.DisableImageBlockPublicAccessInput) (*ec2.DisableImageBlockPublicAccessOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableImageBlockPublicAccess", arg0)
-	ret0, _ := ret[0].(*ec2.DisableImageBlockPublicAccessOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableImageBlockPublicAccess indicates an expected call of DisableImageBlockPublicAccess.
-func (mr *MockEC2APIMockRecorder) DisableImageBlockPublicAccess(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageBlockPublicAccess", reflect.TypeOf((*MockEC2API)(nil).DisableImageBlockPublicAccess), arg0)
-}
-
-// DisableImageBlockPublicAccessRequest mocks base method.
-func (m *MockEC2API) DisableImageBlockPublicAccessRequest(arg0 *ec2.DisableImageBlockPublicAccessInput) (*request.Request, *ec2.DisableImageBlockPublicAccessOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableImageBlockPublicAccessRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisableImageBlockPublicAccessOutput)
-	return ret0, ret1
-}
-
-// DisableImageBlockPublicAccessRequest indicates an expected call of DisableImageBlockPublicAccessRequest.
-func (mr *MockEC2APIMockRecorder) DisableImageBlockPublicAccessRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageBlockPublicAccessRequest", reflect.TypeOf((*MockEC2API)(nil).DisableImageBlockPublicAccessRequest), arg0)
-}
-
-// DisableImageBlockPublicAccessWithContext mocks base method.
-func (m *MockEC2API) DisableImageBlockPublicAccessWithContext(arg0 context.Context, arg1 *ec2.DisableImageBlockPublicAccessInput, arg2 ...request.Option) (*ec2.DisableImageBlockPublicAccessOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisableImageBlockPublicAccessWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisableImageBlockPublicAccessOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableImageBlockPublicAccessWithContext indicates an expected call of DisableImageBlockPublicAccessWithContext.
-func (mr *MockEC2APIMockRecorder) DisableImageBlockPublicAccessWithContext(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, "DisableImageBlockPublicAccessWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableImageBlockPublicAccessWithContext), varargs...)
-}
-
-// DisableImageDeprecation mocks base method.
-func (m *MockEC2API) DisableImageDeprecation(arg0 *ec2.DisableImageDeprecationInput) (*ec2.DisableImageDeprecationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableImageDeprecation", arg0)
-	ret0, _ := ret[0].(*ec2.DisableImageDeprecationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableImageDeprecation indicates an expected call of DisableImageDeprecation.
-func (mr *MockEC2APIMockRecorder) DisableImageDeprecation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageDeprecation", reflect.TypeOf((*MockEC2API)(nil).DisableImageDeprecation), arg0)
-}
-
-// DisableImageDeprecationRequest mocks base method.
-func (m *MockEC2API) DisableImageDeprecationRequest(arg0 *ec2.DisableImageDeprecationInput) (*request.Request, *ec2.DisableImageDeprecationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableImageDeprecationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisableImageDeprecationOutput)
-	return ret0, ret1
-}
-
-// DisableImageDeprecationRequest indicates an expected call of DisableImageDeprecationRequest.
-func (mr *MockEC2APIMockRecorder) DisableImageDeprecationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageDeprecationRequest", reflect.TypeOf((*MockEC2API)(nil).DisableImageDeprecationRequest), arg0)
-}
-
-// DisableImageDeprecationWithContext mocks base method.
-func (m *MockEC2API) DisableImageDeprecationWithContext(arg0 context.Context, arg1 *ec2.DisableImageDeprecationInput, arg2 ...request.Option) (*ec2.DisableImageDeprecationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisableImageDeprecationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisableImageDeprecationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableImageDeprecationWithContext indicates an expected call of DisableImageDeprecationWithContext.
-func (mr *MockEC2APIMockRecorder) DisableImageDeprecationWithContext(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, "DisableImageDeprecationWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableImageDeprecationWithContext), varargs...)
-}
-
-// DisableImageDeregistrationProtection mocks base method.
-func (m *MockEC2API) DisableImageDeregistrationProtection(arg0 *ec2.DisableImageDeregistrationProtectionInput) (*ec2.DisableImageDeregistrationProtectionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableImageDeregistrationProtection", arg0)
-	ret0, _ := ret[0].(*ec2.DisableImageDeregistrationProtectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableImageDeregistrationProtection indicates an expected call of DisableImageDeregistrationProtection.
-func (mr *MockEC2APIMockRecorder) DisableImageDeregistrationProtection(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageDeregistrationProtection", reflect.TypeOf((*MockEC2API)(nil).DisableImageDeregistrationProtection), arg0)
-}
-
-// DisableImageDeregistrationProtectionRequest mocks base method.
-func (m *MockEC2API) DisableImageDeregistrationProtectionRequest(arg0 *ec2.DisableImageDeregistrationProtectionInput) (*request.Request, *ec2.DisableImageDeregistrationProtectionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableImageDeregistrationProtectionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisableImageDeregistrationProtectionOutput)
-	return ret0, ret1
-}
-
-// DisableImageDeregistrationProtectionRequest indicates an expected call of DisableImageDeregistrationProtectionRequest.
-func (mr *MockEC2APIMockRecorder) DisableImageDeregistrationProtectionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageDeregistrationProtectionRequest", reflect.TypeOf((*MockEC2API)(nil).DisableImageDeregistrationProtectionRequest), arg0)
-}
-
-// DisableImageDeregistrationProtectionWithContext mocks base method.
-func (m *MockEC2API) DisableImageDeregistrationProtectionWithContext(arg0 context.Context, arg1 *ec2.DisableImageDeregistrationProtectionInput, arg2 ...request.Option) (*ec2.DisableImageDeregistrationProtectionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisableImageDeregistrationProtectionWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisableImageDeregistrationProtectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableImageDeregistrationProtectionWithContext indicates an expected call of DisableImageDeregistrationProtectionWithContext.
-func (mr *MockEC2APIMockRecorder) DisableImageDeregistrationProtectionWithContext(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, "DisableImageDeregistrationProtectionWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableImageDeregistrationProtectionWithContext), varargs...)
-}
-
-// DisableImageRequest mocks base method.
-func (m *MockEC2API) DisableImageRequest(arg0 *ec2.DisableImageInput) (*request.Request, *ec2.DisableImageOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableImageRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisableImageOutput)
-	return ret0, ret1
-}
-
-// DisableImageRequest indicates an expected call of DisableImageRequest.
-func (mr *MockEC2APIMockRecorder) DisableImageRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageRequest", reflect.TypeOf((*MockEC2API)(nil).DisableImageRequest), arg0)
-}
-
-// DisableImageWithContext mocks base method.
-func (m *MockEC2API) DisableImageWithContext(arg0 context.Context, arg1 *ec2.DisableImageInput, arg2 ...request.Option) (*ec2.DisableImageOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisableImageWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisableImageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableImageWithContext indicates an expected call of DisableImageWithContext.
-func (mr *MockEC2APIMockRecorder) DisableImageWithContext(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, "DisableImageWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableImageWithContext), varargs...)
-}
-
-// DisableIpamOrganizationAdminAccount mocks base method.
-func (m *MockEC2API) DisableIpamOrganizationAdminAccount(arg0 *ec2.DisableIpamOrganizationAdminAccountInput) (*ec2.DisableIpamOrganizationAdminAccountOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableIpamOrganizationAdminAccount", arg0)
-	ret0, _ := ret[0].(*ec2.DisableIpamOrganizationAdminAccountOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableIpamOrganizationAdminAccount indicates an expected call of DisableIpamOrganizationAdminAccount.
-func (mr *MockEC2APIMockRecorder) DisableIpamOrganizationAdminAccount(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableIpamOrganizationAdminAccount", reflect.TypeOf((*MockEC2API)(nil).DisableIpamOrganizationAdminAccount), arg0)
-}
-
-// DisableIpamOrganizationAdminAccountRequest mocks base method.
-func (m *MockEC2API) DisableIpamOrganizationAdminAccountRequest(arg0 *ec2.DisableIpamOrganizationAdminAccountInput) (*request.Request, *ec2.DisableIpamOrganizationAdminAccountOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableIpamOrganizationAdminAccountRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisableIpamOrganizationAdminAccountOutput)
-	return ret0, ret1
-}
-
-// DisableIpamOrganizationAdminAccountRequest indicates an expected call of DisableIpamOrganizationAdminAccountRequest.
-func (mr *MockEC2APIMockRecorder) DisableIpamOrganizationAdminAccountRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableIpamOrganizationAdminAccountRequest", reflect.TypeOf((*MockEC2API)(nil).DisableIpamOrganizationAdminAccountRequest), arg0)
-}
-
-// DisableIpamOrganizationAdminAccountWithContext mocks base method.
-func (m *MockEC2API) DisableIpamOrganizationAdminAccountWithContext(arg0 context.Context, arg1 *ec2.DisableIpamOrganizationAdminAccountInput, arg2 ...request.Option) (*ec2.DisableIpamOrganizationAdminAccountOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisableIpamOrganizationAdminAccountWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisableIpamOrganizationAdminAccountOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableIpamOrganizationAdminAccountWithContext indicates an expected call of DisableIpamOrganizationAdminAccountWithContext.
-func (mr *MockEC2APIMockRecorder) DisableIpamOrganizationAdminAccountWithContext(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, "DisableIpamOrganizationAdminAccountWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableIpamOrganizationAdminAccountWithContext), varargs...)
-}
-
-// DisableSerialConsoleAccess mocks base method.
-func (m *MockEC2API) DisableSerialConsoleAccess(arg0 *ec2.DisableSerialConsoleAccessInput) (*ec2.DisableSerialConsoleAccessOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableSerialConsoleAccess", arg0)
-	ret0, _ := ret[0].(*ec2.DisableSerialConsoleAccessOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableSerialConsoleAccess indicates an expected call of DisableSerialConsoleAccess.
-func (mr *MockEC2APIMockRecorder) DisableSerialConsoleAccess(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableSerialConsoleAccess", reflect.TypeOf((*MockEC2API)(nil).DisableSerialConsoleAccess), arg0)
-}
-
-// DisableSerialConsoleAccessRequest mocks base method.
-func (m *MockEC2API) DisableSerialConsoleAccessRequest(arg0 *ec2.DisableSerialConsoleAccessInput) (*request.Request, *ec2.DisableSerialConsoleAccessOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableSerialConsoleAccessRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisableSerialConsoleAccessOutput)
-	return ret0, ret1
-}
-
-// DisableSerialConsoleAccessRequest indicates an expected call of DisableSerialConsoleAccessRequest.
-func (mr *MockEC2APIMockRecorder) DisableSerialConsoleAccessRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableSerialConsoleAccessRequest", reflect.TypeOf((*MockEC2API)(nil).DisableSerialConsoleAccessRequest), arg0)
-}
-
-// DisableSerialConsoleAccessWithContext mocks base method.
-func (m *MockEC2API) DisableSerialConsoleAccessWithContext(arg0 context.Context, arg1 *ec2.DisableSerialConsoleAccessInput, arg2 ...request.Option) (*ec2.DisableSerialConsoleAccessOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisableSerialConsoleAccessWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisableSerialConsoleAccessOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableSerialConsoleAccessWithContext indicates an expected call of DisableSerialConsoleAccessWithContext.
-func (mr *MockEC2APIMockRecorder) DisableSerialConsoleAccessWithContext(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, "DisableSerialConsoleAccessWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableSerialConsoleAccessWithContext), varargs...)
-}
-
-// DisableSnapshotBlockPublicAccess mocks base method.
-func (m *MockEC2API) DisableSnapshotBlockPublicAccess(arg0 *ec2.DisableSnapshotBlockPublicAccessInput) (*ec2.DisableSnapshotBlockPublicAccessOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableSnapshotBlockPublicAccess", arg0)
-	ret0, _ := ret[0].(*ec2.DisableSnapshotBlockPublicAccessOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableSnapshotBlockPublicAccess indicates an expected call of DisableSnapshotBlockPublicAccess.
-func (mr *MockEC2APIMockRecorder) DisableSnapshotBlockPublicAccess(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableSnapshotBlockPublicAccess", reflect.TypeOf((*MockEC2API)(nil).DisableSnapshotBlockPublicAccess), arg0)
-}
-
-// DisableSnapshotBlockPublicAccessRequest mocks base method.
-func (m *MockEC2API) DisableSnapshotBlockPublicAccessRequest(arg0 *ec2.DisableSnapshotBlockPublicAccessInput) (*request.Request, *ec2.DisableSnapshotBlockPublicAccessOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableSnapshotBlockPublicAccessRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisableSnapshotBlockPublicAccessOutput)
-	return ret0, ret1
-}
-
-// DisableSnapshotBlockPublicAccessRequest indicates an expected call of DisableSnapshotBlockPublicAccessRequest.
-func (mr *MockEC2APIMockRecorder) DisableSnapshotBlockPublicAccessRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableSnapshotBlockPublicAccessRequest", reflect.TypeOf((*MockEC2API)(nil).DisableSnapshotBlockPublicAccessRequest), arg0)
-}
-
-// DisableSnapshotBlockPublicAccessWithContext mocks base method.
-func (m *MockEC2API) DisableSnapshotBlockPublicAccessWithContext(arg0 context.Context, arg1 *ec2.DisableSnapshotBlockPublicAccessInput, arg2 ...request.Option) (*ec2.DisableSnapshotBlockPublicAccessOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisableSnapshotBlockPublicAccessWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisableSnapshotBlockPublicAccessOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableSnapshotBlockPublicAccessWithContext indicates an expected call of DisableSnapshotBlockPublicAccessWithContext.
-func (mr *MockEC2APIMockRecorder) DisableSnapshotBlockPublicAccessWithContext(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, "DisableSnapshotBlockPublicAccessWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableSnapshotBlockPublicAccessWithContext), varargs...)
-}
-
-// DisableTransitGatewayRouteTablePropagation mocks base method.
-func (m *MockEC2API) DisableTransitGatewayRouteTablePropagation(arg0 *ec2.DisableTransitGatewayRouteTablePropagationInput) (*ec2.DisableTransitGatewayRouteTablePropagationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableTransitGatewayRouteTablePropagation", arg0)
-	ret0, _ := ret[0].(*ec2.DisableTransitGatewayRouteTablePropagationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableTransitGatewayRouteTablePropagation indicates an expected call of DisableTransitGatewayRouteTablePropagation.
-func (mr *MockEC2APIMockRecorder) DisableTransitGatewayRouteTablePropagation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableTransitGatewayRouteTablePropagation", reflect.TypeOf((*MockEC2API)(nil).DisableTransitGatewayRouteTablePropagation), arg0)
-}
-
-// DisableTransitGatewayRouteTablePropagationRequest mocks base method.
-func (m *MockEC2API) DisableTransitGatewayRouteTablePropagationRequest(arg0 *ec2.DisableTransitGatewayRouteTablePropagationInput) (*request.Request, *ec2.DisableTransitGatewayRouteTablePropagationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableTransitGatewayRouteTablePropagationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisableTransitGatewayRouteTablePropagationOutput)
-	return ret0, ret1
-}
-
-// DisableTransitGatewayRouteTablePropagationRequest indicates an expected call of DisableTransitGatewayRouteTablePropagationRequest.
-func (mr *MockEC2APIMockRecorder) DisableTransitGatewayRouteTablePropagationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableTransitGatewayRouteTablePropagationRequest", reflect.TypeOf((*MockEC2API)(nil).DisableTransitGatewayRouteTablePropagationRequest), arg0)
-}
-
-// DisableTransitGatewayRouteTablePropagationWithContext mocks base method.
-func (m *MockEC2API) DisableTransitGatewayRouteTablePropagationWithContext(arg0 context.Context, arg1 *ec2.DisableTransitGatewayRouteTablePropagationInput, arg2 ...request.Option) (*ec2.DisableTransitGatewayRouteTablePropagationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisableTransitGatewayRouteTablePropagationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisableTransitGatewayRouteTablePropagationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableTransitGatewayRouteTablePropagationWithContext indicates an expected call of DisableTransitGatewayRouteTablePropagationWithContext.
-func (mr *MockEC2APIMockRecorder) DisableTransitGatewayRouteTablePropagationWithContext(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, "DisableTransitGatewayRouteTablePropagationWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableTransitGatewayRouteTablePropagationWithContext), varargs...)
-}
-
-// DisableVgwRoutePropagation mocks base method.
-func (m *MockEC2API) DisableVgwRoutePropagation(arg0 *ec2.DisableVgwRoutePropagationInput) (*ec2.DisableVgwRoutePropagationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableVgwRoutePropagation", arg0)
-	ret0, _ := ret[0].(*ec2.DisableVgwRoutePropagationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableVgwRoutePropagation indicates an expected call of DisableVgwRoutePropagation.
-func (mr *MockEC2APIMockRecorder) DisableVgwRoutePropagation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVgwRoutePropagation", reflect.TypeOf((*MockEC2API)(nil).DisableVgwRoutePropagation), arg0)
-}
-
-// DisableVgwRoutePropagationRequest mocks base method.
-func (m *MockEC2API) DisableVgwRoutePropagationRequest(arg0 *ec2.DisableVgwRoutePropagationInput) (*request.Request, *ec2.DisableVgwRoutePropagationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableVgwRoutePropagationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisableVgwRoutePropagationOutput)
-	return ret0, ret1
-}
-
-// DisableVgwRoutePropagationRequest indicates an expected call of DisableVgwRoutePropagationRequest.
-func (mr *MockEC2APIMockRecorder) DisableVgwRoutePropagationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVgwRoutePropagationRequest", reflect.TypeOf((*MockEC2API)(nil).DisableVgwRoutePropagationRequest), arg0)
-}
-
-// DisableVgwRoutePropagationWithContext mocks base method.
-func (m *MockEC2API) DisableVgwRoutePropagationWithContext(arg0 context.Context, arg1 *ec2.DisableVgwRoutePropagationInput, arg2 ...request.Option) (*ec2.DisableVgwRoutePropagationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisableVgwRoutePropagationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisableVgwRoutePropagationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableVgwRoutePropagationWithContext indicates an expected call of DisableVgwRoutePropagationWithContext.
-func (mr *MockEC2APIMockRecorder) DisableVgwRoutePropagationWithContext(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, "DisableVgwRoutePropagationWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableVgwRoutePropagationWithContext), varargs...)
-}
-
-// DisableVpcClassicLink mocks base method.
-func (m *MockEC2API) DisableVpcClassicLink(arg0 *ec2.DisableVpcClassicLinkInput) (*ec2.DisableVpcClassicLinkOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableVpcClassicLink", arg0)
-	ret0, _ := ret[0].(*ec2.DisableVpcClassicLinkOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableVpcClassicLink indicates an expected call of DisableVpcClassicLink.
-func (mr *MockEC2APIMockRecorder) DisableVpcClassicLink(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLink", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLink), arg0)
-}
-
-// DisableVpcClassicLinkDnsSupport mocks base method.
-func (m *MockEC2API) DisableVpcClassicLinkDnsSupport(arg0 *ec2.DisableVpcClassicLinkDnsSupportInput) (*ec2.DisableVpcClassicLinkDnsSupportOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableVpcClassicLinkDnsSupport", arg0)
-	ret0, _ := ret[0].(*ec2.DisableVpcClassicLinkDnsSupportOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableVpcClassicLinkDnsSupport indicates an expected call of DisableVpcClassicLinkDnsSupport.
-func (mr *MockEC2APIMockRecorder) DisableVpcClassicLinkDnsSupport(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLinkDnsSupport", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLinkDnsSupport), arg0)
-}
-
-// DisableVpcClassicLinkDnsSupportRequest mocks base method.
-func (m *MockEC2API) DisableVpcClassicLinkDnsSupportRequest(arg0 *ec2.DisableVpcClassicLinkDnsSupportInput) (*request.Request, *ec2.DisableVpcClassicLinkDnsSupportOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableVpcClassicLinkDnsSupportRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisableVpcClassicLinkDnsSupportOutput)
-	return ret0, ret1
-}
-
-// DisableVpcClassicLinkDnsSupportRequest indicates an expected call of DisableVpcClassicLinkDnsSupportRequest.
-func (mr *MockEC2APIMockRecorder) DisableVpcClassicLinkDnsSupportRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLinkDnsSupportRequest", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLinkDnsSupportRequest), arg0)
-}
-
-// DisableVpcClassicLinkDnsSupportWithContext mocks base method.
-func (m *MockEC2API) DisableVpcClassicLinkDnsSupportWithContext(arg0 context.Context, arg1 *ec2.DisableVpcClassicLinkDnsSupportInput, arg2 ...request.Option) (*ec2.DisableVpcClassicLinkDnsSupportOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisableVpcClassicLinkDnsSupportWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisableVpcClassicLinkDnsSupportOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableVpcClassicLinkDnsSupportWithContext indicates an expected call of DisableVpcClassicLinkDnsSupportWithContext.
-func (mr *MockEC2APIMockRecorder) DisableVpcClassicLinkDnsSupportWithContext(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, "DisableVpcClassicLinkDnsSupportWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLinkDnsSupportWithContext), varargs...)
-}
-
-// DisableVpcClassicLinkRequest mocks base method.
-func (m *MockEC2API) DisableVpcClassicLinkRequest(arg0 *ec2.DisableVpcClassicLinkInput) (*request.Request, *ec2.DisableVpcClassicLinkOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableVpcClassicLinkRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisableVpcClassicLinkOutput)
-	return ret0, ret1
-}
-
-// DisableVpcClassicLinkRequest indicates an expected call of DisableVpcClassicLinkRequest.
-func (mr *MockEC2APIMockRecorder) DisableVpcClassicLinkRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLinkRequest", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLinkRequest), arg0)
-}
-
-// DisableVpcClassicLinkWithContext mocks base method.
-func (m *MockEC2API) DisableVpcClassicLinkWithContext(arg0 context.Context, arg1 *ec2.DisableVpcClassicLinkInput, arg2 ...request.Option) (*ec2.DisableVpcClassicLinkOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisableVpcClassicLinkWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisableVpcClassicLinkOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableVpcClassicLinkWithContext indicates an expected call of DisableVpcClassicLinkWithContext.
-func (mr *MockEC2APIMockRecorder) DisableVpcClassicLinkWithContext(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, "DisableVpcClassicLinkWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLinkWithContext), varargs...)
-}
-
-// DisassociateAddress mocks base method.
-func (m *MockEC2API) DisassociateAddress(arg0 *ec2.DisassociateAddressInput) (*ec2.DisassociateAddressOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateAddress", arg0)
-	ret0, _ := ret[0].(*ec2.DisassociateAddressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateAddress indicates an expected call of DisassociateAddress.
-func (mr *MockEC2APIMockRecorder) DisassociateAddress(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateAddress", reflect.TypeOf((*MockEC2API)(nil).DisassociateAddress), arg0)
-}
-
-// DisassociateAddressRequest mocks base method.
-func (m *MockEC2API) DisassociateAddressRequest(arg0 *ec2.DisassociateAddressInput) (*request.Request, *ec2.DisassociateAddressOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateAddressRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisassociateAddressOutput)
-	return ret0, ret1
-}
-
-// DisassociateAddressRequest indicates an expected call of DisassociateAddressRequest.
-func (mr *MockEC2APIMockRecorder) DisassociateAddressRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateAddressRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateAddressRequest), arg0)
-}
-
-// DisassociateAddressWithContext mocks base method.
-func (m *MockEC2API) DisassociateAddressWithContext(arg0 context.Context, arg1 *ec2.DisassociateAddressInput, arg2 ...request.Option) (*ec2.DisassociateAddressOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisassociateAddressWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisassociateAddressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateAddressWithContext indicates an expected call of DisassociateAddressWithContext.
-func (mr *MockEC2APIMockRecorder) DisassociateAddressWithContext(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, "DisassociateAddressWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateAddressWithContext), varargs...)
-}
-
-// DisassociateClientVpnTargetNetwork mocks base method.
-func (m *MockEC2API) DisassociateClientVpnTargetNetwork(arg0 *ec2.DisassociateClientVpnTargetNetworkInput) (*ec2.DisassociateClientVpnTargetNetworkOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateClientVpnTargetNetwork", arg0)
-	ret0, _ := ret[0].(*ec2.DisassociateClientVpnTargetNetworkOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateClientVpnTargetNetwork indicates an expected call of DisassociateClientVpnTargetNetwork.
-func (mr *MockEC2APIMockRecorder) DisassociateClientVpnTargetNetwork(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateClientVpnTargetNetwork", reflect.TypeOf((*MockEC2API)(nil).DisassociateClientVpnTargetNetwork), arg0)
-}
-
-// DisassociateClientVpnTargetNetworkRequest mocks base method.
-func (m *MockEC2API) DisassociateClientVpnTargetNetworkRequest(arg0 *ec2.DisassociateClientVpnTargetNetworkInput) (*request.Request, *ec2.DisassociateClientVpnTargetNetworkOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateClientVpnTargetNetworkRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisassociateClientVpnTargetNetworkOutput)
-	return ret0, ret1
-}
-
-// DisassociateClientVpnTargetNetworkRequest indicates an expected call of DisassociateClientVpnTargetNetworkRequest.
-func (mr *MockEC2APIMockRecorder) DisassociateClientVpnTargetNetworkRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateClientVpnTargetNetworkRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateClientVpnTargetNetworkRequest), arg0)
-}
-
-// DisassociateClientVpnTargetNetworkWithContext mocks base method.
-func (m *MockEC2API) DisassociateClientVpnTargetNetworkWithContext(arg0 context.Context, arg1 *ec2.DisassociateClientVpnTargetNetworkInput, arg2 ...request.Option) (*ec2.DisassociateClientVpnTargetNetworkOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisassociateClientVpnTargetNetworkWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisassociateClientVpnTargetNetworkOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateClientVpnTargetNetworkWithContext indicates an expected call of DisassociateClientVpnTargetNetworkWithContext.
-func (mr *MockEC2APIMockRecorder) DisassociateClientVpnTargetNetworkWithContext(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, "DisassociateClientVpnTargetNetworkWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateClientVpnTargetNetworkWithContext), varargs...)
-}
-
-// DisassociateEnclaveCertificateIamRole mocks base method.
-func (m *MockEC2API) DisassociateEnclaveCertificateIamRole(arg0 *ec2.DisassociateEnclaveCertificateIamRoleInput) (*ec2.DisassociateEnclaveCertificateIamRoleOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateEnclaveCertificateIamRole", arg0)
-	ret0, _ := ret[0].(*ec2.DisassociateEnclaveCertificateIamRoleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateEnclaveCertificateIamRole indicates an expected call of DisassociateEnclaveCertificateIamRole.
-func (mr *MockEC2APIMockRecorder) DisassociateEnclaveCertificateIamRole(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateEnclaveCertificateIamRole", reflect.TypeOf((*MockEC2API)(nil).DisassociateEnclaveCertificateIamRole), arg0)
-}
-
-// DisassociateEnclaveCertificateIamRoleRequest mocks base method.
-func (m *MockEC2API) DisassociateEnclaveCertificateIamRoleRequest(arg0 *ec2.DisassociateEnclaveCertificateIamRoleInput) (*request.Request, *ec2.DisassociateEnclaveCertificateIamRoleOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateEnclaveCertificateIamRoleRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisassociateEnclaveCertificateIamRoleOutput)
-	return ret0, ret1
-}
-
-// DisassociateEnclaveCertificateIamRoleRequest indicates an expected call of DisassociateEnclaveCertificateIamRoleRequest.
-func (mr *MockEC2APIMockRecorder) DisassociateEnclaveCertificateIamRoleRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateEnclaveCertificateIamRoleRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateEnclaveCertificateIamRoleRequest), arg0)
-}
-
-// DisassociateEnclaveCertificateIamRoleWithContext mocks base method.
-func (m *MockEC2API) DisassociateEnclaveCertificateIamRoleWithContext(arg0 context.Context, arg1 *ec2.DisassociateEnclaveCertificateIamRoleInput, arg2 ...request.Option) (*ec2.DisassociateEnclaveCertificateIamRoleOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisassociateEnclaveCertificateIamRoleWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisassociateEnclaveCertificateIamRoleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateEnclaveCertificateIamRoleWithContext indicates an expected call of DisassociateEnclaveCertificateIamRoleWithContext.
-func (mr *MockEC2APIMockRecorder) DisassociateEnclaveCertificateIamRoleWithContext(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, "DisassociateEnclaveCertificateIamRoleWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateEnclaveCertificateIamRoleWithContext), varargs...)
-}
-
-// DisassociateIamInstanceProfile mocks base method.
-func (m *MockEC2API) DisassociateIamInstanceProfile(arg0 *ec2.DisassociateIamInstanceProfileInput) (*ec2.DisassociateIamInstanceProfileOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateIamInstanceProfile", arg0)
-	ret0, _ := ret[0].(*ec2.DisassociateIamInstanceProfileOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateIamInstanceProfile indicates an expected call of DisassociateIamInstanceProfile.
-func (mr *MockEC2APIMockRecorder) DisassociateIamInstanceProfile(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIamInstanceProfile", reflect.TypeOf((*MockEC2API)(nil).DisassociateIamInstanceProfile), arg0)
-}
-
-// DisassociateIamInstanceProfileRequest mocks base method.
-func (m *MockEC2API) DisassociateIamInstanceProfileRequest(arg0 *ec2.DisassociateIamInstanceProfileInput) (*request.Request, *ec2.DisassociateIamInstanceProfileOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateIamInstanceProfileRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisassociateIamInstanceProfileOutput)
-	return ret0, ret1
-}
-
-// DisassociateIamInstanceProfileRequest indicates an expected call of DisassociateIamInstanceProfileRequest.
-func (mr *MockEC2APIMockRecorder) DisassociateIamInstanceProfileRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIamInstanceProfileRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateIamInstanceProfileRequest), arg0)
-}
-
-// DisassociateIamInstanceProfileWithContext mocks base method.
-func (m *MockEC2API) DisassociateIamInstanceProfileWithContext(arg0 context.Context, arg1 *ec2.DisassociateIamInstanceProfileInput, arg2 ...request.Option) (*ec2.DisassociateIamInstanceProfileOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisassociateIamInstanceProfileWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisassociateIamInstanceProfileOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateIamInstanceProfileWithContext indicates an expected call of DisassociateIamInstanceProfileWithContext.
-func (mr *MockEC2APIMockRecorder) DisassociateIamInstanceProfileWithContext(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, "DisassociateIamInstanceProfileWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateIamInstanceProfileWithContext), varargs...)
-}
-
-// DisassociateInstanceEventWindow mocks base method.
-func (m *MockEC2API) DisassociateInstanceEventWindow(arg0 *ec2.DisassociateInstanceEventWindowInput) (*ec2.DisassociateInstanceEventWindowOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateInstanceEventWindow", arg0)
-	ret0, _ := ret[0].(*ec2.DisassociateInstanceEventWindowOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateInstanceEventWindow indicates an expected call of DisassociateInstanceEventWindow.
-func (mr *MockEC2APIMockRecorder) DisassociateInstanceEventWindow(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateInstanceEventWindow", reflect.TypeOf((*MockEC2API)(nil).DisassociateInstanceEventWindow), arg0)
-}
-
-// DisassociateInstanceEventWindowRequest mocks base method.
-func (m *MockEC2API) DisassociateInstanceEventWindowRequest(arg0 *ec2.DisassociateInstanceEventWindowInput) (*request.Request, *ec2.DisassociateInstanceEventWindowOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateInstanceEventWindowRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisassociateInstanceEventWindowOutput)
-	return ret0, ret1
-}
-
-// DisassociateInstanceEventWindowRequest indicates an expected call of DisassociateInstanceEventWindowRequest.
-func (mr *MockEC2APIMockRecorder) DisassociateInstanceEventWindowRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateInstanceEventWindowRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateInstanceEventWindowRequest), arg0)
-}
-
-// DisassociateInstanceEventWindowWithContext mocks base method.
-func (m *MockEC2API) DisassociateInstanceEventWindowWithContext(arg0 context.Context, arg1 *ec2.DisassociateInstanceEventWindowInput, arg2 ...request.Option) (*ec2.DisassociateInstanceEventWindowOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisassociateInstanceEventWindowWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisassociateInstanceEventWindowOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateInstanceEventWindowWithContext indicates an expected call of DisassociateInstanceEventWindowWithContext.
-func (mr *MockEC2APIMockRecorder) DisassociateInstanceEventWindowWithContext(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, "DisassociateInstanceEventWindowWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateInstanceEventWindowWithContext), varargs...)
-}
-
-// DisassociateIpamByoasn mocks base method.
-func (m *MockEC2API) DisassociateIpamByoasn(arg0 *ec2.DisassociateIpamByoasnInput) (*ec2.DisassociateIpamByoasnOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateIpamByoasn", arg0)
-	ret0, _ := ret[0].(*ec2.DisassociateIpamByoasnOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateIpamByoasn indicates an expected call of DisassociateIpamByoasn.
-func (mr *MockEC2APIMockRecorder) DisassociateIpamByoasn(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIpamByoasn", reflect.TypeOf((*MockEC2API)(nil).DisassociateIpamByoasn), arg0)
-}
-
-// DisassociateIpamByoasnRequest mocks base method.
-func (m *MockEC2API) DisassociateIpamByoasnRequest(arg0 *ec2.DisassociateIpamByoasnInput) (*request.Request, *ec2.DisassociateIpamByoasnOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateIpamByoasnRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisassociateIpamByoasnOutput)
-	return ret0, ret1
-}
-
-// DisassociateIpamByoasnRequest indicates an expected call of DisassociateIpamByoasnRequest.
-func (mr *MockEC2APIMockRecorder) DisassociateIpamByoasnRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIpamByoasnRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateIpamByoasnRequest), arg0)
-}
-
-// DisassociateIpamByoasnWithContext mocks base method.
-func (m *MockEC2API) DisassociateIpamByoasnWithContext(arg0 context.Context, arg1 *ec2.DisassociateIpamByoasnInput, arg2 ...request.Option) (*ec2.DisassociateIpamByoasnOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisassociateIpamByoasnWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisassociateIpamByoasnOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateIpamByoasnWithContext indicates an expected call of DisassociateIpamByoasnWithContext.
-func (mr *MockEC2APIMockRecorder) DisassociateIpamByoasnWithContext(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, "DisassociateIpamByoasnWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateIpamByoasnWithContext), varargs...)
-}
-
-// DisassociateIpamResourceDiscovery mocks base method.
-func (m *MockEC2API) DisassociateIpamResourceDiscovery(arg0 *ec2.DisassociateIpamResourceDiscoveryInput) (*ec2.DisassociateIpamResourceDiscoveryOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateIpamResourceDiscovery", arg0)
-	ret0, _ := ret[0].(*ec2.DisassociateIpamResourceDiscoveryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateIpamResourceDiscovery indicates an expected call of DisassociateIpamResourceDiscovery.
-func (mr *MockEC2APIMockRecorder) DisassociateIpamResourceDiscovery(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIpamResourceDiscovery", reflect.TypeOf((*MockEC2API)(nil).DisassociateIpamResourceDiscovery), arg0)
-}
-
-// DisassociateIpamResourceDiscoveryRequest mocks base method.
-func (m *MockEC2API) DisassociateIpamResourceDiscoveryRequest(arg0 *ec2.DisassociateIpamResourceDiscoveryInput) (*request.Request, *ec2.DisassociateIpamResourceDiscoveryOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateIpamResourceDiscoveryRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisassociateIpamResourceDiscoveryOutput)
-	return ret0, ret1
-}
-
-// DisassociateIpamResourceDiscoveryRequest indicates an expected call of DisassociateIpamResourceDiscoveryRequest.
-func (mr *MockEC2APIMockRecorder) DisassociateIpamResourceDiscoveryRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIpamResourceDiscoveryRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateIpamResourceDiscoveryRequest), arg0)
-}
-
-// DisassociateIpamResourceDiscoveryWithContext mocks base method.
-func (m *MockEC2API) DisassociateIpamResourceDiscoveryWithContext(arg0 context.Context, arg1 *ec2.DisassociateIpamResourceDiscoveryInput, arg2 ...request.Option) (*ec2.DisassociateIpamResourceDiscoveryOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisassociateIpamResourceDiscoveryWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisassociateIpamResourceDiscoveryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateIpamResourceDiscoveryWithContext indicates an expected call of DisassociateIpamResourceDiscoveryWithContext.
-func (mr *MockEC2APIMockRecorder) DisassociateIpamResourceDiscoveryWithContext(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, "DisassociateIpamResourceDiscoveryWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateIpamResourceDiscoveryWithContext), varargs...)
-}
-
-// DisassociateNatGatewayAddress mocks base method.
-func (m *MockEC2API) DisassociateNatGatewayAddress(arg0 *ec2.DisassociateNatGatewayAddressInput) (*ec2.DisassociateNatGatewayAddressOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateNatGatewayAddress", arg0)
-	ret0, _ := ret[0].(*ec2.DisassociateNatGatewayAddressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateNatGatewayAddress indicates an expected call of DisassociateNatGatewayAddress.
-func (mr *MockEC2APIMockRecorder) DisassociateNatGatewayAddress(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateNatGatewayAddress", reflect.TypeOf((*MockEC2API)(nil).DisassociateNatGatewayAddress), arg0)
-}
-
-// DisassociateNatGatewayAddressRequest mocks base method.
-func (m *MockEC2API) DisassociateNatGatewayAddressRequest(arg0 *ec2.DisassociateNatGatewayAddressInput) (*request.Request, *ec2.DisassociateNatGatewayAddressOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateNatGatewayAddressRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisassociateNatGatewayAddressOutput)
-	return ret0, ret1
-}
-
-// DisassociateNatGatewayAddressRequest indicates an expected call of DisassociateNatGatewayAddressRequest.
-func (mr *MockEC2APIMockRecorder) DisassociateNatGatewayAddressRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateNatGatewayAddressRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateNatGatewayAddressRequest), arg0)
-}
-
-// DisassociateNatGatewayAddressWithContext mocks base method.
-func (m *MockEC2API) DisassociateNatGatewayAddressWithContext(arg0 context.Context, arg1 *ec2.DisassociateNatGatewayAddressInput, arg2 ...request.Option) (*ec2.DisassociateNatGatewayAddressOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisassociateNatGatewayAddressWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisassociateNatGatewayAddressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateNatGatewayAddressWithContext indicates an expected call of DisassociateNatGatewayAddressWithContext.
-func (mr *MockEC2APIMockRecorder) DisassociateNatGatewayAddressWithContext(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, "DisassociateNatGatewayAddressWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateNatGatewayAddressWithContext), varargs...)
-}
-
-// DisassociateRouteTable mocks base method.
-func (m *MockEC2API) DisassociateRouteTable(arg0 *ec2.DisassociateRouteTableInput) (*ec2.DisassociateRouteTableOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateRouteTable", arg0)
-	ret0, _ := ret[0].(*ec2.DisassociateRouteTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateRouteTable indicates an expected call of DisassociateRouteTable.
-func (mr *MockEC2APIMockRecorder) DisassociateRouteTable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateRouteTable", reflect.TypeOf((*MockEC2API)(nil).DisassociateRouteTable), arg0)
-}
-
-// DisassociateRouteTableRequest mocks base method.
-func (m *MockEC2API) DisassociateRouteTableRequest(arg0 *ec2.DisassociateRouteTableInput) (*request.Request, *ec2.DisassociateRouteTableOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateRouteTableRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisassociateRouteTableOutput)
-	return ret0, ret1
-}
-
-// DisassociateRouteTableRequest indicates an expected call of DisassociateRouteTableRequest.
-func (mr *MockEC2APIMockRecorder) DisassociateRouteTableRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateRouteTableRequest), arg0)
-}
-
-// DisassociateRouteTableWithContext mocks base method.
-func (m *MockEC2API) DisassociateRouteTableWithContext(arg0 context.Context, arg1 *ec2.DisassociateRouteTableInput, arg2 ...request.Option) (*ec2.DisassociateRouteTableOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisassociateRouteTableWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisassociateRouteTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateRouteTableWithContext indicates an expected call of DisassociateRouteTableWithContext.
-func (mr *MockEC2APIMockRecorder) DisassociateRouteTableWithContext(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, "DisassociateRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateRouteTableWithContext), varargs...)
-}
-
-// DisassociateSubnetCidrBlock mocks base method.
-func (m *MockEC2API) DisassociateSubnetCidrBlock(arg0 *ec2.DisassociateSubnetCidrBlockInput) (*ec2.DisassociateSubnetCidrBlockOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateSubnetCidrBlock", arg0)
-	ret0, _ := ret[0].(*ec2.DisassociateSubnetCidrBlockOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateSubnetCidrBlock indicates an expected call of DisassociateSubnetCidrBlock.
-func (mr *MockEC2APIMockRecorder) DisassociateSubnetCidrBlock(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateSubnetCidrBlock", reflect.TypeOf((*MockEC2API)(nil).DisassociateSubnetCidrBlock), arg0)
-}
-
-// DisassociateSubnetCidrBlockRequest mocks base method.
-func (m *MockEC2API) DisassociateSubnetCidrBlockRequest(arg0 *ec2.DisassociateSubnetCidrBlockInput) (*request.Request, *ec2.DisassociateSubnetCidrBlockOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateSubnetCidrBlockRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisassociateSubnetCidrBlockOutput)
-	return ret0, ret1
-}
-
-// DisassociateSubnetCidrBlockRequest indicates an expected call of DisassociateSubnetCidrBlockRequest.
-func (mr *MockEC2APIMockRecorder) DisassociateSubnetCidrBlockRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateSubnetCidrBlockRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateSubnetCidrBlockRequest), arg0)
-}
-
-// DisassociateSubnetCidrBlockWithContext mocks base method.
-func (m *MockEC2API) DisassociateSubnetCidrBlockWithContext(arg0 context.Context, arg1 *ec2.DisassociateSubnetCidrBlockInput, arg2 ...request.Option) (*ec2.DisassociateSubnetCidrBlockOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisassociateSubnetCidrBlockWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisassociateSubnetCidrBlockOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateSubnetCidrBlockWithContext indicates an expected call of DisassociateSubnetCidrBlockWithContext.
-func (mr *MockEC2APIMockRecorder) DisassociateSubnetCidrBlockWithContext(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, "DisassociateSubnetCidrBlockWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateSubnetCidrBlockWithContext), varargs...)
-}
-
-// DisassociateTransitGatewayMulticastDomain mocks base method.
-func (m *MockEC2API) DisassociateTransitGatewayMulticastDomain(arg0 *ec2.DisassociateTransitGatewayMulticastDomainInput) (*ec2.DisassociateTransitGatewayMulticastDomainOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateTransitGatewayMulticastDomain", arg0)
-	ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayMulticastDomainOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateTransitGatewayMulticastDomain indicates an expected call of DisassociateTransitGatewayMulticastDomain.
-func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayMulticastDomain(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayMulticastDomain", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayMulticastDomain), arg0)
-}
-
-// DisassociateTransitGatewayMulticastDomainRequest mocks base method.
-func (m *MockEC2API) DisassociateTransitGatewayMulticastDomainRequest(arg0 *ec2.DisassociateTransitGatewayMulticastDomainInput) (*request.Request, *ec2.DisassociateTransitGatewayMulticastDomainOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateTransitGatewayMulticastDomainRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisassociateTransitGatewayMulticastDomainOutput)
-	return ret0, ret1
-}
-
-// DisassociateTransitGatewayMulticastDomainRequest indicates an expected call of DisassociateTransitGatewayMulticastDomainRequest.
-func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayMulticastDomainRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayMulticastDomainRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayMulticastDomainRequest), arg0)
-}
-
-// DisassociateTransitGatewayMulticastDomainWithContext mocks base method.
-func (m *MockEC2API) DisassociateTransitGatewayMulticastDomainWithContext(arg0 context.Context, arg1 *ec2.DisassociateTransitGatewayMulticastDomainInput, arg2 ...request.Option) (*ec2.DisassociateTransitGatewayMulticastDomainOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisassociateTransitGatewayMulticastDomainWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayMulticastDomainOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateTransitGatewayMulticastDomainWithContext indicates an expected call of DisassociateTransitGatewayMulticastDomainWithContext.
-func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayMulticastDomainWithContext(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, "DisassociateTransitGatewayMulticastDomainWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayMulticastDomainWithContext), varargs...)
-}
-
-// DisassociateTransitGatewayPolicyTable mocks base method.
-func (m *MockEC2API) DisassociateTransitGatewayPolicyTable(arg0 *ec2.DisassociateTransitGatewayPolicyTableInput) (*ec2.DisassociateTransitGatewayPolicyTableOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateTransitGatewayPolicyTable", arg0)
-	ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayPolicyTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateTransitGatewayPolicyTable indicates an expected call of DisassociateTransitGatewayPolicyTable.
-func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayPolicyTable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayPolicyTable", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayPolicyTable), arg0)
-}
-
-// DisassociateTransitGatewayPolicyTableRequest mocks base method.
-func (m *MockEC2API) DisassociateTransitGatewayPolicyTableRequest(arg0 *ec2.DisassociateTransitGatewayPolicyTableInput) (*request.Request, *ec2.DisassociateTransitGatewayPolicyTableOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateTransitGatewayPolicyTableRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisassociateTransitGatewayPolicyTableOutput)
-	return ret0, ret1
-}
-
-// DisassociateTransitGatewayPolicyTableRequest indicates an expected call of DisassociateTransitGatewayPolicyTableRequest.
-func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayPolicyTableRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayPolicyTableRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayPolicyTableRequest), arg0)
-}
-
-// DisassociateTransitGatewayPolicyTableWithContext mocks base method.
-func (m *MockEC2API) DisassociateTransitGatewayPolicyTableWithContext(arg0 context.Context, arg1 *ec2.DisassociateTransitGatewayPolicyTableInput, arg2 ...request.Option) (*ec2.DisassociateTransitGatewayPolicyTableOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisassociateTransitGatewayPolicyTableWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayPolicyTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateTransitGatewayPolicyTableWithContext indicates an expected call of DisassociateTransitGatewayPolicyTableWithContext.
-func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayPolicyTableWithContext(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, "DisassociateTransitGatewayPolicyTableWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayPolicyTableWithContext), varargs...)
-}
-
-// DisassociateTransitGatewayRouteTable mocks base method.
-func (m *MockEC2API) DisassociateTransitGatewayRouteTable(arg0 *ec2.DisassociateTransitGatewayRouteTableInput) (*ec2.DisassociateTransitGatewayRouteTableOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateTransitGatewayRouteTable", arg0)
-	ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayRouteTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateTransitGatewayRouteTable indicates an expected call of DisassociateTransitGatewayRouteTable.
-func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayRouteTable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayRouteTable), arg0)
-}
-
-// DisassociateTransitGatewayRouteTableRequest mocks base method.
-func (m *MockEC2API) DisassociateTransitGatewayRouteTableRequest(arg0 *ec2.DisassociateTransitGatewayRouteTableInput) (*request.Request, *ec2.DisassociateTransitGatewayRouteTableOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateTransitGatewayRouteTableRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisassociateTransitGatewayRouteTableOutput)
-	return ret0, ret1
-}
-
-// DisassociateTransitGatewayRouteTableRequest indicates an expected call of DisassociateTransitGatewayRouteTableRequest.
-func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayRouteTableRequest), arg0)
-}
-
-// DisassociateTransitGatewayRouteTableWithContext mocks base method.
-func (m *MockEC2API) DisassociateTransitGatewayRouteTableWithContext(arg0 context.Context, arg1 *ec2.DisassociateTransitGatewayRouteTableInput, arg2 ...request.Option) (*ec2.DisassociateTransitGatewayRouteTableOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisassociateTransitGatewayRouteTableWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayRouteTableOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateTransitGatewayRouteTableWithContext indicates an expected call of DisassociateTransitGatewayRouteTableWithContext.
-func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayRouteTableWithContext(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, "DisassociateTransitGatewayRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayRouteTableWithContext), varargs...)
-}
-
-// DisassociateTrunkInterface mocks base method.
-func (m *MockEC2API) DisassociateTrunkInterface(arg0 *ec2.DisassociateTrunkInterfaceInput) (*ec2.DisassociateTrunkInterfaceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateTrunkInterface", arg0)
-	ret0, _ := ret[0].(*ec2.DisassociateTrunkInterfaceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateTrunkInterface indicates an expected call of DisassociateTrunkInterface.
-func (mr *MockEC2APIMockRecorder) DisassociateTrunkInterface(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTrunkInterface", reflect.TypeOf((*MockEC2API)(nil).DisassociateTrunkInterface), arg0)
-}
-
-// DisassociateTrunkInterfaceRequest mocks base method.
-func (m *MockEC2API) DisassociateTrunkInterfaceRequest(arg0 *ec2.DisassociateTrunkInterfaceInput) (*request.Request, *ec2.DisassociateTrunkInterfaceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateTrunkInterfaceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisassociateTrunkInterfaceOutput)
-	return ret0, ret1
-}
-
-// DisassociateTrunkInterfaceRequest indicates an expected call of DisassociateTrunkInterfaceRequest.
-func (mr *MockEC2APIMockRecorder) DisassociateTrunkInterfaceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTrunkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateTrunkInterfaceRequest), arg0)
-}
-
-// DisassociateTrunkInterfaceWithContext mocks base method.
-func (m *MockEC2API) DisassociateTrunkInterfaceWithContext(arg0 context.Context, arg1 *ec2.DisassociateTrunkInterfaceInput, arg2 ...request.Option) (*ec2.DisassociateTrunkInterfaceOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisassociateTrunkInterfaceWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisassociateTrunkInterfaceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateTrunkInterfaceWithContext indicates an expected call of DisassociateTrunkInterfaceWithContext.
-func (mr *MockEC2APIMockRecorder) DisassociateTrunkInterfaceWithContext(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, "DisassociateTrunkInterfaceWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateTrunkInterfaceWithContext), varargs...)
-}
-
-// DisassociateVpcCidrBlock mocks base method.
-func (m *MockEC2API) DisassociateVpcCidrBlock(arg0 *ec2.DisassociateVpcCidrBlockInput) (*ec2.DisassociateVpcCidrBlockOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateVpcCidrBlock", arg0)
-	ret0, _ := ret[0].(*ec2.DisassociateVpcCidrBlockOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateVpcCidrBlock indicates an expected call of DisassociateVpcCidrBlock.
-func (mr *MockEC2APIMockRecorder) DisassociateVpcCidrBlock(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVpcCidrBlock", reflect.TypeOf((*MockEC2API)(nil).DisassociateVpcCidrBlock), arg0)
-}
-
-// DisassociateVpcCidrBlockRequest mocks base method.
-func (m *MockEC2API) DisassociateVpcCidrBlockRequest(arg0 *ec2.DisassociateVpcCidrBlockInput) (*request.Request, *ec2.DisassociateVpcCidrBlockOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisassociateVpcCidrBlockRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.DisassociateVpcCidrBlockOutput)
-	return ret0, ret1
-}
-
-// DisassociateVpcCidrBlockRequest indicates an expected call of DisassociateVpcCidrBlockRequest.
-func (mr *MockEC2APIMockRecorder) DisassociateVpcCidrBlockRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVpcCidrBlockRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateVpcCidrBlockRequest), arg0)
-}
-
-// DisassociateVpcCidrBlockWithContext mocks base method.
-func (m *MockEC2API) DisassociateVpcCidrBlockWithContext(arg0 context.Context, arg1 *ec2.DisassociateVpcCidrBlockInput, arg2 ...request.Option) (*ec2.DisassociateVpcCidrBlockOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisassociateVpcCidrBlockWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.DisassociateVpcCidrBlockOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisassociateVpcCidrBlockWithContext indicates an expected call of DisassociateVpcCidrBlockWithContext.
-func (mr *MockEC2APIMockRecorder) DisassociateVpcCidrBlockWithContext(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, "DisassociateVpcCidrBlockWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateVpcCidrBlockWithContext), varargs...)
-}
-
-// EnableAddressTransfer mocks base method.
-func (m *MockEC2API) EnableAddressTransfer(arg0 *ec2.EnableAddressTransferInput) (*ec2.EnableAddressTransferOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableAddressTransfer", arg0)
-	ret0, _ := ret[0].(*ec2.EnableAddressTransferOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableAddressTransfer indicates an expected call of EnableAddressTransfer.
-func (mr *MockEC2APIMockRecorder) EnableAddressTransfer(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableAddressTransfer", reflect.TypeOf((*MockEC2API)(nil).EnableAddressTransfer), arg0)
-}
-
-// EnableAddressTransferRequest mocks base method.
-func (m *MockEC2API) EnableAddressTransferRequest(arg0 *ec2.EnableAddressTransferInput) (*request.Request, *ec2.EnableAddressTransferOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableAddressTransferRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.EnableAddressTransferOutput)
-	return ret0, ret1
-}
-
-// EnableAddressTransferRequest indicates an expected call of EnableAddressTransferRequest.
-func (mr *MockEC2APIMockRecorder) EnableAddressTransferRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableAddressTransferRequest", reflect.TypeOf((*MockEC2API)(nil).EnableAddressTransferRequest), arg0)
-}
-
-// EnableAddressTransferWithContext mocks base method.
-func (m *MockEC2API) EnableAddressTransferWithContext(arg0 context.Context, arg1 *ec2.EnableAddressTransferInput, arg2 ...request.Option) (*ec2.EnableAddressTransferOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EnableAddressTransferWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.EnableAddressTransferOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableAddressTransferWithContext indicates an expected call of EnableAddressTransferWithContext.
-func (mr *MockEC2APIMockRecorder) EnableAddressTransferWithContext(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, "EnableAddressTransferWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableAddressTransferWithContext), varargs...)
-}
-
-// EnableAwsNetworkPerformanceMetricSubscription mocks base method.
-func (m *MockEC2API) EnableAwsNetworkPerformanceMetricSubscription(arg0 *ec2.EnableAwsNetworkPerformanceMetricSubscriptionInput) (*ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableAwsNetworkPerformanceMetricSubscription", arg0)
-	ret0, _ := ret[0].(*ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableAwsNetworkPerformanceMetricSubscription indicates an expected call of EnableAwsNetworkPerformanceMetricSubscription.
-func (mr *MockEC2APIMockRecorder) EnableAwsNetworkPerformanceMetricSubscription(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableAwsNetworkPerformanceMetricSubscription", reflect.TypeOf((*MockEC2API)(nil).EnableAwsNetworkPerformanceMetricSubscription), arg0)
-}
-
-// EnableAwsNetworkPerformanceMetricSubscriptionRequest mocks base method.
-func (m *MockEC2API) EnableAwsNetworkPerformanceMetricSubscriptionRequest(arg0 *ec2.EnableAwsNetworkPerformanceMetricSubscriptionInput) (*request.Request, *ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableAwsNetworkPerformanceMetricSubscriptionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput)
-	return ret0, ret1
-}
-
-// EnableAwsNetworkPerformanceMetricSubscriptionRequest indicates an expected call of EnableAwsNetworkPerformanceMetricSubscriptionRequest.
-func (mr *MockEC2APIMockRecorder) EnableAwsNetworkPerformanceMetricSubscriptionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableAwsNetworkPerformanceMetricSubscriptionRequest", reflect.TypeOf((*MockEC2API)(nil).EnableAwsNetworkPerformanceMetricSubscriptionRequest), arg0)
-}
-
-// EnableAwsNetworkPerformanceMetricSubscriptionWithContext mocks base method.
-func (m *MockEC2API) EnableAwsNetworkPerformanceMetricSubscriptionWithContext(arg0 context.Context, arg1 *ec2.EnableAwsNetworkPerformanceMetricSubscriptionInput, arg2 ...request.Option) (*ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EnableAwsNetworkPerformanceMetricSubscriptionWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableAwsNetworkPerformanceMetricSubscriptionWithContext indicates an expected call of EnableAwsNetworkPerformanceMetricSubscriptionWithContext.
-func (mr *MockEC2APIMockRecorder) EnableAwsNetworkPerformanceMetricSubscriptionWithContext(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, "EnableAwsNetworkPerformanceMetricSubscriptionWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableAwsNetworkPerformanceMetricSubscriptionWithContext), varargs...)
-}
-
-// EnableEbsEncryptionByDefault mocks base method.
-func (m *MockEC2API) EnableEbsEncryptionByDefault(arg0 *ec2.EnableEbsEncryptionByDefaultInput) (*ec2.EnableEbsEncryptionByDefaultOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableEbsEncryptionByDefault", arg0)
-	ret0, _ := ret[0].(*ec2.EnableEbsEncryptionByDefaultOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableEbsEncryptionByDefault indicates an expected call of EnableEbsEncryptionByDefault.
-func (mr *MockEC2APIMockRecorder) EnableEbsEncryptionByDefault(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEbsEncryptionByDefault", reflect.TypeOf((*MockEC2API)(nil).EnableEbsEncryptionByDefault), arg0)
-}
-
-// EnableEbsEncryptionByDefaultRequest mocks base method.
-func (m *MockEC2API) EnableEbsEncryptionByDefaultRequest(arg0 *ec2.EnableEbsEncryptionByDefaultInput) (*request.Request, *ec2.EnableEbsEncryptionByDefaultOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableEbsEncryptionByDefaultRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.EnableEbsEncryptionByDefaultOutput)
-	return ret0, ret1
-}
-
-// EnableEbsEncryptionByDefaultRequest indicates an expected call of EnableEbsEncryptionByDefaultRequest.
-func (mr *MockEC2APIMockRecorder) EnableEbsEncryptionByDefaultRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEbsEncryptionByDefaultRequest", reflect.TypeOf((*MockEC2API)(nil).EnableEbsEncryptionByDefaultRequest), arg0)
-}
-
-// EnableEbsEncryptionByDefaultWithContext mocks base method.
-func (m *MockEC2API) EnableEbsEncryptionByDefaultWithContext(arg0 context.Context, arg1 *ec2.EnableEbsEncryptionByDefaultInput, arg2 ...request.Option) (*ec2.EnableEbsEncryptionByDefaultOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EnableEbsEncryptionByDefaultWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.EnableEbsEncryptionByDefaultOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableEbsEncryptionByDefaultWithContext indicates an expected call of EnableEbsEncryptionByDefaultWithContext.
-func (mr *MockEC2APIMockRecorder) EnableEbsEncryptionByDefaultWithContext(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, "EnableEbsEncryptionByDefaultWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableEbsEncryptionByDefaultWithContext), varargs...)
-}
-
-// EnableFastLaunch mocks base method.
-func (m *MockEC2API) EnableFastLaunch(arg0 *ec2.EnableFastLaunchInput) (*ec2.EnableFastLaunchOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableFastLaunch", arg0)
-	ret0, _ := ret[0].(*ec2.EnableFastLaunchOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableFastLaunch indicates an expected call of EnableFastLaunch.
-func (mr *MockEC2APIMockRecorder) EnableFastLaunch(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastLaunch", reflect.TypeOf((*MockEC2API)(nil).EnableFastLaunch), arg0)
-}
-
-// EnableFastLaunchRequest mocks base method.
-func (m *MockEC2API) EnableFastLaunchRequest(arg0 *ec2.EnableFastLaunchInput) (*request.Request, *ec2.EnableFastLaunchOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableFastLaunchRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.EnableFastLaunchOutput)
-	return ret0, ret1
-}
-
-// EnableFastLaunchRequest indicates an expected call of EnableFastLaunchRequest.
-func (mr *MockEC2APIMockRecorder) EnableFastLaunchRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastLaunchRequest", reflect.TypeOf((*MockEC2API)(nil).EnableFastLaunchRequest), arg0)
-}
-
-// EnableFastLaunchWithContext mocks base method.
-func (m *MockEC2API) EnableFastLaunchWithContext(arg0 context.Context, arg1 *ec2.EnableFastLaunchInput, arg2 ...request.Option) (*ec2.EnableFastLaunchOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EnableFastLaunchWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.EnableFastLaunchOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableFastLaunchWithContext indicates an expected call of EnableFastLaunchWithContext.
-func (mr *MockEC2APIMockRecorder) EnableFastLaunchWithContext(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, "EnableFastLaunchWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableFastLaunchWithContext), varargs...)
-}
-
-// EnableFastSnapshotRestores mocks base method.
-func (m *MockEC2API) EnableFastSnapshotRestores(arg0 *ec2.EnableFastSnapshotRestoresInput) (*ec2.EnableFastSnapshotRestoresOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableFastSnapshotRestores", arg0)
-	ret0, _ := ret[0].(*ec2.EnableFastSnapshotRestoresOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableFastSnapshotRestores indicates an expected call of EnableFastSnapshotRestores.
-func (mr *MockEC2APIMockRecorder) EnableFastSnapshotRestores(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastSnapshotRestores", reflect.TypeOf((*MockEC2API)(nil).EnableFastSnapshotRestores), arg0)
-}
-
-// EnableFastSnapshotRestoresRequest mocks base method.
-func (m *MockEC2API) EnableFastSnapshotRestoresRequest(arg0 *ec2.EnableFastSnapshotRestoresInput) (*request.Request, *ec2.EnableFastSnapshotRestoresOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableFastSnapshotRestoresRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.EnableFastSnapshotRestoresOutput)
-	return ret0, ret1
-}
-
-// EnableFastSnapshotRestoresRequest indicates an expected call of EnableFastSnapshotRestoresRequest.
-func (mr *MockEC2APIMockRecorder) EnableFastSnapshotRestoresRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastSnapshotRestoresRequest", reflect.TypeOf((*MockEC2API)(nil).EnableFastSnapshotRestoresRequest), arg0)
-}
-
-// EnableFastSnapshotRestoresWithContext mocks base method.
-func (m *MockEC2API) EnableFastSnapshotRestoresWithContext(arg0 context.Context, arg1 *ec2.EnableFastSnapshotRestoresInput, arg2 ...request.Option) (*ec2.EnableFastSnapshotRestoresOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EnableFastSnapshotRestoresWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.EnableFastSnapshotRestoresOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableFastSnapshotRestoresWithContext indicates an expected call of EnableFastSnapshotRestoresWithContext.
-func (mr *MockEC2APIMockRecorder) EnableFastSnapshotRestoresWithContext(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, "EnableFastSnapshotRestoresWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableFastSnapshotRestoresWithContext), varargs...)
-}
-
-// EnableImage mocks base method.
-func (m *MockEC2API) EnableImage(arg0 *ec2.EnableImageInput) (*ec2.EnableImageOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableImage", arg0)
-	ret0, _ := ret[0].(*ec2.EnableImageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableImage indicates an expected call of EnableImage.
-func (mr *MockEC2APIMockRecorder) EnableImage(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImage", reflect.TypeOf((*MockEC2API)(nil).EnableImage), arg0)
-}
-
-// EnableImageBlockPublicAccess mocks base method.
-func (m *MockEC2API) EnableImageBlockPublicAccess(arg0 *ec2.EnableImageBlockPublicAccessInput) (*ec2.EnableImageBlockPublicAccessOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableImageBlockPublicAccess", arg0)
-	ret0, _ := ret[0].(*ec2.EnableImageBlockPublicAccessOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableImageBlockPublicAccess indicates an expected call of EnableImageBlockPublicAccess.
-func (mr *MockEC2APIMockRecorder) EnableImageBlockPublicAccess(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageBlockPublicAccess", reflect.TypeOf((*MockEC2API)(nil).EnableImageBlockPublicAccess), arg0)
-}
-
-// EnableImageBlockPublicAccessRequest mocks base method.
-func (m *MockEC2API) EnableImageBlockPublicAccessRequest(arg0 *ec2.EnableImageBlockPublicAccessInput) (*request.Request, *ec2.EnableImageBlockPublicAccessOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableImageBlockPublicAccessRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.EnableImageBlockPublicAccessOutput)
-	return ret0, ret1
-}
-
-// EnableImageBlockPublicAccessRequest indicates an expected call of EnableImageBlockPublicAccessRequest.
-func (mr *MockEC2APIMockRecorder) EnableImageBlockPublicAccessRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageBlockPublicAccessRequest", reflect.TypeOf((*MockEC2API)(nil).EnableImageBlockPublicAccessRequest), arg0)
-}
-
-// EnableImageBlockPublicAccessWithContext mocks base method.
-func (m *MockEC2API) EnableImageBlockPublicAccessWithContext(arg0 context.Context, arg1 *ec2.EnableImageBlockPublicAccessInput, arg2 ...request.Option) (*ec2.EnableImageBlockPublicAccessOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EnableImageBlockPublicAccessWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.EnableImageBlockPublicAccessOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableImageBlockPublicAccessWithContext indicates an expected call of EnableImageBlockPublicAccessWithContext.
-func (mr *MockEC2APIMockRecorder) EnableImageBlockPublicAccessWithContext(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, "EnableImageBlockPublicAccessWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableImageBlockPublicAccessWithContext), varargs...)
-}
-
-// EnableImageDeprecation mocks base method.
-func (m *MockEC2API) EnableImageDeprecation(arg0 *ec2.EnableImageDeprecationInput) (*ec2.EnableImageDeprecationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableImageDeprecation", arg0)
-	ret0, _ := ret[0].(*ec2.EnableImageDeprecationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableImageDeprecation indicates an expected call of EnableImageDeprecation.
-func (mr *MockEC2APIMockRecorder) EnableImageDeprecation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageDeprecation", reflect.TypeOf((*MockEC2API)(nil).EnableImageDeprecation), arg0)
-}
-
-// EnableImageDeprecationRequest mocks base method.
-func (m *MockEC2API) EnableImageDeprecationRequest(arg0 *ec2.EnableImageDeprecationInput) (*request.Request, *ec2.EnableImageDeprecationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableImageDeprecationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.EnableImageDeprecationOutput)
-	return ret0, ret1
-}
-
-// EnableImageDeprecationRequest indicates an expected call of EnableImageDeprecationRequest.
-func (mr *MockEC2APIMockRecorder) EnableImageDeprecationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageDeprecationRequest", reflect.TypeOf((*MockEC2API)(nil).EnableImageDeprecationRequest), arg0)
-}
-
-// EnableImageDeprecationWithContext mocks base method.
-func (m *MockEC2API) EnableImageDeprecationWithContext(arg0 context.Context, arg1 *ec2.EnableImageDeprecationInput, arg2 ...request.Option) (*ec2.EnableImageDeprecationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EnableImageDeprecationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.EnableImageDeprecationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableImageDeprecationWithContext indicates an expected call of EnableImageDeprecationWithContext.
-func (mr *MockEC2APIMockRecorder) EnableImageDeprecationWithContext(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, "EnableImageDeprecationWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableImageDeprecationWithContext), varargs...)
-}
-
-// EnableImageDeregistrationProtection mocks base method.
-func (m *MockEC2API) EnableImageDeregistrationProtection(arg0 *ec2.EnableImageDeregistrationProtectionInput) (*ec2.EnableImageDeregistrationProtectionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableImageDeregistrationProtection", arg0)
-	ret0, _ := ret[0].(*ec2.EnableImageDeregistrationProtectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableImageDeregistrationProtection indicates an expected call of EnableImageDeregistrationProtection.
-func (mr *MockEC2APIMockRecorder) EnableImageDeregistrationProtection(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageDeregistrationProtection", reflect.TypeOf((*MockEC2API)(nil).EnableImageDeregistrationProtection), arg0)
-}
-
-// EnableImageDeregistrationProtectionRequest mocks base method.
-func (m *MockEC2API) EnableImageDeregistrationProtectionRequest(arg0 *ec2.EnableImageDeregistrationProtectionInput) (*request.Request, *ec2.EnableImageDeregistrationProtectionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableImageDeregistrationProtectionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.EnableImageDeregistrationProtectionOutput)
-	return ret0, ret1
-}
-
-// EnableImageDeregistrationProtectionRequest indicates an expected call of EnableImageDeregistrationProtectionRequest.
-func (mr *MockEC2APIMockRecorder) EnableImageDeregistrationProtectionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageDeregistrationProtectionRequest", reflect.TypeOf((*MockEC2API)(nil).EnableImageDeregistrationProtectionRequest), arg0)
-}
-
-// EnableImageDeregistrationProtectionWithContext mocks base method.
-func (m *MockEC2API) EnableImageDeregistrationProtectionWithContext(arg0 context.Context, arg1 *ec2.EnableImageDeregistrationProtectionInput, arg2 ...request.Option) (*ec2.EnableImageDeregistrationProtectionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EnableImageDeregistrationProtectionWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.EnableImageDeregistrationProtectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableImageDeregistrationProtectionWithContext indicates an expected call of EnableImageDeregistrationProtectionWithContext.
-func (mr *MockEC2APIMockRecorder) EnableImageDeregistrationProtectionWithContext(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, "EnableImageDeregistrationProtectionWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableImageDeregistrationProtectionWithContext), varargs...)
-}
-
-// EnableImageRequest mocks base method.
-func (m *MockEC2API) EnableImageRequest(arg0 *ec2.EnableImageInput) (*request.Request, *ec2.EnableImageOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableImageRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.EnableImageOutput)
-	return ret0, ret1
-}
-
-// EnableImageRequest indicates an expected call of EnableImageRequest.
-func (mr *MockEC2APIMockRecorder) EnableImageRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageRequest", reflect.TypeOf((*MockEC2API)(nil).EnableImageRequest), arg0)
-}
-
-// EnableImageWithContext mocks base method.
-func (m *MockEC2API) EnableImageWithContext(arg0 context.Context, arg1 *ec2.EnableImageInput, arg2 ...request.Option) (*ec2.EnableImageOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EnableImageWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.EnableImageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableImageWithContext indicates an expected call of EnableImageWithContext.
-func (mr *MockEC2APIMockRecorder) EnableImageWithContext(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, "EnableImageWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableImageWithContext), varargs...)
-}
-
-// EnableIpamOrganizationAdminAccount mocks base method.
-func (m *MockEC2API) EnableIpamOrganizationAdminAccount(arg0 *ec2.EnableIpamOrganizationAdminAccountInput) (*ec2.EnableIpamOrganizationAdminAccountOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableIpamOrganizationAdminAccount", arg0)
-	ret0, _ := ret[0].(*ec2.EnableIpamOrganizationAdminAccountOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableIpamOrganizationAdminAccount indicates an expected call of EnableIpamOrganizationAdminAccount.
-func (mr *MockEC2APIMockRecorder) EnableIpamOrganizationAdminAccount(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableIpamOrganizationAdminAccount", reflect.TypeOf((*MockEC2API)(nil).EnableIpamOrganizationAdminAccount), arg0)
-}
-
-// EnableIpamOrganizationAdminAccountRequest mocks base method.
-func (m *MockEC2API) EnableIpamOrganizationAdminAccountRequest(arg0 *ec2.EnableIpamOrganizationAdminAccountInput) (*request.Request, *ec2.EnableIpamOrganizationAdminAccountOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableIpamOrganizationAdminAccountRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.EnableIpamOrganizationAdminAccountOutput)
-	return ret0, ret1
-}
-
-// EnableIpamOrganizationAdminAccountRequest indicates an expected call of EnableIpamOrganizationAdminAccountRequest.
-func (mr *MockEC2APIMockRecorder) EnableIpamOrganizationAdminAccountRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableIpamOrganizationAdminAccountRequest", reflect.TypeOf((*MockEC2API)(nil).EnableIpamOrganizationAdminAccountRequest), arg0)
-}
-
-// EnableIpamOrganizationAdminAccountWithContext mocks base method.
-func (m *MockEC2API) EnableIpamOrganizationAdminAccountWithContext(arg0 context.Context, arg1 *ec2.EnableIpamOrganizationAdminAccountInput, arg2 ...request.Option) (*ec2.EnableIpamOrganizationAdminAccountOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EnableIpamOrganizationAdminAccountWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.EnableIpamOrganizationAdminAccountOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableIpamOrganizationAdminAccountWithContext indicates an expected call of EnableIpamOrganizationAdminAccountWithContext.
-func (mr *MockEC2APIMockRecorder) EnableIpamOrganizationAdminAccountWithContext(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, "EnableIpamOrganizationAdminAccountWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableIpamOrganizationAdminAccountWithContext), varargs...)
-}
-
-// EnableReachabilityAnalyzerOrganizationSharing mocks base method.
-func (m *MockEC2API) EnableReachabilityAnalyzerOrganizationSharing(arg0 *ec2.EnableReachabilityAnalyzerOrganizationSharingInput) (*ec2.EnableReachabilityAnalyzerOrganizationSharingOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableReachabilityAnalyzerOrganizationSharing", arg0)
-	ret0, _ := ret[0].(*ec2.EnableReachabilityAnalyzerOrganizationSharingOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableReachabilityAnalyzerOrganizationSharing indicates an expected call of EnableReachabilityAnalyzerOrganizationSharing.
-func (mr *MockEC2APIMockRecorder) EnableReachabilityAnalyzerOrganizationSharing(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableReachabilityAnalyzerOrganizationSharing", reflect.TypeOf((*MockEC2API)(nil).EnableReachabilityAnalyzerOrganizationSharing), arg0)
-}
-
-// EnableReachabilityAnalyzerOrganizationSharingRequest mocks base method.
-func (m *MockEC2API) EnableReachabilityAnalyzerOrganizationSharingRequest(arg0 *ec2.EnableReachabilityAnalyzerOrganizationSharingInput) (*request.Request, *ec2.EnableReachabilityAnalyzerOrganizationSharingOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableReachabilityAnalyzerOrganizationSharingRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.EnableReachabilityAnalyzerOrganizationSharingOutput)
-	return ret0, ret1
-}
-
-// EnableReachabilityAnalyzerOrganizationSharingRequest indicates an expected call of EnableReachabilityAnalyzerOrganizationSharingRequest.
-func (mr *MockEC2APIMockRecorder) EnableReachabilityAnalyzerOrganizationSharingRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableReachabilityAnalyzerOrganizationSharingRequest", reflect.TypeOf((*MockEC2API)(nil).EnableReachabilityAnalyzerOrganizationSharingRequest), arg0)
-}
-
-// EnableReachabilityAnalyzerOrganizationSharingWithContext mocks base method.
-func (m *MockEC2API) EnableReachabilityAnalyzerOrganizationSharingWithContext(arg0 context.Context, arg1 *ec2.EnableReachabilityAnalyzerOrganizationSharingInput, arg2 ...request.Option) (*ec2.EnableReachabilityAnalyzerOrganizationSharingOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EnableReachabilityAnalyzerOrganizationSharingWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.EnableReachabilityAnalyzerOrganizationSharingOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableReachabilityAnalyzerOrganizationSharingWithContext indicates an expected call of EnableReachabilityAnalyzerOrganizationSharingWithContext.
-func (mr *MockEC2APIMockRecorder) EnableReachabilityAnalyzerOrganizationSharingWithContext(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, "EnableReachabilityAnalyzerOrganizationSharingWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableReachabilityAnalyzerOrganizationSharingWithContext), varargs...)
-}
-
-// EnableSerialConsoleAccess mocks base method.
-func (m *MockEC2API) EnableSerialConsoleAccess(arg0 *ec2.EnableSerialConsoleAccessInput) (*ec2.EnableSerialConsoleAccessOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableSerialConsoleAccess", arg0)
-	ret0, _ := ret[0].(*ec2.EnableSerialConsoleAccessOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableSerialConsoleAccess indicates an expected call of EnableSerialConsoleAccess.
-func (mr *MockEC2APIMockRecorder) EnableSerialConsoleAccess(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableSerialConsoleAccess", reflect.TypeOf((*MockEC2API)(nil).EnableSerialConsoleAccess), arg0)
-}
-
-// EnableSerialConsoleAccessRequest mocks base method.
-func (m *MockEC2API) EnableSerialConsoleAccessRequest(arg0 *ec2.EnableSerialConsoleAccessInput) (*request.Request, *ec2.EnableSerialConsoleAccessOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableSerialConsoleAccessRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.EnableSerialConsoleAccessOutput)
-	return ret0, ret1
-}
-
-// EnableSerialConsoleAccessRequest indicates an expected call of EnableSerialConsoleAccessRequest.
-func (mr *MockEC2APIMockRecorder) EnableSerialConsoleAccessRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableSerialConsoleAccessRequest", reflect.TypeOf((*MockEC2API)(nil).EnableSerialConsoleAccessRequest), arg0)
-}
-
-// EnableSerialConsoleAccessWithContext mocks base method.
-func (m *MockEC2API) EnableSerialConsoleAccessWithContext(arg0 context.Context, arg1 *ec2.EnableSerialConsoleAccessInput, arg2 ...request.Option) (*ec2.EnableSerialConsoleAccessOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EnableSerialConsoleAccessWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.EnableSerialConsoleAccessOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableSerialConsoleAccessWithContext indicates an expected call of EnableSerialConsoleAccessWithContext.
-func (mr *MockEC2APIMockRecorder) EnableSerialConsoleAccessWithContext(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, "EnableSerialConsoleAccessWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableSerialConsoleAccessWithContext), varargs...)
-}
-
-// EnableSnapshotBlockPublicAccess mocks base method.
-func (m *MockEC2API) EnableSnapshotBlockPublicAccess(arg0 *ec2.EnableSnapshotBlockPublicAccessInput) (*ec2.EnableSnapshotBlockPublicAccessOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableSnapshotBlockPublicAccess", arg0)
-	ret0, _ := ret[0].(*ec2.EnableSnapshotBlockPublicAccessOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableSnapshotBlockPublicAccess indicates an expected call of EnableSnapshotBlockPublicAccess.
-func (mr *MockEC2APIMockRecorder) EnableSnapshotBlockPublicAccess(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableSnapshotBlockPublicAccess", reflect.TypeOf((*MockEC2API)(nil).EnableSnapshotBlockPublicAccess), arg0)
-}
-
-// EnableSnapshotBlockPublicAccessRequest mocks base method.
-func (m *MockEC2API) EnableSnapshotBlockPublicAccessRequest(arg0 *ec2.EnableSnapshotBlockPublicAccessInput) (*request.Request, *ec2.EnableSnapshotBlockPublicAccessOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableSnapshotBlockPublicAccessRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.EnableSnapshotBlockPublicAccessOutput)
-	return ret0, ret1
-}
-
-// EnableSnapshotBlockPublicAccessRequest indicates an expected call of EnableSnapshotBlockPublicAccessRequest.
-func (mr *MockEC2APIMockRecorder) EnableSnapshotBlockPublicAccessRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableSnapshotBlockPublicAccessRequest", reflect.TypeOf((*MockEC2API)(nil).EnableSnapshotBlockPublicAccessRequest), arg0)
-}
-
-// EnableSnapshotBlockPublicAccessWithContext mocks base method.
-func (m *MockEC2API) EnableSnapshotBlockPublicAccessWithContext(arg0 context.Context, arg1 *ec2.EnableSnapshotBlockPublicAccessInput, arg2 ...request.Option) (*ec2.EnableSnapshotBlockPublicAccessOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EnableSnapshotBlockPublicAccessWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.EnableSnapshotBlockPublicAccessOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableSnapshotBlockPublicAccessWithContext indicates an expected call of EnableSnapshotBlockPublicAccessWithContext.
-func (mr *MockEC2APIMockRecorder) EnableSnapshotBlockPublicAccessWithContext(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, "EnableSnapshotBlockPublicAccessWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableSnapshotBlockPublicAccessWithContext), varargs...)
-}
-
-// EnableTransitGatewayRouteTablePropagation mocks base method.
-func (m *MockEC2API) EnableTransitGatewayRouteTablePropagation(arg0 *ec2.EnableTransitGatewayRouteTablePropagationInput) (*ec2.EnableTransitGatewayRouteTablePropagationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableTransitGatewayRouteTablePropagation", arg0)
-	ret0, _ := ret[0].(*ec2.EnableTransitGatewayRouteTablePropagationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableTransitGatewayRouteTablePropagation indicates an expected call of EnableTransitGatewayRouteTablePropagation.
-func (mr *MockEC2APIMockRecorder) EnableTransitGatewayRouteTablePropagation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableTransitGatewayRouteTablePropagation", reflect.TypeOf((*MockEC2API)(nil).EnableTransitGatewayRouteTablePropagation), arg0)
-}
-
-// EnableTransitGatewayRouteTablePropagationRequest mocks base method.
-func (m *MockEC2API) EnableTransitGatewayRouteTablePropagationRequest(arg0 *ec2.EnableTransitGatewayRouteTablePropagationInput) (*request.Request, *ec2.EnableTransitGatewayRouteTablePropagationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableTransitGatewayRouteTablePropagationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.EnableTransitGatewayRouteTablePropagationOutput)
-	return ret0, ret1
-}
-
-// EnableTransitGatewayRouteTablePropagationRequest indicates an expected call of EnableTransitGatewayRouteTablePropagationRequest.
-func (mr *MockEC2APIMockRecorder) EnableTransitGatewayRouteTablePropagationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableTransitGatewayRouteTablePropagationRequest", reflect.TypeOf((*MockEC2API)(nil).EnableTransitGatewayRouteTablePropagationRequest), arg0)
-}
-
-// EnableTransitGatewayRouteTablePropagationWithContext mocks base method.
-func (m *MockEC2API) EnableTransitGatewayRouteTablePropagationWithContext(arg0 context.Context, arg1 *ec2.EnableTransitGatewayRouteTablePropagationInput, arg2 ...request.Option) (*ec2.EnableTransitGatewayRouteTablePropagationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EnableTransitGatewayRouteTablePropagationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.EnableTransitGatewayRouteTablePropagationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableTransitGatewayRouteTablePropagationWithContext indicates an expected call of EnableTransitGatewayRouteTablePropagationWithContext.
-func (mr *MockEC2APIMockRecorder) EnableTransitGatewayRouteTablePropagationWithContext(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, "EnableTransitGatewayRouteTablePropagationWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableTransitGatewayRouteTablePropagationWithContext), varargs...)
-}
-
-// EnableVgwRoutePropagation mocks base method.
-func (m *MockEC2API) EnableVgwRoutePropagation(arg0 *ec2.EnableVgwRoutePropagationInput) (*ec2.EnableVgwRoutePropagationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableVgwRoutePropagation", arg0)
-	ret0, _ := ret[0].(*ec2.EnableVgwRoutePropagationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableVgwRoutePropagation indicates an expected call of EnableVgwRoutePropagation.
-func (mr *MockEC2APIMockRecorder) EnableVgwRoutePropagation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVgwRoutePropagation", reflect.TypeOf((*MockEC2API)(nil).EnableVgwRoutePropagation), arg0)
-}
-
-// EnableVgwRoutePropagationRequest mocks base method.
-func (m *MockEC2API) EnableVgwRoutePropagationRequest(arg0 *ec2.EnableVgwRoutePropagationInput) (*request.Request, *ec2.EnableVgwRoutePropagationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableVgwRoutePropagationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.EnableVgwRoutePropagationOutput)
-	return ret0, ret1
-}
-
-// EnableVgwRoutePropagationRequest indicates an expected call of EnableVgwRoutePropagationRequest.
-func (mr *MockEC2APIMockRecorder) EnableVgwRoutePropagationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVgwRoutePropagationRequest", reflect.TypeOf((*MockEC2API)(nil).EnableVgwRoutePropagationRequest), arg0)
-}
-
-// EnableVgwRoutePropagationWithContext mocks base method.
-func (m *MockEC2API) EnableVgwRoutePropagationWithContext(arg0 context.Context, arg1 *ec2.EnableVgwRoutePropagationInput, arg2 ...request.Option) (*ec2.EnableVgwRoutePropagationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EnableVgwRoutePropagationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.EnableVgwRoutePropagationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableVgwRoutePropagationWithContext indicates an expected call of EnableVgwRoutePropagationWithContext.
-func (mr *MockEC2APIMockRecorder) EnableVgwRoutePropagationWithContext(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, "EnableVgwRoutePropagationWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableVgwRoutePropagationWithContext), varargs...)
-}
-
-// EnableVolumeIO mocks base method.
-func (m *MockEC2API) EnableVolumeIO(arg0 *ec2.EnableVolumeIOInput) (*ec2.EnableVolumeIOOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableVolumeIO", arg0)
-	ret0, _ := ret[0].(*ec2.EnableVolumeIOOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableVolumeIO indicates an expected call of EnableVolumeIO.
-func (mr *MockEC2APIMockRecorder) EnableVolumeIO(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVolumeIO", reflect.TypeOf((*MockEC2API)(nil).EnableVolumeIO), arg0)
-}
-
-// EnableVolumeIORequest mocks base method.
-func (m *MockEC2API) EnableVolumeIORequest(arg0 *ec2.EnableVolumeIOInput) (*request.Request, *ec2.EnableVolumeIOOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableVolumeIORequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.EnableVolumeIOOutput)
-	return ret0, ret1
-}
-
-// EnableVolumeIORequest indicates an expected call of EnableVolumeIORequest.
-func (mr *MockEC2APIMockRecorder) EnableVolumeIORequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVolumeIORequest", reflect.TypeOf((*MockEC2API)(nil).EnableVolumeIORequest), arg0)
-}
-
-// EnableVolumeIOWithContext mocks base method.
-func (m *MockEC2API) EnableVolumeIOWithContext(arg0 context.Context, arg1 *ec2.EnableVolumeIOInput, arg2 ...request.Option) (*ec2.EnableVolumeIOOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EnableVolumeIOWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.EnableVolumeIOOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableVolumeIOWithContext indicates an expected call of EnableVolumeIOWithContext.
-func (mr *MockEC2APIMockRecorder) EnableVolumeIOWithContext(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, "EnableVolumeIOWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableVolumeIOWithContext), varargs...)
-}
-
-// EnableVpcClassicLink mocks base method.
-func (m *MockEC2API) EnableVpcClassicLink(arg0 *ec2.EnableVpcClassicLinkInput) (*ec2.EnableVpcClassicLinkOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableVpcClassicLink", arg0)
-	ret0, _ := ret[0].(*ec2.EnableVpcClassicLinkOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableVpcClassicLink indicates an expected call of EnableVpcClassicLink.
-func (mr *MockEC2APIMockRecorder) EnableVpcClassicLink(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLink", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLink), arg0)
-}
-
-// EnableVpcClassicLinkDnsSupport mocks base method.
-func (m *MockEC2API) EnableVpcClassicLinkDnsSupport(arg0 *ec2.EnableVpcClassicLinkDnsSupportInput) (*ec2.EnableVpcClassicLinkDnsSupportOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableVpcClassicLinkDnsSupport", arg0)
-	ret0, _ := ret[0].(*ec2.EnableVpcClassicLinkDnsSupportOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableVpcClassicLinkDnsSupport indicates an expected call of EnableVpcClassicLinkDnsSupport.
-func (mr *MockEC2APIMockRecorder) EnableVpcClassicLinkDnsSupport(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLinkDnsSupport", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLinkDnsSupport), arg0)
-}
-
-// EnableVpcClassicLinkDnsSupportRequest mocks base method.
-func (m *MockEC2API) EnableVpcClassicLinkDnsSupportRequest(arg0 *ec2.EnableVpcClassicLinkDnsSupportInput) (*request.Request, *ec2.EnableVpcClassicLinkDnsSupportOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableVpcClassicLinkDnsSupportRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.EnableVpcClassicLinkDnsSupportOutput)
-	return ret0, ret1
-}
-
-// EnableVpcClassicLinkDnsSupportRequest indicates an expected call of EnableVpcClassicLinkDnsSupportRequest.
-func (mr *MockEC2APIMockRecorder) EnableVpcClassicLinkDnsSupportRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLinkDnsSupportRequest", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLinkDnsSupportRequest), arg0)
-}
-
-// EnableVpcClassicLinkDnsSupportWithContext mocks base method.
-func (m *MockEC2API) EnableVpcClassicLinkDnsSupportWithContext(arg0 context.Context, arg1 *ec2.EnableVpcClassicLinkDnsSupportInput, arg2 ...request.Option) (*ec2.EnableVpcClassicLinkDnsSupportOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EnableVpcClassicLinkDnsSupportWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.EnableVpcClassicLinkDnsSupportOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableVpcClassicLinkDnsSupportWithContext indicates an expected call of EnableVpcClassicLinkDnsSupportWithContext.
-func (mr *MockEC2APIMockRecorder) EnableVpcClassicLinkDnsSupportWithContext(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, "EnableVpcClassicLinkDnsSupportWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLinkDnsSupportWithContext), varargs...)
-}
-
-// EnableVpcClassicLinkRequest mocks base method.
-func (m *MockEC2API) EnableVpcClassicLinkRequest(arg0 *ec2.EnableVpcClassicLinkInput) (*request.Request, *ec2.EnableVpcClassicLinkOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableVpcClassicLinkRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.EnableVpcClassicLinkOutput)
-	return ret0, ret1
-}
-
-// EnableVpcClassicLinkRequest indicates an expected call of EnableVpcClassicLinkRequest.
-func (mr *MockEC2APIMockRecorder) EnableVpcClassicLinkRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLinkRequest", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLinkRequest), arg0)
-}
-
-// EnableVpcClassicLinkWithContext mocks base method.
-func (m *MockEC2API) EnableVpcClassicLinkWithContext(arg0 context.Context, arg1 *ec2.EnableVpcClassicLinkInput, arg2 ...request.Option) (*ec2.EnableVpcClassicLinkOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EnableVpcClassicLinkWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.EnableVpcClassicLinkOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableVpcClassicLinkWithContext indicates an expected call of EnableVpcClassicLinkWithContext.
-func (mr *MockEC2APIMockRecorder) EnableVpcClassicLinkWithContext(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, "EnableVpcClassicLinkWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLinkWithContext), varargs...)
-}
-
-// ExportClientVpnClientCertificateRevocationList mocks base method.
-func (m *MockEC2API) ExportClientVpnClientCertificateRevocationList(arg0 *ec2.ExportClientVpnClientCertificateRevocationListInput) (*ec2.ExportClientVpnClientCertificateRevocationListOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ExportClientVpnClientCertificateRevocationList", arg0)
-	ret0, _ := ret[0].(*ec2.ExportClientVpnClientCertificateRevocationListOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ExportClientVpnClientCertificateRevocationList indicates an expected call of ExportClientVpnClientCertificateRevocationList.
-func (mr *MockEC2APIMockRecorder) ExportClientVpnClientCertificateRevocationList(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientCertificateRevocationList", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientCertificateRevocationList), arg0)
-}
-
-// ExportClientVpnClientCertificateRevocationListRequest mocks base method.
-func (m *MockEC2API) ExportClientVpnClientCertificateRevocationListRequest(arg0 *ec2.ExportClientVpnClientCertificateRevocationListInput) (*request.Request, *ec2.ExportClientVpnClientCertificateRevocationListOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ExportClientVpnClientCertificateRevocationListRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ExportClientVpnClientCertificateRevocationListOutput)
-	return ret0, ret1
-}
-
-// ExportClientVpnClientCertificateRevocationListRequest indicates an expected call of ExportClientVpnClientCertificateRevocationListRequest.
-func (mr *MockEC2APIMockRecorder) ExportClientVpnClientCertificateRevocationListRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientCertificateRevocationListRequest", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientCertificateRevocationListRequest), arg0)
-}
-
-// ExportClientVpnClientCertificateRevocationListWithContext mocks base method.
-func (m *MockEC2API) ExportClientVpnClientCertificateRevocationListWithContext(arg0 context.Context, arg1 *ec2.ExportClientVpnClientCertificateRevocationListInput, arg2 ...request.Option) (*ec2.ExportClientVpnClientCertificateRevocationListOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ExportClientVpnClientCertificateRevocationListWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ExportClientVpnClientCertificateRevocationListOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ExportClientVpnClientCertificateRevocationListWithContext indicates an expected call of ExportClientVpnClientCertificateRevocationListWithContext.
-func (mr *MockEC2APIMockRecorder) ExportClientVpnClientCertificateRevocationListWithContext(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, "ExportClientVpnClientCertificateRevocationListWithContext", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientCertificateRevocationListWithContext), varargs...)
-}
-
-// ExportClientVpnClientConfiguration mocks base method.
-func (m *MockEC2API) ExportClientVpnClientConfiguration(arg0 *ec2.ExportClientVpnClientConfigurationInput) (*ec2.ExportClientVpnClientConfigurationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ExportClientVpnClientConfiguration", arg0)
-	ret0, _ := ret[0].(*ec2.ExportClientVpnClientConfigurationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ExportClientVpnClientConfiguration indicates an expected call of ExportClientVpnClientConfiguration.
-func (mr *MockEC2APIMockRecorder) ExportClientVpnClientConfiguration(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientConfiguration", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientConfiguration), arg0)
-}
-
-// ExportClientVpnClientConfigurationRequest mocks base method.
-func (m *MockEC2API) ExportClientVpnClientConfigurationRequest(arg0 *ec2.ExportClientVpnClientConfigurationInput) (*request.Request, *ec2.ExportClientVpnClientConfigurationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ExportClientVpnClientConfigurationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ExportClientVpnClientConfigurationOutput)
-	return ret0, ret1
-}
-
-// ExportClientVpnClientConfigurationRequest indicates an expected call of ExportClientVpnClientConfigurationRequest.
-func (mr *MockEC2APIMockRecorder) ExportClientVpnClientConfigurationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientConfigurationRequest", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientConfigurationRequest), arg0)
-}
-
-// ExportClientVpnClientConfigurationWithContext mocks base method.
-func (m *MockEC2API) ExportClientVpnClientConfigurationWithContext(arg0 context.Context, arg1 *ec2.ExportClientVpnClientConfigurationInput, arg2 ...request.Option) (*ec2.ExportClientVpnClientConfigurationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ExportClientVpnClientConfigurationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ExportClientVpnClientConfigurationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ExportClientVpnClientConfigurationWithContext indicates an expected call of ExportClientVpnClientConfigurationWithContext.
-func (mr *MockEC2APIMockRecorder) ExportClientVpnClientConfigurationWithContext(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, "ExportClientVpnClientConfigurationWithContext", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientConfigurationWithContext), varargs...)
-}
-
-// ExportImage mocks base method.
-func (m *MockEC2API) ExportImage(arg0 *ec2.ExportImageInput) (*ec2.ExportImageOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ExportImage", arg0)
-	ret0, _ := ret[0].(*ec2.ExportImageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ExportImage indicates an expected call of ExportImage.
-func (mr *MockEC2APIMockRecorder) ExportImage(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportImage", reflect.TypeOf((*MockEC2API)(nil).ExportImage), arg0)
-}
-
-// ExportImageRequest mocks base method.
-func (m *MockEC2API) ExportImageRequest(arg0 *ec2.ExportImageInput) (*request.Request, *ec2.ExportImageOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ExportImageRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ExportImageOutput)
-	return ret0, ret1
-}
-
-// ExportImageRequest indicates an expected call of ExportImageRequest.
-func (mr *MockEC2APIMockRecorder) ExportImageRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportImageRequest", reflect.TypeOf((*MockEC2API)(nil).ExportImageRequest), arg0)
-}
-
-// ExportImageWithContext mocks base method.
-func (m *MockEC2API) ExportImageWithContext(arg0 context.Context, arg1 *ec2.ExportImageInput, arg2 ...request.Option) (*ec2.ExportImageOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ExportImageWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ExportImageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ExportImageWithContext indicates an expected call of ExportImageWithContext.
-func (mr *MockEC2APIMockRecorder) ExportImageWithContext(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, "ExportImageWithContext", reflect.TypeOf((*MockEC2API)(nil).ExportImageWithContext), varargs...)
-}
-
-// ExportTransitGatewayRoutes mocks base method.
-func (m *MockEC2API) ExportTransitGatewayRoutes(arg0 *ec2.ExportTransitGatewayRoutesInput) (*ec2.ExportTransitGatewayRoutesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ExportTransitGatewayRoutes", arg0)
-	ret0, _ := ret[0].(*ec2.ExportTransitGatewayRoutesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ExportTransitGatewayRoutes indicates an expected call of ExportTransitGatewayRoutes.
-func (mr *MockEC2APIMockRecorder) ExportTransitGatewayRoutes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTransitGatewayRoutes", reflect.TypeOf((*MockEC2API)(nil).ExportTransitGatewayRoutes), arg0)
-}
-
-// ExportTransitGatewayRoutesRequest mocks base method.
-func (m *MockEC2API) ExportTransitGatewayRoutesRequest(arg0 *ec2.ExportTransitGatewayRoutesInput) (*request.Request, *ec2.ExportTransitGatewayRoutesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ExportTransitGatewayRoutesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ExportTransitGatewayRoutesOutput)
-	return ret0, ret1
-}
-
-// ExportTransitGatewayRoutesRequest indicates an expected call of ExportTransitGatewayRoutesRequest.
-func (mr *MockEC2APIMockRecorder) ExportTransitGatewayRoutesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTransitGatewayRoutesRequest", reflect.TypeOf((*MockEC2API)(nil).ExportTransitGatewayRoutesRequest), arg0)
-}
-
-// ExportTransitGatewayRoutesWithContext mocks base method.
-func (m *MockEC2API) ExportTransitGatewayRoutesWithContext(arg0 context.Context, arg1 *ec2.ExportTransitGatewayRoutesInput, arg2 ...request.Option) (*ec2.ExportTransitGatewayRoutesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ExportTransitGatewayRoutesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ExportTransitGatewayRoutesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ExportTransitGatewayRoutesWithContext indicates an expected call of ExportTransitGatewayRoutesWithContext.
-func (mr *MockEC2APIMockRecorder) ExportTransitGatewayRoutesWithContext(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, "ExportTransitGatewayRoutesWithContext", reflect.TypeOf((*MockEC2API)(nil).ExportTransitGatewayRoutesWithContext), varargs...)
-}
-
-// GetAssociatedEnclaveCertificateIamRoles mocks base method.
-func (m *MockEC2API) GetAssociatedEnclaveCertificateIamRoles(arg0 *ec2.GetAssociatedEnclaveCertificateIamRolesInput) (*ec2.GetAssociatedEnclaveCertificateIamRolesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetAssociatedEnclaveCertificateIamRoles", arg0)
-	ret0, _ := ret[0].(*ec2.GetAssociatedEnclaveCertificateIamRolesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetAssociatedEnclaveCertificateIamRoles indicates an expected call of GetAssociatedEnclaveCertificateIamRoles.
-func (mr *MockEC2APIMockRecorder) GetAssociatedEnclaveCertificateIamRoles(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedEnclaveCertificateIamRoles", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedEnclaveCertificateIamRoles), arg0)
-}
-
-// GetAssociatedEnclaveCertificateIamRolesRequest mocks base method.
-func (m *MockEC2API) GetAssociatedEnclaveCertificateIamRolesRequest(arg0 *ec2.GetAssociatedEnclaveCertificateIamRolesInput) (*request.Request, *ec2.GetAssociatedEnclaveCertificateIamRolesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetAssociatedEnclaveCertificateIamRolesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetAssociatedEnclaveCertificateIamRolesOutput)
-	return ret0, ret1
-}
-
-// GetAssociatedEnclaveCertificateIamRolesRequest indicates an expected call of GetAssociatedEnclaveCertificateIamRolesRequest.
-func (mr *MockEC2APIMockRecorder) GetAssociatedEnclaveCertificateIamRolesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedEnclaveCertificateIamRolesRequest", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedEnclaveCertificateIamRolesRequest), arg0)
-}
-
-// GetAssociatedEnclaveCertificateIamRolesWithContext mocks base method.
-func (m *MockEC2API) GetAssociatedEnclaveCertificateIamRolesWithContext(arg0 context.Context, arg1 *ec2.GetAssociatedEnclaveCertificateIamRolesInput, arg2 ...request.Option) (*ec2.GetAssociatedEnclaveCertificateIamRolesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetAssociatedEnclaveCertificateIamRolesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetAssociatedEnclaveCertificateIamRolesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetAssociatedEnclaveCertificateIamRolesWithContext indicates an expected call of GetAssociatedEnclaveCertificateIamRolesWithContext.
-func (mr *MockEC2APIMockRecorder) GetAssociatedEnclaveCertificateIamRolesWithContext(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, "GetAssociatedEnclaveCertificateIamRolesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedEnclaveCertificateIamRolesWithContext), varargs...)
-}
-
-// GetAssociatedIpv6PoolCidrs mocks base method.
-func (m *MockEC2API) GetAssociatedIpv6PoolCidrs(arg0 *ec2.GetAssociatedIpv6PoolCidrsInput) (*ec2.GetAssociatedIpv6PoolCidrsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetAssociatedIpv6PoolCidrs", arg0)
-	ret0, _ := ret[0].(*ec2.GetAssociatedIpv6PoolCidrsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetAssociatedIpv6PoolCidrs indicates an expected call of GetAssociatedIpv6PoolCidrs.
-func (mr *MockEC2APIMockRecorder) GetAssociatedIpv6PoolCidrs(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedIpv6PoolCidrs", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedIpv6PoolCidrs), arg0)
-}
-
-// GetAssociatedIpv6PoolCidrsPages mocks base method.
-func (m *MockEC2API) GetAssociatedIpv6PoolCidrsPages(arg0 *ec2.GetAssociatedIpv6PoolCidrsInput, arg1 func(*ec2.GetAssociatedIpv6PoolCidrsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetAssociatedIpv6PoolCidrsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetAssociatedIpv6PoolCidrsPages indicates an expected call of GetAssociatedIpv6PoolCidrsPages.
-func (mr *MockEC2APIMockRecorder) GetAssociatedIpv6PoolCidrsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedIpv6PoolCidrsPages", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedIpv6PoolCidrsPages), arg0, arg1)
-}
-
-// GetAssociatedIpv6PoolCidrsPagesWithContext mocks base method.
-func (m *MockEC2API) GetAssociatedIpv6PoolCidrsPagesWithContext(arg0 context.Context, arg1 *ec2.GetAssociatedIpv6PoolCidrsInput, arg2 func(*ec2.GetAssociatedIpv6PoolCidrsOutput, 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, "GetAssociatedIpv6PoolCidrsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetAssociatedIpv6PoolCidrsPagesWithContext indicates an expected call of GetAssociatedIpv6PoolCidrsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) GetAssociatedIpv6PoolCidrsPagesWithContext(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, "GetAssociatedIpv6PoolCidrsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedIpv6PoolCidrsPagesWithContext), varargs...)
-}
-
-// GetAssociatedIpv6PoolCidrsRequest mocks base method.
-func (m *MockEC2API) GetAssociatedIpv6PoolCidrsRequest(arg0 *ec2.GetAssociatedIpv6PoolCidrsInput) (*request.Request, *ec2.GetAssociatedIpv6PoolCidrsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetAssociatedIpv6PoolCidrsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetAssociatedIpv6PoolCidrsOutput)
-	return ret0, ret1
-}
-
-// GetAssociatedIpv6PoolCidrsRequest indicates an expected call of GetAssociatedIpv6PoolCidrsRequest.
-func (mr *MockEC2APIMockRecorder) GetAssociatedIpv6PoolCidrsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedIpv6PoolCidrsRequest", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedIpv6PoolCidrsRequest), arg0)
-}
-
-// GetAssociatedIpv6PoolCidrsWithContext mocks base method.
-func (m *MockEC2API) GetAssociatedIpv6PoolCidrsWithContext(arg0 context.Context, arg1 *ec2.GetAssociatedIpv6PoolCidrsInput, arg2 ...request.Option) (*ec2.GetAssociatedIpv6PoolCidrsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetAssociatedIpv6PoolCidrsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetAssociatedIpv6PoolCidrsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetAssociatedIpv6PoolCidrsWithContext indicates an expected call of GetAssociatedIpv6PoolCidrsWithContext.
-func (mr *MockEC2APIMockRecorder) GetAssociatedIpv6PoolCidrsWithContext(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, "GetAssociatedIpv6PoolCidrsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedIpv6PoolCidrsWithContext), varargs...)
-}
-
-// GetAwsNetworkPerformanceData mocks base method.
-func (m *MockEC2API) GetAwsNetworkPerformanceData(arg0 *ec2.GetAwsNetworkPerformanceDataInput) (*ec2.GetAwsNetworkPerformanceDataOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetAwsNetworkPerformanceData", arg0)
-	ret0, _ := ret[0].(*ec2.GetAwsNetworkPerformanceDataOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetAwsNetworkPerformanceData indicates an expected call of GetAwsNetworkPerformanceData.
-func (mr *MockEC2APIMockRecorder) GetAwsNetworkPerformanceData(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAwsNetworkPerformanceData", reflect.TypeOf((*MockEC2API)(nil).GetAwsNetworkPerformanceData), arg0)
-}
-
-// GetAwsNetworkPerformanceDataPages mocks base method.
-func (m *MockEC2API) GetAwsNetworkPerformanceDataPages(arg0 *ec2.GetAwsNetworkPerformanceDataInput, arg1 func(*ec2.GetAwsNetworkPerformanceDataOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetAwsNetworkPerformanceDataPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetAwsNetworkPerformanceDataPages indicates an expected call of GetAwsNetworkPerformanceDataPages.
-func (mr *MockEC2APIMockRecorder) GetAwsNetworkPerformanceDataPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAwsNetworkPerformanceDataPages", reflect.TypeOf((*MockEC2API)(nil).GetAwsNetworkPerformanceDataPages), arg0, arg1)
-}
-
-// GetAwsNetworkPerformanceDataPagesWithContext mocks base method.
-func (m *MockEC2API) GetAwsNetworkPerformanceDataPagesWithContext(arg0 context.Context, arg1 *ec2.GetAwsNetworkPerformanceDataInput, arg2 func(*ec2.GetAwsNetworkPerformanceDataOutput, 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, "GetAwsNetworkPerformanceDataPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetAwsNetworkPerformanceDataPagesWithContext indicates an expected call of GetAwsNetworkPerformanceDataPagesWithContext.
-func (mr *MockEC2APIMockRecorder) GetAwsNetworkPerformanceDataPagesWithContext(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, "GetAwsNetworkPerformanceDataPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetAwsNetworkPerformanceDataPagesWithContext), varargs...)
-}
-
-// GetAwsNetworkPerformanceDataRequest mocks base method.
-func (m *MockEC2API) GetAwsNetworkPerformanceDataRequest(arg0 *ec2.GetAwsNetworkPerformanceDataInput) (*request.Request, *ec2.GetAwsNetworkPerformanceDataOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetAwsNetworkPerformanceDataRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetAwsNetworkPerformanceDataOutput)
-	return ret0, ret1
-}
-
-// GetAwsNetworkPerformanceDataRequest indicates an expected call of GetAwsNetworkPerformanceDataRequest.
-func (mr *MockEC2APIMockRecorder) GetAwsNetworkPerformanceDataRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAwsNetworkPerformanceDataRequest", reflect.TypeOf((*MockEC2API)(nil).GetAwsNetworkPerformanceDataRequest), arg0)
-}
-
-// GetAwsNetworkPerformanceDataWithContext mocks base method.
-func (m *MockEC2API) GetAwsNetworkPerformanceDataWithContext(arg0 context.Context, arg1 *ec2.GetAwsNetworkPerformanceDataInput, arg2 ...request.Option) (*ec2.GetAwsNetworkPerformanceDataOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetAwsNetworkPerformanceDataWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetAwsNetworkPerformanceDataOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetAwsNetworkPerformanceDataWithContext indicates an expected call of GetAwsNetworkPerformanceDataWithContext.
-func (mr *MockEC2APIMockRecorder) GetAwsNetworkPerformanceDataWithContext(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, "GetAwsNetworkPerformanceDataWithContext", reflect.TypeOf((*MockEC2API)(nil).GetAwsNetworkPerformanceDataWithContext), varargs...)
-}
-
-// GetCapacityReservationUsage mocks base method.
-func (m *MockEC2API) GetCapacityReservationUsage(arg0 *ec2.GetCapacityReservationUsageInput) (*ec2.GetCapacityReservationUsageOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetCapacityReservationUsage", arg0)
-	ret0, _ := ret[0].(*ec2.GetCapacityReservationUsageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetCapacityReservationUsage indicates an expected call of GetCapacityReservationUsage.
-func (mr *MockEC2APIMockRecorder) GetCapacityReservationUsage(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCapacityReservationUsage", reflect.TypeOf((*MockEC2API)(nil).GetCapacityReservationUsage), arg0)
-}
-
-// GetCapacityReservationUsageRequest mocks base method.
-func (m *MockEC2API) GetCapacityReservationUsageRequest(arg0 *ec2.GetCapacityReservationUsageInput) (*request.Request, *ec2.GetCapacityReservationUsageOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetCapacityReservationUsageRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetCapacityReservationUsageOutput)
-	return ret0, ret1
-}
-
-// GetCapacityReservationUsageRequest indicates an expected call of GetCapacityReservationUsageRequest.
-func (mr *MockEC2APIMockRecorder) GetCapacityReservationUsageRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCapacityReservationUsageRequest", reflect.TypeOf((*MockEC2API)(nil).GetCapacityReservationUsageRequest), arg0)
-}
-
-// GetCapacityReservationUsageWithContext mocks base method.
-func (m *MockEC2API) GetCapacityReservationUsageWithContext(arg0 context.Context, arg1 *ec2.GetCapacityReservationUsageInput, arg2 ...request.Option) (*ec2.GetCapacityReservationUsageOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetCapacityReservationUsageWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetCapacityReservationUsageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetCapacityReservationUsageWithContext indicates an expected call of GetCapacityReservationUsageWithContext.
-func (mr *MockEC2APIMockRecorder) GetCapacityReservationUsageWithContext(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, "GetCapacityReservationUsageWithContext", reflect.TypeOf((*MockEC2API)(nil).GetCapacityReservationUsageWithContext), varargs...)
-}
-
-// GetCoipPoolUsage mocks base method.
-func (m *MockEC2API) GetCoipPoolUsage(arg0 *ec2.GetCoipPoolUsageInput) (*ec2.GetCoipPoolUsageOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetCoipPoolUsage", arg0)
-	ret0, _ := ret[0].(*ec2.GetCoipPoolUsageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetCoipPoolUsage indicates an expected call of GetCoipPoolUsage.
-func (mr *MockEC2APIMockRecorder) GetCoipPoolUsage(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCoipPoolUsage", reflect.TypeOf((*MockEC2API)(nil).GetCoipPoolUsage), arg0)
-}
-
-// GetCoipPoolUsageRequest mocks base method.
-func (m *MockEC2API) GetCoipPoolUsageRequest(arg0 *ec2.GetCoipPoolUsageInput) (*request.Request, *ec2.GetCoipPoolUsageOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetCoipPoolUsageRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetCoipPoolUsageOutput)
-	return ret0, ret1
-}
-
-// GetCoipPoolUsageRequest indicates an expected call of GetCoipPoolUsageRequest.
-func (mr *MockEC2APIMockRecorder) GetCoipPoolUsageRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCoipPoolUsageRequest", reflect.TypeOf((*MockEC2API)(nil).GetCoipPoolUsageRequest), arg0)
-}
-
-// GetCoipPoolUsageWithContext mocks base method.
-func (m *MockEC2API) GetCoipPoolUsageWithContext(arg0 context.Context, arg1 *ec2.GetCoipPoolUsageInput, arg2 ...request.Option) (*ec2.GetCoipPoolUsageOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetCoipPoolUsageWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetCoipPoolUsageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetCoipPoolUsageWithContext indicates an expected call of GetCoipPoolUsageWithContext.
-func (mr *MockEC2APIMockRecorder) GetCoipPoolUsageWithContext(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, "GetCoipPoolUsageWithContext", reflect.TypeOf((*MockEC2API)(nil).GetCoipPoolUsageWithContext), varargs...)
-}
-
-// GetConsoleOutput mocks base method.
-func (m *MockEC2API) GetConsoleOutput(arg0 *ec2.GetConsoleOutputInput) (*ec2.GetConsoleOutputOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetConsoleOutput", arg0)
-	ret0, _ := ret[0].(*ec2.GetConsoleOutputOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetConsoleOutput indicates an expected call of GetConsoleOutput.
-func (mr *MockEC2APIMockRecorder) GetConsoleOutput(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleOutput", reflect.TypeOf((*MockEC2API)(nil).GetConsoleOutput), arg0)
-}
-
-// GetConsoleOutputRequest mocks base method.
-func (m *MockEC2API) GetConsoleOutputRequest(arg0 *ec2.GetConsoleOutputInput) (*request.Request, *ec2.GetConsoleOutputOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetConsoleOutputRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetConsoleOutputOutput)
-	return ret0, ret1
-}
-
-// GetConsoleOutputRequest indicates an expected call of GetConsoleOutputRequest.
-func (mr *MockEC2APIMockRecorder) GetConsoleOutputRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleOutputRequest", reflect.TypeOf((*MockEC2API)(nil).GetConsoleOutputRequest), arg0)
-}
-
-// GetConsoleOutputWithContext mocks base method.
-func (m *MockEC2API) GetConsoleOutputWithContext(arg0 context.Context, arg1 *ec2.GetConsoleOutputInput, arg2 ...request.Option) (*ec2.GetConsoleOutputOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetConsoleOutputWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetConsoleOutputOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetConsoleOutputWithContext indicates an expected call of GetConsoleOutputWithContext.
-func (mr *MockEC2APIMockRecorder) GetConsoleOutputWithContext(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, "GetConsoleOutputWithContext", reflect.TypeOf((*MockEC2API)(nil).GetConsoleOutputWithContext), varargs...)
-}
-
-// GetConsoleScreenshot mocks base method.
-func (m *MockEC2API) GetConsoleScreenshot(arg0 *ec2.GetConsoleScreenshotInput) (*ec2.GetConsoleScreenshotOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetConsoleScreenshot", arg0)
-	ret0, _ := ret[0].(*ec2.GetConsoleScreenshotOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetConsoleScreenshot indicates an expected call of GetConsoleScreenshot.
-func (mr *MockEC2APIMockRecorder) GetConsoleScreenshot(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleScreenshot", reflect.TypeOf((*MockEC2API)(nil).GetConsoleScreenshot), arg0)
-}
-
-// GetConsoleScreenshotRequest mocks base method.
-func (m *MockEC2API) GetConsoleScreenshotRequest(arg0 *ec2.GetConsoleScreenshotInput) (*request.Request, *ec2.GetConsoleScreenshotOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetConsoleScreenshotRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetConsoleScreenshotOutput)
-	return ret0, ret1
-}
-
-// GetConsoleScreenshotRequest indicates an expected call of GetConsoleScreenshotRequest.
-func (mr *MockEC2APIMockRecorder) GetConsoleScreenshotRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleScreenshotRequest", reflect.TypeOf((*MockEC2API)(nil).GetConsoleScreenshotRequest), arg0)
-}
-
-// GetConsoleScreenshotWithContext mocks base method.
-func (m *MockEC2API) GetConsoleScreenshotWithContext(arg0 context.Context, arg1 *ec2.GetConsoleScreenshotInput, arg2 ...request.Option) (*ec2.GetConsoleScreenshotOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetConsoleScreenshotWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetConsoleScreenshotOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetConsoleScreenshotWithContext indicates an expected call of GetConsoleScreenshotWithContext.
-func (mr *MockEC2APIMockRecorder) GetConsoleScreenshotWithContext(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, "GetConsoleScreenshotWithContext", reflect.TypeOf((*MockEC2API)(nil).GetConsoleScreenshotWithContext), varargs...)
-}
-
-// GetDefaultCreditSpecification mocks base method.
-func (m *MockEC2API) GetDefaultCreditSpecification(arg0 *ec2.GetDefaultCreditSpecificationInput) (*ec2.GetDefaultCreditSpecificationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetDefaultCreditSpecification", arg0)
-	ret0, _ := ret[0].(*ec2.GetDefaultCreditSpecificationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetDefaultCreditSpecification indicates an expected call of GetDefaultCreditSpecification.
-func (mr *MockEC2APIMockRecorder) GetDefaultCreditSpecification(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultCreditSpecification", reflect.TypeOf((*MockEC2API)(nil).GetDefaultCreditSpecification), arg0)
-}
-
-// GetDefaultCreditSpecificationRequest mocks base method.
-func (m *MockEC2API) GetDefaultCreditSpecificationRequest(arg0 *ec2.GetDefaultCreditSpecificationInput) (*request.Request, *ec2.GetDefaultCreditSpecificationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetDefaultCreditSpecificationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetDefaultCreditSpecificationOutput)
-	return ret0, ret1
-}
-
-// GetDefaultCreditSpecificationRequest indicates an expected call of GetDefaultCreditSpecificationRequest.
-func (mr *MockEC2APIMockRecorder) GetDefaultCreditSpecificationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultCreditSpecificationRequest", reflect.TypeOf((*MockEC2API)(nil).GetDefaultCreditSpecificationRequest), arg0)
-}
-
-// GetDefaultCreditSpecificationWithContext mocks base method.
-func (m *MockEC2API) GetDefaultCreditSpecificationWithContext(arg0 context.Context, arg1 *ec2.GetDefaultCreditSpecificationInput, arg2 ...request.Option) (*ec2.GetDefaultCreditSpecificationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetDefaultCreditSpecificationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetDefaultCreditSpecificationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetDefaultCreditSpecificationWithContext indicates an expected call of GetDefaultCreditSpecificationWithContext.
-func (mr *MockEC2APIMockRecorder) GetDefaultCreditSpecificationWithContext(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, "GetDefaultCreditSpecificationWithContext", reflect.TypeOf((*MockEC2API)(nil).GetDefaultCreditSpecificationWithContext), varargs...)
-}
-
-// GetEbsDefaultKmsKeyId mocks base method.
-func (m *MockEC2API) GetEbsDefaultKmsKeyId(arg0 *ec2.GetEbsDefaultKmsKeyIdInput) (*ec2.GetEbsDefaultKmsKeyIdOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetEbsDefaultKmsKeyId", arg0)
-	ret0, _ := ret[0].(*ec2.GetEbsDefaultKmsKeyIdOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetEbsDefaultKmsKeyId indicates an expected call of GetEbsDefaultKmsKeyId.
-func (mr *MockEC2APIMockRecorder) GetEbsDefaultKmsKeyId(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsDefaultKmsKeyId", reflect.TypeOf((*MockEC2API)(nil).GetEbsDefaultKmsKeyId), arg0)
-}
-
-// GetEbsDefaultKmsKeyIdRequest mocks base method.
-func (m *MockEC2API) GetEbsDefaultKmsKeyIdRequest(arg0 *ec2.GetEbsDefaultKmsKeyIdInput) (*request.Request, *ec2.GetEbsDefaultKmsKeyIdOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetEbsDefaultKmsKeyIdRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetEbsDefaultKmsKeyIdOutput)
-	return ret0, ret1
-}
-
-// GetEbsDefaultKmsKeyIdRequest indicates an expected call of GetEbsDefaultKmsKeyIdRequest.
-func (mr *MockEC2APIMockRecorder) GetEbsDefaultKmsKeyIdRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsDefaultKmsKeyIdRequest", reflect.TypeOf((*MockEC2API)(nil).GetEbsDefaultKmsKeyIdRequest), arg0)
-}
-
-// GetEbsDefaultKmsKeyIdWithContext mocks base method.
-func (m *MockEC2API) GetEbsDefaultKmsKeyIdWithContext(arg0 context.Context, arg1 *ec2.GetEbsDefaultKmsKeyIdInput, arg2 ...request.Option) (*ec2.GetEbsDefaultKmsKeyIdOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetEbsDefaultKmsKeyIdWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetEbsDefaultKmsKeyIdOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetEbsDefaultKmsKeyIdWithContext indicates an expected call of GetEbsDefaultKmsKeyIdWithContext.
-func (mr *MockEC2APIMockRecorder) GetEbsDefaultKmsKeyIdWithContext(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, "GetEbsDefaultKmsKeyIdWithContext", reflect.TypeOf((*MockEC2API)(nil).GetEbsDefaultKmsKeyIdWithContext), varargs...)
-}
-
-// GetEbsEncryptionByDefault mocks base method.
-func (m *MockEC2API) GetEbsEncryptionByDefault(arg0 *ec2.GetEbsEncryptionByDefaultInput) (*ec2.GetEbsEncryptionByDefaultOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetEbsEncryptionByDefault", arg0)
-	ret0, _ := ret[0].(*ec2.GetEbsEncryptionByDefaultOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetEbsEncryptionByDefault indicates an expected call of GetEbsEncryptionByDefault.
-func (mr *MockEC2APIMockRecorder) GetEbsEncryptionByDefault(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsEncryptionByDefault", reflect.TypeOf((*MockEC2API)(nil).GetEbsEncryptionByDefault), arg0)
-}
-
-// GetEbsEncryptionByDefaultRequest mocks base method.
-func (m *MockEC2API) GetEbsEncryptionByDefaultRequest(arg0 *ec2.GetEbsEncryptionByDefaultInput) (*request.Request, *ec2.GetEbsEncryptionByDefaultOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetEbsEncryptionByDefaultRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetEbsEncryptionByDefaultOutput)
-	return ret0, ret1
-}
-
-// GetEbsEncryptionByDefaultRequest indicates an expected call of GetEbsEncryptionByDefaultRequest.
-func (mr *MockEC2APIMockRecorder) GetEbsEncryptionByDefaultRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsEncryptionByDefaultRequest", reflect.TypeOf((*MockEC2API)(nil).GetEbsEncryptionByDefaultRequest), arg0)
-}
-
-// GetEbsEncryptionByDefaultWithContext mocks base method.
-func (m *MockEC2API) GetEbsEncryptionByDefaultWithContext(arg0 context.Context, arg1 *ec2.GetEbsEncryptionByDefaultInput, arg2 ...request.Option) (*ec2.GetEbsEncryptionByDefaultOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetEbsEncryptionByDefaultWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetEbsEncryptionByDefaultOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetEbsEncryptionByDefaultWithContext indicates an expected call of GetEbsEncryptionByDefaultWithContext.
-func (mr *MockEC2APIMockRecorder) GetEbsEncryptionByDefaultWithContext(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, "GetEbsEncryptionByDefaultWithContext", reflect.TypeOf((*MockEC2API)(nil).GetEbsEncryptionByDefaultWithContext), varargs...)
-}
-
-// GetFlowLogsIntegrationTemplate mocks base method.
-func (m *MockEC2API) GetFlowLogsIntegrationTemplate(arg0 *ec2.GetFlowLogsIntegrationTemplateInput) (*ec2.GetFlowLogsIntegrationTemplateOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetFlowLogsIntegrationTemplate", arg0)
-	ret0, _ := ret[0].(*ec2.GetFlowLogsIntegrationTemplateOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetFlowLogsIntegrationTemplate indicates an expected call of GetFlowLogsIntegrationTemplate.
-func (mr *MockEC2APIMockRecorder) GetFlowLogsIntegrationTemplate(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFlowLogsIntegrationTemplate", reflect.TypeOf((*MockEC2API)(nil).GetFlowLogsIntegrationTemplate), arg0)
-}
-
-// GetFlowLogsIntegrationTemplateRequest mocks base method.
-func (m *MockEC2API) GetFlowLogsIntegrationTemplateRequest(arg0 *ec2.GetFlowLogsIntegrationTemplateInput) (*request.Request, *ec2.GetFlowLogsIntegrationTemplateOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetFlowLogsIntegrationTemplateRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetFlowLogsIntegrationTemplateOutput)
-	return ret0, ret1
-}
-
-// GetFlowLogsIntegrationTemplateRequest indicates an expected call of GetFlowLogsIntegrationTemplateRequest.
-func (mr *MockEC2APIMockRecorder) GetFlowLogsIntegrationTemplateRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFlowLogsIntegrationTemplateRequest", reflect.TypeOf((*MockEC2API)(nil).GetFlowLogsIntegrationTemplateRequest), arg0)
-}
-
-// GetFlowLogsIntegrationTemplateWithContext mocks base method.
-func (m *MockEC2API) GetFlowLogsIntegrationTemplateWithContext(arg0 context.Context, arg1 *ec2.GetFlowLogsIntegrationTemplateInput, arg2 ...request.Option) (*ec2.GetFlowLogsIntegrationTemplateOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetFlowLogsIntegrationTemplateWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetFlowLogsIntegrationTemplateOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetFlowLogsIntegrationTemplateWithContext indicates an expected call of GetFlowLogsIntegrationTemplateWithContext.
-func (mr *MockEC2APIMockRecorder) GetFlowLogsIntegrationTemplateWithContext(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, "GetFlowLogsIntegrationTemplateWithContext", reflect.TypeOf((*MockEC2API)(nil).GetFlowLogsIntegrationTemplateWithContext), varargs...)
-}
-
-// GetGroupsForCapacityReservation mocks base method.
-func (m *MockEC2API) GetGroupsForCapacityReservation(arg0 *ec2.GetGroupsForCapacityReservationInput) (*ec2.GetGroupsForCapacityReservationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetGroupsForCapacityReservation", arg0)
-	ret0, _ := ret[0].(*ec2.GetGroupsForCapacityReservationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetGroupsForCapacityReservation indicates an expected call of GetGroupsForCapacityReservation.
-func (mr *MockEC2APIMockRecorder) GetGroupsForCapacityReservation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupsForCapacityReservation", reflect.TypeOf((*MockEC2API)(nil).GetGroupsForCapacityReservation), arg0)
-}
-
-// GetGroupsForCapacityReservationPages mocks base method.
-func (m *MockEC2API) GetGroupsForCapacityReservationPages(arg0 *ec2.GetGroupsForCapacityReservationInput, arg1 func(*ec2.GetGroupsForCapacityReservationOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetGroupsForCapacityReservationPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetGroupsForCapacityReservationPages indicates an expected call of GetGroupsForCapacityReservationPages.
-func (mr *MockEC2APIMockRecorder) GetGroupsForCapacityReservationPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupsForCapacityReservationPages", reflect.TypeOf((*MockEC2API)(nil).GetGroupsForCapacityReservationPages), arg0, arg1)
-}
-
-// GetGroupsForCapacityReservationPagesWithContext mocks base method.
-func (m *MockEC2API) GetGroupsForCapacityReservationPagesWithContext(arg0 context.Context, arg1 *ec2.GetGroupsForCapacityReservationInput, arg2 func(*ec2.GetGroupsForCapacityReservationOutput, 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, "GetGroupsForCapacityReservationPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetGroupsForCapacityReservationPagesWithContext indicates an expected call of GetGroupsForCapacityReservationPagesWithContext.
-func (mr *MockEC2APIMockRecorder) GetGroupsForCapacityReservationPagesWithContext(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, "GetGroupsForCapacityReservationPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetGroupsForCapacityReservationPagesWithContext), varargs...)
-}
-
-// GetGroupsForCapacityReservationRequest mocks base method.
-func (m *MockEC2API) GetGroupsForCapacityReservationRequest(arg0 *ec2.GetGroupsForCapacityReservationInput) (*request.Request, *ec2.GetGroupsForCapacityReservationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetGroupsForCapacityReservationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetGroupsForCapacityReservationOutput)
-	return ret0, ret1
-}
-
-// GetGroupsForCapacityReservationRequest indicates an expected call of GetGroupsForCapacityReservationRequest.
-func (mr *MockEC2APIMockRecorder) GetGroupsForCapacityReservationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupsForCapacityReservationRequest", reflect.TypeOf((*MockEC2API)(nil).GetGroupsForCapacityReservationRequest), arg0)
-}
-
-// GetGroupsForCapacityReservationWithContext mocks base method.
-func (m *MockEC2API) GetGroupsForCapacityReservationWithContext(arg0 context.Context, arg1 *ec2.GetGroupsForCapacityReservationInput, arg2 ...request.Option) (*ec2.GetGroupsForCapacityReservationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetGroupsForCapacityReservationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetGroupsForCapacityReservationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetGroupsForCapacityReservationWithContext indicates an expected call of GetGroupsForCapacityReservationWithContext.
-func (mr *MockEC2APIMockRecorder) GetGroupsForCapacityReservationWithContext(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, "GetGroupsForCapacityReservationWithContext", reflect.TypeOf((*MockEC2API)(nil).GetGroupsForCapacityReservationWithContext), varargs...)
-}
-
-// GetHostReservationPurchasePreview mocks base method.
-func (m *MockEC2API) GetHostReservationPurchasePreview(arg0 *ec2.GetHostReservationPurchasePreviewInput) (*ec2.GetHostReservationPurchasePreviewOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetHostReservationPurchasePreview", arg0)
-	ret0, _ := ret[0].(*ec2.GetHostReservationPurchasePreviewOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetHostReservationPurchasePreview indicates an expected call of GetHostReservationPurchasePreview.
-func (mr *MockEC2APIMockRecorder) GetHostReservationPurchasePreview(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostReservationPurchasePreview", reflect.TypeOf((*MockEC2API)(nil).GetHostReservationPurchasePreview), arg0)
-}
-
-// GetHostReservationPurchasePreviewRequest mocks base method.
-func (m *MockEC2API) GetHostReservationPurchasePreviewRequest(arg0 *ec2.GetHostReservationPurchasePreviewInput) (*request.Request, *ec2.GetHostReservationPurchasePreviewOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetHostReservationPurchasePreviewRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetHostReservationPurchasePreviewOutput)
-	return ret0, ret1
-}
-
-// GetHostReservationPurchasePreviewRequest indicates an expected call of GetHostReservationPurchasePreviewRequest.
-func (mr *MockEC2APIMockRecorder) GetHostReservationPurchasePreviewRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostReservationPurchasePreviewRequest", reflect.TypeOf((*MockEC2API)(nil).GetHostReservationPurchasePreviewRequest), arg0)
-}
-
-// GetHostReservationPurchasePreviewWithContext mocks base method.
-func (m *MockEC2API) GetHostReservationPurchasePreviewWithContext(arg0 context.Context, arg1 *ec2.GetHostReservationPurchasePreviewInput, arg2 ...request.Option) (*ec2.GetHostReservationPurchasePreviewOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetHostReservationPurchasePreviewWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetHostReservationPurchasePreviewOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetHostReservationPurchasePreviewWithContext indicates an expected call of GetHostReservationPurchasePreviewWithContext.
-func (mr *MockEC2APIMockRecorder) GetHostReservationPurchasePreviewWithContext(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, "GetHostReservationPurchasePreviewWithContext", reflect.TypeOf((*MockEC2API)(nil).GetHostReservationPurchasePreviewWithContext), varargs...)
-}
-
-// GetImageBlockPublicAccessState mocks base method.
-func (m *MockEC2API) GetImageBlockPublicAccessState(arg0 *ec2.GetImageBlockPublicAccessStateInput) (*ec2.GetImageBlockPublicAccessStateOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetImageBlockPublicAccessState", arg0)
-	ret0, _ := ret[0].(*ec2.GetImageBlockPublicAccessStateOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetImageBlockPublicAccessState indicates an expected call of GetImageBlockPublicAccessState.
-func (mr *MockEC2APIMockRecorder) GetImageBlockPublicAccessState(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageBlockPublicAccessState", reflect.TypeOf((*MockEC2API)(nil).GetImageBlockPublicAccessState), arg0)
-}
-
-// GetImageBlockPublicAccessStateRequest mocks base method.
-func (m *MockEC2API) GetImageBlockPublicAccessStateRequest(arg0 *ec2.GetImageBlockPublicAccessStateInput) (*request.Request, *ec2.GetImageBlockPublicAccessStateOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetImageBlockPublicAccessStateRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetImageBlockPublicAccessStateOutput)
-	return ret0, ret1
-}
-
-// GetImageBlockPublicAccessStateRequest indicates an expected call of GetImageBlockPublicAccessStateRequest.
-func (mr *MockEC2APIMockRecorder) GetImageBlockPublicAccessStateRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageBlockPublicAccessStateRequest", reflect.TypeOf((*MockEC2API)(nil).GetImageBlockPublicAccessStateRequest), arg0)
-}
-
-// GetImageBlockPublicAccessStateWithContext mocks base method.
-func (m *MockEC2API) GetImageBlockPublicAccessStateWithContext(arg0 context.Context, arg1 *ec2.GetImageBlockPublicAccessStateInput, arg2 ...request.Option) (*ec2.GetImageBlockPublicAccessStateOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetImageBlockPublicAccessStateWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetImageBlockPublicAccessStateOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetImageBlockPublicAccessStateWithContext indicates an expected call of GetImageBlockPublicAccessStateWithContext.
-func (mr *MockEC2APIMockRecorder) GetImageBlockPublicAccessStateWithContext(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, "GetImageBlockPublicAccessStateWithContext", reflect.TypeOf((*MockEC2API)(nil).GetImageBlockPublicAccessStateWithContext), varargs...)
-}
-
-// GetInstanceMetadataDefaults mocks base method.
-func (m *MockEC2API) GetInstanceMetadataDefaults(arg0 *ec2.GetInstanceMetadataDefaultsInput) (*ec2.GetInstanceMetadataDefaultsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetInstanceMetadataDefaults", arg0)
-	ret0, _ := ret[0].(*ec2.GetInstanceMetadataDefaultsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetInstanceMetadataDefaults indicates an expected call of GetInstanceMetadataDefaults.
-func (mr *MockEC2APIMockRecorder) GetInstanceMetadataDefaults(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceMetadataDefaults", reflect.TypeOf((*MockEC2API)(nil).GetInstanceMetadataDefaults), arg0)
-}
-
-// GetInstanceMetadataDefaultsRequest mocks base method.
-func (m *MockEC2API) GetInstanceMetadataDefaultsRequest(arg0 *ec2.GetInstanceMetadataDefaultsInput) (*request.Request, *ec2.GetInstanceMetadataDefaultsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetInstanceMetadataDefaultsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetInstanceMetadataDefaultsOutput)
-	return ret0, ret1
-}
-
-// GetInstanceMetadataDefaultsRequest indicates an expected call of GetInstanceMetadataDefaultsRequest.
-func (mr *MockEC2APIMockRecorder) GetInstanceMetadataDefaultsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceMetadataDefaultsRequest", reflect.TypeOf((*MockEC2API)(nil).GetInstanceMetadataDefaultsRequest), arg0)
-}
-
-// GetInstanceMetadataDefaultsWithContext mocks base method.
-func (m *MockEC2API) GetInstanceMetadataDefaultsWithContext(arg0 context.Context, arg1 *ec2.GetInstanceMetadataDefaultsInput, arg2 ...request.Option) (*ec2.GetInstanceMetadataDefaultsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetInstanceMetadataDefaultsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetInstanceMetadataDefaultsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetInstanceMetadataDefaultsWithContext indicates an expected call of GetInstanceMetadataDefaultsWithContext.
-func (mr *MockEC2APIMockRecorder) GetInstanceMetadataDefaultsWithContext(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, "GetInstanceMetadataDefaultsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetInstanceMetadataDefaultsWithContext), varargs...)
-}
-
-// GetInstanceTpmEkPub mocks base method.
-func (m *MockEC2API) GetInstanceTpmEkPub(arg0 *ec2.GetInstanceTpmEkPubInput) (*ec2.GetInstanceTpmEkPubOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetInstanceTpmEkPub", arg0)
-	ret0, _ := ret[0].(*ec2.GetInstanceTpmEkPubOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetInstanceTpmEkPub indicates an expected call of GetInstanceTpmEkPub.
-func (mr *MockEC2APIMockRecorder) GetInstanceTpmEkPub(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceTpmEkPub", reflect.TypeOf((*MockEC2API)(nil).GetInstanceTpmEkPub), arg0)
-}
-
-// GetInstanceTpmEkPubRequest mocks base method.
-func (m *MockEC2API) GetInstanceTpmEkPubRequest(arg0 *ec2.GetInstanceTpmEkPubInput) (*request.Request, *ec2.GetInstanceTpmEkPubOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetInstanceTpmEkPubRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetInstanceTpmEkPubOutput)
-	return ret0, ret1
-}
-
-// GetInstanceTpmEkPubRequest indicates an expected call of GetInstanceTpmEkPubRequest.
-func (mr *MockEC2APIMockRecorder) GetInstanceTpmEkPubRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceTpmEkPubRequest", reflect.TypeOf((*MockEC2API)(nil).GetInstanceTpmEkPubRequest), arg0)
-}
-
-// GetInstanceTpmEkPubWithContext mocks base method.
-func (m *MockEC2API) GetInstanceTpmEkPubWithContext(arg0 context.Context, arg1 *ec2.GetInstanceTpmEkPubInput, arg2 ...request.Option) (*ec2.GetInstanceTpmEkPubOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetInstanceTpmEkPubWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetInstanceTpmEkPubOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetInstanceTpmEkPubWithContext indicates an expected call of GetInstanceTpmEkPubWithContext.
-func (mr *MockEC2APIMockRecorder) GetInstanceTpmEkPubWithContext(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, "GetInstanceTpmEkPubWithContext", reflect.TypeOf((*MockEC2API)(nil).GetInstanceTpmEkPubWithContext), varargs...)
-}
-
-// GetInstanceTypesFromInstanceRequirements mocks base method.
-func (m *MockEC2API) GetInstanceTypesFromInstanceRequirements(arg0 *ec2.GetInstanceTypesFromInstanceRequirementsInput) (*ec2.GetInstanceTypesFromInstanceRequirementsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetInstanceTypesFromInstanceRequirements", arg0)
-	ret0, _ := ret[0].(*ec2.GetInstanceTypesFromInstanceRequirementsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetInstanceTypesFromInstanceRequirements indicates an expected call of GetInstanceTypesFromInstanceRequirements.
-func (mr *MockEC2APIMockRecorder) GetInstanceTypesFromInstanceRequirements(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceTypesFromInstanceRequirements", reflect.TypeOf((*MockEC2API)(nil).GetInstanceTypesFromInstanceRequirements), arg0)
-}
-
-// GetInstanceTypesFromInstanceRequirementsPages mocks base method.
-func (m *MockEC2API) GetInstanceTypesFromInstanceRequirementsPages(arg0 *ec2.GetInstanceTypesFromInstanceRequirementsInput, arg1 func(*ec2.GetInstanceTypesFromInstanceRequirementsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetInstanceTypesFromInstanceRequirementsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetInstanceTypesFromInstanceRequirementsPages indicates an expected call of GetInstanceTypesFromInstanceRequirementsPages.
-func (mr *MockEC2APIMockRecorder) GetInstanceTypesFromInstanceRequirementsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceTypesFromInstanceRequirementsPages", reflect.TypeOf((*MockEC2API)(nil).GetInstanceTypesFromInstanceRequirementsPages), arg0, arg1)
-}
-
-// GetInstanceTypesFromInstanceRequirementsPagesWithContext mocks base method.
-func (m *MockEC2API) GetInstanceTypesFromInstanceRequirementsPagesWithContext(arg0 context.Context, arg1 *ec2.GetInstanceTypesFromInstanceRequirementsInput, arg2 func(*ec2.GetInstanceTypesFromInstanceRequirementsOutput, 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, "GetInstanceTypesFromInstanceRequirementsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetInstanceTypesFromInstanceRequirementsPagesWithContext indicates an expected call of GetInstanceTypesFromInstanceRequirementsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) GetInstanceTypesFromInstanceRequirementsPagesWithContext(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, "GetInstanceTypesFromInstanceRequirementsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetInstanceTypesFromInstanceRequirementsPagesWithContext), varargs...)
-}
-
-// GetInstanceTypesFromInstanceRequirementsRequest mocks base method.
-func (m *MockEC2API) GetInstanceTypesFromInstanceRequirementsRequest(arg0 *ec2.GetInstanceTypesFromInstanceRequirementsInput) (*request.Request, *ec2.GetInstanceTypesFromInstanceRequirementsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetInstanceTypesFromInstanceRequirementsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetInstanceTypesFromInstanceRequirementsOutput)
-	return ret0, ret1
-}
-
-// GetInstanceTypesFromInstanceRequirementsRequest indicates an expected call of GetInstanceTypesFromInstanceRequirementsRequest.
-func (mr *MockEC2APIMockRecorder) GetInstanceTypesFromInstanceRequirementsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceTypesFromInstanceRequirementsRequest", reflect.TypeOf((*MockEC2API)(nil).GetInstanceTypesFromInstanceRequirementsRequest), arg0)
-}
-
-// GetInstanceTypesFromInstanceRequirementsWithContext mocks base method.
-func (m *MockEC2API) GetInstanceTypesFromInstanceRequirementsWithContext(arg0 context.Context, arg1 *ec2.GetInstanceTypesFromInstanceRequirementsInput, arg2 ...request.Option) (*ec2.GetInstanceTypesFromInstanceRequirementsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetInstanceTypesFromInstanceRequirementsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetInstanceTypesFromInstanceRequirementsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetInstanceTypesFromInstanceRequirementsWithContext indicates an expected call of GetInstanceTypesFromInstanceRequirementsWithContext.
-func (mr *MockEC2APIMockRecorder) GetInstanceTypesFromInstanceRequirementsWithContext(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, "GetInstanceTypesFromInstanceRequirementsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetInstanceTypesFromInstanceRequirementsWithContext), varargs...)
-}
-
-// GetInstanceUefiData mocks base method.
-func (m *MockEC2API) GetInstanceUefiData(arg0 *ec2.GetInstanceUefiDataInput) (*ec2.GetInstanceUefiDataOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetInstanceUefiData", arg0)
-	ret0, _ := ret[0].(*ec2.GetInstanceUefiDataOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetInstanceUefiData indicates an expected call of GetInstanceUefiData.
-func (mr *MockEC2APIMockRecorder) GetInstanceUefiData(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceUefiData", reflect.TypeOf((*MockEC2API)(nil).GetInstanceUefiData), arg0)
-}
-
-// GetInstanceUefiDataRequest mocks base method.
-func (m *MockEC2API) GetInstanceUefiDataRequest(arg0 *ec2.GetInstanceUefiDataInput) (*request.Request, *ec2.GetInstanceUefiDataOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetInstanceUefiDataRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetInstanceUefiDataOutput)
-	return ret0, ret1
-}
-
-// GetInstanceUefiDataRequest indicates an expected call of GetInstanceUefiDataRequest.
-func (mr *MockEC2APIMockRecorder) GetInstanceUefiDataRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceUefiDataRequest", reflect.TypeOf((*MockEC2API)(nil).GetInstanceUefiDataRequest), arg0)
-}
-
-// GetInstanceUefiDataWithContext mocks base method.
-func (m *MockEC2API) GetInstanceUefiDataWithContext(arg0 context.Context, arg1 *ec2.GetInstanceUefiDataInput, arg2 ...request.Option) (*ec2.GetInstanceUefiDataOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetInstanceUefiDataWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetInstanceUefiDataOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetInstanceUefiDataWithContext indicates an expected call of GetInstanceUefiDataWithContext.
-func (mr *MockEC2APIMockRecorder) GetInstanceUefiDataWithContext(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, "GetInstanceUefiDataWithContext", reflect.TypeOf((*MockEC2API)(nil).GetInstanceUefiDataWithContext), varargs...)
-}
-
-// GetIpamAddressHistory mocks base method.
-func (m *MockEC2API) GetIpamAddressHistory(arg0 *ec2.GetIpamAddressHistoryInput) (*ec2.GetIpamAddressHistoryOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetIpamAddressHistory", arg0)
-	ret0, _ := ret[0].(*ec2.GetIpamAddressHistoryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetIpamAddressHistory indicates an expected call of GetIpamAddressHistory.
-func (mr *MockEC2APIMockRecorder) GetIpamAddressHistory(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamAddressHistory", reflect.TypeOf((*MockEC2API)(nil).GetIpamAddressHistory), arg0)
-}
-
-// GetIpamAddressHistoryPages mocks base method.
-func (m *MockEC2API) GetIpamAddressHistoryPages(arg0 *ec2.GetIpamAddressHistoryInput, arg1 func(*ec2.GetIpamAddressHistoryOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetIpamAddressHistoryPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetIpamAddressHistoryPages indicates an expected call of GetIpamAddressHistoryPages.
-func (mr *MockEC2APIMockRecorder) GetIpamAddressHistoryPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamAddressHistoryPages", reflect.TypeOf((*MockEC2API)(nil).GetIpamAddressHistoryPages), arg0, arg1)
-}
-
-// GetIpamAddressHistoryPagesWithContext mocks base method.
-func (m *MockEC2API) GetIpamAddressHistoryPagesWithContext(arg0 context.Context, arg1 *ec2.GetIpamAddressHistoryInput, arg2 func(*ec2.GetIpamAddressHistoryOutput, 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, "GetIpamAddressHistoryPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetIpamAddressHistoryPagesWithContext indicates an expected call of GetIpamAddressHistoryPagesWithContext.
-func (mr *MockEC2APIMockRecorder) GetIpamAddressHistoryPagesWithContext(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, "GetIpamAddressHistoryPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetIpamAddressHistoryPagesWithContext), varargs...)
-}
-
-// GetIpamAddressHistoryRequest mocks base method.
-func (m *MockEC2API) GetIpamAddressHistoryRequest(arg0 *ec2.GetIpamAddressHistoryInput) (*request.Request, *ec2.GetIpamAddressHistoryOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetIpamAddressHistoryRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetIpamAddressHistoryOutput)
-	return ret0, ret1
-}
-
-// GetIpamAddressHistoryRequest indicates an expected call of GetIpamAddressHistoryRequest.
-func (mr *MockEC2APIMockRecorder) GetIpamAddressHistoryRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamAddressHistoryRequest", reflect.TypeOf((*MockEC2API)(nil).GetIpamAddressHistoryRequest), arg0)
-}
-
-// GetIpamAddressHistoryWithContext mocks base method.
-func (m *MockEC2API) GetIpamAddressHistoryWithContext(arg0 context.Context, arg1 *ec2.GetIpamAddressHistoryInput, arg2 ...request.Option) (*ec2.GetIpamAddressHistoryOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetIpamAddressHistoryWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetIpamAddressHistoryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetIpamAddressHistoryWithContext indicates an expected call of GetIpamAddressHistoryWithContext.
-func (mr *MockEC2APIMockRecorder) GetIpamAddressHistoryWithContext(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, "GetIpamAddressHistoryWithContext", reflect.TypeOf((*MockEC2API)(nil).GetIpamAddressHistoryWithContext), varargs...)
-}
-
-// GetIpamDiscoveredAccounts mocks base method.
-func (m *MockEC2API) GetIpamDiscoveredAccounts(arg0 *ec2.GetIpamDiscoveredAccountsInput) (*ec2.GetIpamDiscoveredAccountsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetIpamDiscoveredAccounts", arg0)
-	ret0, _ := ret[0].(*ec2.GetIpamDiscoveredAccountsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetIpamDiscoveredAccounts indicates an expected call of GetIpamDiscoveredAccounts.
-func (mr *MockEC2APIMockRecorder) GetIpamDiscoveredAccounts(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredAccounts", reflect.TypeOf((*MockEC2API)(nil).GetIpamDiscoveredAccounts), arg0)
-}
-
-// GetIpamDiscoveredAccountsPages mocks base method.
-func (m *MockEC2API) GetIpamDiscoveredAccountsPages(arg0 *ec2.GetIpamDiscoveredAccountsInput, arg1 func(*ec2.GetIpamDiscoveredAccountsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetIpamDiscoveredAccountsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetIpamDiscoveredAccountsPages indicates an expected call of GetIpamDiscoveredAccountsPages.
-func (mr *MockEC2APIMockRecorder) GetIpamDiscoveredAccountsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredAccountsPages", reflect.TypeOf((*MockEC2API)(nil).GetIpamDiscoveredAccountsPages), arg0, arg1)
-}
-
-// GetIpamDiscoveredAccountsPagesWithContext mocks base method.
-func (m *MockEC2API) GetIpamDiscoveredAccountsPagesWithContext(arg0 context.Context, arg1 *ec2.GetIpamDiscoveredAccountsInput, arg2 func(*ec2.GetIpamDiscoveredAccountsOutput, 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, "GetIpamDiscoveredAccountsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetIpamDiscoveredAccountsPagesWithContext indicates an expected call of GetIpamDiscoveredAccountsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) GetIpamDiscoveredAccountsPagesWithContext(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, "GetIpamDiscoveredAccountsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetIpamDiscoveredAccountsPagesWithContext), varargs...)
-}
-
-// GetIpamDiscoveredAccountsRequest mocks base method.
-func (m *MockEC2API) GetIpamDiscoveredAccountsRequest(arg0 *ec2.GetIpamDiscoveredAccountsInput) (*request.Request, *ec2.GetIpamDiscoveredAccountsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetIpamDiscoveredAccountsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetIpamDiscoveredAccountsOutput)
-	return ret0, ret1
-}
-
-// GetIpamDiscoveredAccountsRequest indicates an expected call of GetIpamDiscoveredAccountsRequest.
-func (mr *MockEC2APIMockRecorder) GetIpamDiscoveredAccountsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredAccountsRequest", reflect.TypeOf((*MockEC2API)(nil).GetIpamDiscoveredAccountsRequest), arg0)
-}
-
-// GetIpamDiscoveredAccountsWithContext mocks base method.
-func (m *MockEC2API) GetIpamDiscoveredAccountsWithContext(arg0 context.Context, arg1 *ec2.GetIpamDiscoveredAccountsInput, arg2 ...request.Option) (*ec2.GetIpamDiscoveredAccountsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetIpamDiscoveredAccountsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetIpamDiscoveredAccountsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetIpamDiscoveredAccountsWithContext indicates an expected call of GetIpamDiscoveredAccountsWithContext.
-func (mr *MockEC2APIMockRecorder) GetIpamDiscoveredAccountsWithContext(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, "GetIpamDiscoveredAccountsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetIpamDiscoveredAccountsWithContext), varargs...)
-}
-
-// GetIpamDiscoveredPublicAddresses mocks base method.
-func (m *MockEC2API) GetIpamDiscoveredPublicAddresses(arg0 *ec2.GetIpamDiscoveredPublicAddressesInput) (*ec2.GetIpamDiscoveredPublicAddressesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetIpamDiscoveredPublicAddresses", arg0)
-	ret0, _ := ret[0].(*ec2.GetIpamDiscoveredPublicAddressesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetIpamDiscoveredPublicAddresses indicates an expected call of GetIpamDiscoveredPublicAddresses.
-func (mr *MockEC2APIMockRecorder) GetIpamDiscoveredPublicAddresses(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredPublicAddresses", reflect.TypeOf((*MockEC2API)(nil).GetIpamDiscoveredPublicAddresses), arg0)
-}
-
-// GetIpamDiscoveredPublicAddressesRequest mocks base method.
-func (m *MockEC2API) GetIpamDiscoveredPublicAddressesRequest(arg0 *ec2.GetIpamDiscoveredPublicAddressesInput) (*request.Request, *ec2.GetIpamDiscoveredPublicAddressesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetIpamDiscoveredPublicAddressesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetIpamDiscoveredPublicAddressesOutput)
-	return ret0, ret1
-}
-
-// GetIpamDiscoveredPublicAddressesRequest indicates an expected call of GetIpamDiscoveredPublicAddressesRequest.
-func (mr *MockEC2APIMockRecorder) GetIpamDiscoveredPublicAddressesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredPublicAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).GetIpamDiscoveredPublicAddressesRequest), arg0)
-}
-
-// GetIpamDiscoveredPublicAddressesWithContext mocks base method.
-func (m *MockEC2API) GetIpamDiscoveredPublicAddressesWithContext(arg0 context.Context, arg1 *ec2.GetIpamDiscoveredPublicAddressesInput, arg2 ...request.Option) (*ec2.GetIpamDiscoveredPublicAddressesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetIpamDiscoveredPublicAddressesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetIpamDiscoveredPublicAddressesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetIpamDiscoveredPublicAddressesWithContext indicates an expected call of GetIpamDiscoveredPublicAddressesWithContext.
-func (mr *MockEC2APIMockRecorder) GetIpamDiscoveredPublicAddressesWithContext(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, "GetIpamDiscoveredPublicAddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetIpamDiscoveredPublicAddressesWithContext), varargs...)
-}
-
-// GetIpamDiscoveredResourceCidrs mocks base method.
-func (m *MockEC2API) GetIpamDiscoveredResourceCidrs(arg0 *ec2.GetIpamDiscoveredResourceCidrsInput) (*ec2.GetIpamDiscoveredResourceCidrsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetIpamDiscoveredResourceCidrs", arg0)
-	ret0, _ := ret[0].(*ec2.GetIpamDiscoveredResourceCidrsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetIpamDiscoveredResourceCidrs indicates an expected call of GetIpamDiscoveredResourceCidrs.
-func (mr *MockEC2APIMockRecorder) GetIpamDiscoveredResourceCidrs(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredResourceCidrs", reflect.TypeOf((*MockEC2API)(nil).GetIpamDiscoveredResourceCidrs), arg0)
-}
-
-// GetIpamDiscoveredResourceCidrsPages mocks base method.
-func (m *MockEC2API) GetIpamDiscoveredResourceCidrsPages(arg0 *ec2.GetIpamDiscoveredResourceCidrsInput, arg1 func(*ec2.GetIpamDiscoveredResourceCidrsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetIpamDiscoveredResourceCidrsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetIpamDiscoveredResourceCidrsPages indicates an expected call of GetIpamDiscoveredResourceCidrsPages.
-func (mr *MockEC2APIMockRecorder) GetIpamDiscoveredResourceCidrsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredResourceCidrsPages", reflect.TypeOf((*MockEC2API)(nil).GetIpamDiscoveredResourceCidrsPages), arg0, arg1)
-}
-
-// GetIpamDiscoveredResourceCidrsPagesWithContext mocks base method.
-func (m *MockEC2API) GetIpamDiscoveredResourceCidrsPagesWithContext(arg0 context.Context, arg1 *ec2.GetIpamDiscoveredResourceCidrsInput, arg2 func(*ec2.GetIpamDiscoveredResourceCidrsOutput, 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, "GetIpamDiscoveredResourceCidrsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetIpamDiscoveredResourceCidrsPagesWithContext indicates an expected call of GetIpamDiscoveredResourceCidrsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) GetIpamDiscoveredResourceCidrsPagesWithContext(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, "GetIpamDiscoveredResourceCidrsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetIpamDiscoveredResourceCidrsPagesWithContext), varargs...)
-}
-
-// GetIpamDiscoveredResourceCidrsRequest mocks base method.
-func (m *MockEC2API) GetIpamDiscoveredResourceCidrsRequest(arg0 *ec2.GetIpamDiscoveredResourceCidrsInput) (*request.Request, *ec2.GetIpamDiscoveredResourceCidrsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetIpamDiscoveredResourceCidrsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetIpamDiscoveredResourceCidrsOutput)
-	return ret0, ret1
-}
-
-// GetIpamDiscoveredResourceCidrsRequest indicates an expected call of GetIpamDiscoveredResourceCidrsRequest.
-func (mr *MockEC2APIMockRecorder) GetIpamDiscoveredResourceCidrsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredResourceCidrsRequest", reflect.TypeOf((*MockEC2API)(nil).GetIpamDiscoveredResourceCidrsRequest), arg0)
-}
-
-// GetIpamDiscoveredResourceCidrsWithContext mocks base method.
-func (m *MockEC2API) GetIpamDiscoveredResourceCidrsWithContext(arg0 context.Context, arg1 *ec2.GetIpamDiscoveredResourceCidrsInput, arg2 ...request.Option) (*ec2.GetIpamDiscoveredResourceCidrsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetIpamDiscoveredResourceCidrsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetIpamDiscoveredResourceCidrsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetIpamDiscoveredResourceCidrsWithContext indicates an expected call of GetIpamDiscoveredResourceCidrsWithContext.
-func (mr *MockEC2APIMockRecorder) GetIpamDiscoveredResourceCidrsWithContext(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, "GetIpamDiscoveredResourceCidrsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetIpamDiscoveredResourceCidrsWithContext), varargs...)
-}
-
-// GetIpamPoolAllocations mocks base method.
-func (m *MockEC2API) GetIpamPoolAllocations(arg0 *ec2.GetIpamPoolAllocationsInput) (*ec2.GetIpamPoolAllocationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetIpamPoolAllocations", arg0)
-	ret0, _ := ret[0].(*ec2.GetIpamPoolAllocationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetIpamPoolAllocations indicates an expected call of GetIpamPoolAllocations.
-func (mr *MockEC2APIMockRecorder) GetIpamPoolAllocations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamPoolAllocations", reflect.TypeOf((*MockEC2API)(nil).GetIpamPoolAllocations), arg0)
-}
-
-// GetIpamPoolAllocationsPages mocks base method.
-func (m *MockEC2API) GetIpamPoolAllocationsPages(arg0 *ec2.GetIpamPoolAllocationsInput, arg1 func(*ec2.GetIpamPoolAllocationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetIpamPoolAllocationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetIpamPoolAllocationsPages indicates an expected call of GetIpamPoolAllocationsPages.
-func (mr *MockEC2APIMockRecorder) GetIpamPoolAllocationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamPoolAllocationsPages", reflect.TypeOf((*MockEC2API)(nil).GetIpamPoolAllocationsPages), arg0, arg1)
-}
-
-// GetIpamPoolAllocationsPagesWithContext mocks base method.
-func (m *MockEC2API) GetIpamPoolAllocationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetIpamPoolAllocationsInput, arg2 func(*ec2.GetIpamPoolAllocationsOutput, 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, "GetIpamPoolAllocationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetIpamPoolAllocationsPagesWithContext indicates an expected call of GetIpamPoolAllocationsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) GetIpamPoolAllocationsPagesWithContext(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, "GetIpamPoolAllocationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetIpamPoolAllocationsPagesWithContext), varargs...)
-}
-
-// GetIpamPoolAllocationsRequest mocks base method.
-func (m *MockEC2API) GetIpamPoolAllocationsRequest(arg0 *ec2.GetIpamPoolAllocationsInput) (*request.Request, *ec2.GetIpamPoolAllocationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetIpamPoolAllocationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetIpamPoolAllocationsOutput)
-	return ret0, ret1
-}
-
-// GetIpamPoolAllocationsRequest indicates an expected call of GetIpamPoolAllocationsRequest.
-func (mr *MockEC2APIMockRecorder) GetIpamPoolAllocationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamPoolAllocationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetIpamPoolAllocationsRequest), arg0)
-}
-
-// GetIpamPoolAllocationsWithContext mocks base method.
-func (m *MockEC2API) GetIpamPoolAllocationsWithContext(arg0 context.Context, arg1 *ec2.GetIpamPoolAllocationsInput, arg2 ...request.Option) (*ec2.GetIpamPoolAllocationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetIpamPoolAllocationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetIpamPoolAllocationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetIpamPoolAllocationsWithContext indicates an expected call of GetIpamPoolAllocationsWithContext.
-func (mr *MockEC2APIMockRecorder) GetIpamPoolAllocationsWithContext(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, "GetIpamPoolAllocationsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetIpamPoolAllocationsWithContext), varargs...)
-}
-
-// GetIpamPoolCidrs mocks base method.
-func (m *MockEC2API) GetIpamPoolCidrs(arg0 *ec2.GetIpamPoolCidrsInput) (*ec2.GetIpamPoolCidrsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetIpamPoolCidrs", arg0)
-	ret0, _ := ret[0].(*ec2.GetIpamPoolCidrsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetIpamPoolCidrs indicates an expected call of GetIpamPoolCidrs.
-func (mr *MockEC2APIMockRecorder) GetIpamPoolCidrs(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamPoolCidrs", reflect.TypeOf((*MockEC2API)(nil).GetIpamPoolCidrs), arg0)
-}
-
-// GetIpamPoolCidrsPages mocks base method.
-func (m *MockEC2API) GetIpamPoolCidrsPages(arg0 *ec2.GetIpamPoolCidrsInput, arg1 func(*ec2.GetIpamPoolCidrsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetIpamPoolCidrsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetIpamPoolCidrsPages indicates an expected call of GetIpamPoolCidrsPages.
-func (mr *MockEC2APIMockRecorder) GetIpamPoolCidrsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamPoolCidrsPages", reflect.TypeOf((*MockEC2API)(nil).GetIpamPoolCidrsPages), arg0, arg1)
-}
-
-// GetIpamPoolCidrsPagesWithContext mocks base method.
-func (m *MockEC2API) GetIpamPoolCidrsPagesWithContext(arg0 context.Context, arg1 *ec2.GetIpamPoolCidrsInput, arg2 func(*ec2.GetIpamPoolCidrsOutput, 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, "GetIpamPoolCidrsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetIpamPoolCidrsPagesWithContext indicates an expected call of GetIpamPoolCidrsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) GetIpamPoolCidrsPagesWithContext(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, "GetIpamPoolCidrsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetIpamPoolCidrsPagesWithContext), varargs...)
-}
-
-// GetIpamPoolCidrsRequest mocks base method.
-func (m *MockEC2API) GetIpamPoolCidrsRequest(arg0 *ec2.GetIpamPoolCidrsInput) (*request.Request, *ec2.GetIpamPoolCidrsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetIpamPoolCidrsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetIpamPoolCidrsOutput)
-	return ret0, ret1
-}
-
-// GetIpamPoolCidrsRequest indicates an expected call of GetIpamPoolCidrsRequest.
-func (mr *MockEC2APIMockRecorder) GetIpamPoolCidrsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamPoolCidrsRequest", reflect.TypeOf((*MockEC2API)(nil).GetIpamPoolCidrsRequest), arg0)
-}
-
-// GetIpamPoolCidrsWithContext mocks base method.
-func (m *MockEC2API) GetIpamPoolCidrsWithContext(arg0 context.Context, arg1 *ec2.GetIpamPoolCidrsInput, arg2 ...request.Option) (*ec2.GetIpamPoolCidrsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetIpamPoolCidrsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetIpamPoolCidrsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetIpamPoolCidrsWithContext indicates an expected call of GetIpamPoolCidrsWithContext.
-func (mr *MockEC2APIMockRecorder) GetIpamPoolCidrsWithContext(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, "GetIpamPoolCidrsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetIpamPoolCidrsWithContext), varargs...)
-}
-
-// GetIpamResourceCidrs mocks base method.
-func (m *MockEC2API) GetIpamResourceCidrs(arg0 *ec2.GetIpamResourceCidrsInput) (*ec2.GetIpamResourceCidrsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetIpamResourceCidrs", arg0)
-	ret0, _ := ret[0].(*ec2.GetIpamResourceCidrsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetIpamResourceCidrs indicates an expected call of GetIpamResourceCidrs.
-func (mr *MockEC2APIMockRecorder) GetIpamResourceCidrs(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamResourceCidrs", reflect.TypeOf((*MockEC2API)(nil).GetIpamResourceCidrs), arg0)
-}
-
-// GetIpamResourceCidrsPages mocks base method.
-func (m *MockEC2API) GetIpamResourceCidrsPages(arg0 *ec2.GetIpamResourceCidrsInput, arg1 func(*ec2.GetIpamResourceCidrsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetIpamResourceCidrsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetIpamResourceCidrsPages indicates an expected call of GetIpamResourceCidrsPages.
-func (mr *MockEC2APIMockRecorder) GetIpamResourceCidrsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamResourceCidrsPages", reflect.TypeOf((*MockEC2API)(nil).GetIpamResourceCidrsPages), arg0, arg1)
-}
-
-// GetIpamResourceCidrsPagesWithContext mocks base method.
-func (m *MockEC2API) GetIpamResourceCidrsPagesWithContext(arg0 context.Context, arg1 *ec2.GetIpamResourceCidrsInput, arg2 func(*ec2.GetIpamResourceCidrsOutput, 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, "GetIpamResourceCidrsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetIpamResourceCidrsPagesWithContext indicates an expected call of GetIpamResourceCidrsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) GetIpamResourceCidrsPagesWithContext(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, "GetIpamResourceCidrsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetIpamResourceCidrsPagesWithContext), varargs...)
-}
-
-// GetIpamResourceCidrsRequest mocks base method.
-func (m *MockEC2API) GetIpamResourceCidrsRequest(arg0 *ec2.GetIpamResourceCidrsInput) (*request.Request, *ec2.GetIpamResourceCidrsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetIpamResourceCidrsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetIpamResourceCidrsOutput)
-	return ret0, ret1
-}
-
-// GetIpamResourceCidrsRequest indicates an expected call of GetIpamResourceCidrsRequest.
-func (mr *MockEC2APIMockRecorder) GetIpamResourceCidrsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamResourceCidrsRequest", reflect.TypeOf((*MockEC2API)(nil).GetIpamResourceCidrsRequest), arg0)
-}
-
-// GetIpamResourceCidrsWithContext mocks base method.
-func (m *MockEC2API) GetIpamResourceCidrsWithContext(arg0 context.Context, arg1 *ec2.GetIpamResourceCidrsInput, arg2 ...request.Option) (*ec2.GetIpamResourceCidrsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetIpamResourceCidrsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetIpamResourceCidrsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetIpamResourceCidrsWithContext indicates an expected call of GetIpamResourceCidrsWithContext.
-func (mr *MockEC2APIMockRecorder) GetIpamResourceCidrsWithContext(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, "GetIpamResourceCidrsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetIpamResourceCidrsWithContext), varargs...)
-}
-
-// GetLaunchTemplateData mocks base method.
-func (m *MockEC2API) GetLaunchTemplateData(arg0 *ec2.GetLaunchTemplateDataInput) (*ec2.GetLaunchTemplateDataOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetLaunchTemplateData", arg0)
-	ret0, _ := ret[0].(*ec2.GetLaunchTemplateDataOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetLaunchTemplateData indicates an expected call of GetLaunchTemplateData.
-func (mr *MockEC2APIMockRecorder) GetLaunchTemplateData(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLaunchTemplateData", reflect.TypeOf((*MockEC2API)(nil).GetLaunchTemplateData), arg0)
-}
-
-// GetLaunchTemplateDataRequest mocks base method.
-func (m *MockEC2API) GetLaunchTemplateDataRequest(arg0 *ec2.GetLaunchTemplateDataInput) (*request.Request, *ec2.GetLaunchTemplateDataOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetLaunchTemplateDataRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetLaunchTemplateDataOutput)
-	return ret0, ret1
-}
-
-// GetLaunchTemplateDataRequest indicates an expected call of GetLaunchTemplateDataRequest.
-func (mr *MockEC2APIMockRecorder) GetLaunchTemplateDataRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLaunchTemplateDataRequest", reflect.TypeOf((*MockEC2API)(nil).GetLaunchTemplateDataRequest), arg0)
-}
-
-// GetLaunchTemplateDataWithContext mocks base method.
-func (m *MockEC2API) GetLaunchTemplateDataWithContext(arg0 context.Context, arg1 *ec2.GetLaunchTemplateDataInput, arg2 ...request.Option) (*ec2.GetLaunchTemplateDataOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetLaunchTemplateDataWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetLaunchTemplateDataOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetLaunchTemplateDataWithContext indicates an expected call of GetLaunchTemplateDataWithContext.
-func (mr *MockEC2APIMockRecorder) GetLaunchTemplateDataWithContext(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, "GetLaunchTemplateDataWithContext", reflect.TypeOf((*MockEC2API)(nil).GetLaunchTemplateDataWithContext), varargs...)
-}
-
-// GetManagedPrefixListAssociations mocks base method.
-func (m *MockEC2API) GetManagedPrefixListAssociations(arg0 *ec2.GetManagedPrefixListAssociationsInput) (*ec2.GetManagedPrefixListAssociationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetManagedPrefixListAssociations", arg0)
-	ret0, _ := ret[0].(*ec2.GetManagedPrefixListAssociationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetManagedPrefixListAssociations indicates an expected call of GetManagedPrefixListAssociations.
-func (mr *MockEC2APIMockRecorder) GetManagedPrefixListAssociations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListAssociations", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListAssociations), arg0)
-}
-
-// GetManagedPrefixListAssociationsPages mocks base method.
-func (m *MockEC2API) GetManagedPrefixListAssociationsPages(arg0 *ec2.GetManagedPrefixListAssociationsInput, arg1 func(*ec2.GetManagedPrefixListAssociationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetManagedPrefixListAssociationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetManagedPrefixListAssociationsPages indicates an expected call of GetManagedPrefixListAssociationsPages.
-func (mr *MockEC2APIMockRecorder) GetManagedPrefixListAssociationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListAssociationsPages), arg0, arg1)
-}
-
-// GetManagedPrefixListAssociationsPagesWithContext mocks base method.
-func (m *MockEC2API) GetManagedPrefixListAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetManagedPrefixListAssociationsInput, arg2 func(*ec2.GetManagedPrefixListAssociationsOutput, 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, "GetManagedPrefixListAssociationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetManagedPrefixListAssociationsPagesWithContext indicates an expected call of GetManagedPrefixListAssociationsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) GetManagedPrefixListAssociationsPagesWithContext(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, "GetManagedPrefixListAssociationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListAssociationsPagesWithContext), varargs...)
-}
-
-// GetManagedPrefixListAssociationsRequest mocks base method.
-func (m *MockEC2API) GetManagedPrefixListAssociationsRequest(arg0 *ec2.GetManagedPrefixListAssociationsInput) (*request.Request, *ec2.GetManagedPrefixListAssociationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetManagedPrefixListAssociationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetManagedPrefixListAssociationsOutput)
-	return ret0, ret1
-}
-
-// GetManagedPrefixListAssociationsRequest indicates an expected call of GetManagedPrefixListAssociationsRequest.
-func (mr *MockEC2APIMockRecorder) GetManagedPrefixListAssociationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListAssociationsRequest), arg0)
-}
-
-// GetManagedPrefixListAssociationsWithContext mocks base method.
-func (m *MockEC2API) GetManagedPrefixListAssociationsWithContext(arg0 context.Context, arg1 *ec2.GetManagedPrefixListAssociationsInput, arg2 ...request.Option) (*ec2.GetManagedPrefixListAssociationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetManagedPrefixListAssociationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetManagedPrefixListAssociationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetManagedPrefixListAssociationsWithContext indicates an expected call of GetManagedPrefixListAssociationsWithContext.
-func (mr *MockEC2APIMockRecorder) GetManagedPrefixListAssociationsWithContext(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, "GetManagedPrefixListAssociationsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListAssociationsWithContext), varargs...)
-}
-
-// GetManagedPrefixListEntries mocks base method.
-func (m *MockEC2API) GetManagedPrefixListEntries(arg0 *ec2.GetManagedPrefixListEntriesInput) (*ec2.GetManagedPrefixListEntriesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetManagedPrefixListEntries", arg0)
-	ret0, _ := ret[0].(*ec2.GetManagedPrefixListEntriesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetManagedPrefixListEntries indicates an expected call of GetManagedPrefixListEntries.
-func (mr *MockEC2APIMockRecorder) GetManagedPrefixListEntries(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListEntries", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListEntries), arg0)
-}
-
-// GetManagedPrefixListEntriesPages mocks base method.
-func (m *MockEC2API) GetManagedPrefixListEntriesPages(arg0 *ec2.GetManagedPrefixListEntriesInput, arg1 func(*ec2.GetManagedPrefixListEntriesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetManagedPrefixListEntriesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetManagedPrefixListEntriesPages indicates an expected call of GetManagedPrefixListEntriesPages.
-func (mr *MockEC2APIMockRecorder) GetManagedPrefixListEntriesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListEntriesPages", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListEntriesPages), arg0, arg1)
-}
-
-// GetManagedPrefixListEntriesPagesWithContext mocks base method.
-func (m *MockEC2API) GetManagedPrefixListEntriesPagesWithContext(arg0 context.Context, arg1 *ec2.GetManagedPrefixListEntriesInput, arg2 func(*ec2.GetManagedPrefixListEntriesOutput, 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, "GetManagedPrefixListEntriesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetManagedPrefixListEntriesPagesWithContext indicates an expected call of GetManagedPrefixListEntriesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) GetManagedPrefixListEntriesPagesWithContext(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, "GetManagedPrefixListEntriesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListEntriesPagesWithContext), varargs...)
-}
-
-// GetManagedPrefixListEntriesRequest mocks base method.
-func (m *MockEC2API) GetManagedPrefixListEntriesRequest(arg0 *ec2.GetManagedPrefixListEntriesInput) (*request.Request, *ec2.GetManagedPrefixListEntriesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetManagedPrefixListEntriesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetManagedPrefixListEntriesOutput)
-	return ret0, ret1
-}
-
-// GetManagedPrefixListEntriesRequest indicates an expected call of GetManagedPrefixListEntriesRequest.
-func (mr *MockEC2APIMockRecorder) GetManagedPrefixListEntriesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListEntriesRequest", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListEntriesRequest), arg0)
-}
-
-// GetManagedPrefixListEntriesWithContext mocks base method.
-func (m *MockEC2API) GetManagedPrefixListEntriesWithContext(arg0 context.Context, arg1 *ec2.GetManagedPrefixListEntriesInput, arg2 ...request.Option) (*ec2.GetManagedPrefixListEntriesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetManagedPrefixListEntriesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetManagedPrefixListEntriesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetManagedPrefixListEntriesWithContext indicates an expected call of GetManagedPrefixListEntriesWithContext.
-func (mr *MockEC2APIMockRecorder) GetManagedPrefixListEntriesWithContext(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, "GetManagedPrefixListEntriesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListEntriesWithContext), varargs...)
-}
-
-// GetNetworkInsightsAccessScopeAnalysisFindings mocks base method.
-func (m *MockEC2API) GetNetworkInsightsAccessScopeAnalysisFindings(arg0 *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsInput) (*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetNetworkInsightsAccessScopeAnalysisFindings", arg0)
-	ret0, _ := ret[0].(*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetNetworkInsightsAccessScopeAnalysisFindings indicates an expected call of GetNetworkInsightsAccessScopeAnalysisFindings.
-func (mr *MockEC2APIMockRecorder) GetNetworkInsightsAccessScopeAnalysisFindings(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkInsightsAccessScopeAnalysisFindings", reflect.TypeOf((*MockEC2API)(nil).GetNetworkInsightsAccessScopeAnalysisFindings), arg0)
-}
-
-// GetNetworkInsightsAccessScopeAnalysisFindingsPages mocks base method.
-func (m *MockEC2API) GetNetworkInsightsAccessScopeAnalysisFindingsPages(arg0 *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsInput, arg1 func(*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetNetworkInsightsAccessScopeAnalysisFindingsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetNetworkInsightsAccessScopeAnalysisFindingsPages indicates an expected call of GetNetworkInsightsAccessScopeAnalysisFindingsPages.
-func (mr *MockEC2APIMockRecorder) GetNetworkInsightsAccessScopeAnalysisFindingsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkInsightsAccessScopeAnalysisFindingsPages", reflect.TypeOf((*MockEC2API)(nil).GetNetworkInsightsAccessScopeAnalysisFindingsPages), arg0, arg1)
-}
-
-// GetNetworkInsightsAccessScopeAnalysisFindingsPagesWithContext mocks base method.
-func (m *MockEC2API) GetNetworkInsightsAccessScopeAnalysisFindingsPagesWithContext(arg0 context.Context, arg1 *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsInput, arg2 func(*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput, 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, "GetNetworkInsightsAccessScopeAnalysisFindingsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetNetworkInsightsAccessScopeAnalysisFindingsPagesWithContext indicates an expected call of GetNetworkInsightsAccessScopeAnalysisFindingsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) GetNetworkInsightsAccessScopeAnalysisFindingsPagesWithContext(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, "GetNetworkInsightsAccessScopeAnalysisFindingsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetNetworkInsightsAccessScopeAnalysisFindingsPagesWithContext), varargs...)
-}
-
-// GetNetworkInsightsAccessScopeAnalysisFindingsRequest mocks base method.
-func (m *MockEC2API) GetNetworkInsightsAccessScopeAnalysisFindingsRequest(arg0 *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsInput) (*request.Request, *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetNetworkInsightsAccessScopeAnalysisFindingsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput)
-	return ret0, ret1
-}
-
-// GetNetworkInsightsAccessScopeAnalysisFindingsRequest indicates an expected call of GetNetworkInsightsAccessScopeAnalysisFindingsRequest.
-func (mr *MockEC2APIMockRecorder) GetNetworkInsightsAccessScopeAnalysisFindingsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkInsightsAccessScopeAnalysisFindingsRequest", reflect.TypeOf((*MockEC2API)(nil).GetNetworkInsightsAccessScopeAnalysisFindingsRequest), arg0)
-}
-
-// GetNetworkInsightsAccessScopeAnalysisFindingsWithContext mocks base method.
-func (m *MockEC2API) GetNetworkInsightsAccessScopeAnalysisFindingsWithContext(arg0 context.Context, arg1 *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsInput, arg2 ...request.Option) (*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetNetworkInsightsAccessScopeAnalysisFindingsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetNetworkInsightsAccessScopeAnalysisFindingsWithContext indicates an expected call of GetNetworkInsightsAccessScopeAnalysisFindingsWithContext.
-func (mr *MockEC2APIMockRecorder) GetNetworkInsightsAccessScopeAnalysisFindingsWithContext(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, "GetNetworkInsightsAccessScopeAnalysisFindingsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetNetworkInsightsAccessScopeAnalysisFindingsWithContext), varargs...)
-}
-
-// GetNetworkInsightsAccessScopeContent mocks base method.
-func (m *MockEC2API) GetNetworkInsightsAccessScopeContent(arg0 *ec2.GetNetworkInsightsAccessScopeContentInput) (*ec2.GetNetworkInsightsAccessScopeContentOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetNetworkInsightsAccessScopeContent", arg0)
-	ret0, _ := ret[0].(*ec2.GetNetworkInsightsAccessScopeContentOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetNetworkInsightsAccessScopeContent indicates an expected call of GetNetworkInsightsAccessScopeContent.
-func (mr *MockEC2APIMockRecorder) GetNetworkInsightsAccessScopeContent(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkInsightsAccessScopeContent", reflect.TypeOf((*MockEC2API)(nil).GetNetworkInsightsAccessScopeContent), arg0)
-}
-
-// GetNetworkInsightsAccessScopeContentRequest mocks base method.
-func (m *MockEC2API) GetNetworkInsightsAccessScopeContentRequest(arg0 *ec2.GetNetworkInsightsAccessScopeContentInput) (*request.Request, *ec2.GetNetworkInsightsAccessScopeContentOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetNetworkInsightsAccessScopeContentRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetNetworkInsightsAccessScopeContentOutput)
-	return ret0, ret1
-}
-
-// GetNetworkInsightsAccessScopeContentRequest indicates an expected call of GetNetworkInsightsAccessScopeContentRequest.
-func (mr *MockEC2APIMockRecorder) GetNetworkInsightsAccessScopeContentRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkInsightsAccessScopeContentRequest", reflect.TypeOf((*MockEC2API)(nil).GetNetworkInsightsAccessScopeContentRequest), arg0)
-}
-
-// GetNetworkInsightsAccessScopeContentWithContext mocks base method.
-func (m *MockEC2API) GetNetworkInsightsAccessScopeContentWithContext(arg0 context.Context, arg1 *ec2.GetNetworkInsightsAccessScopeContentInput, arg2 ...request.Option) (*ec2.GetNetworkInsightsAccessScopeContentOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetNetworkInsightsAccessScopeContentWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetNetworkInsightsAccessScopeContentOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetNetworkInsightsAccessScopeContentWithContext indicates an expected call of GetNetworkInsightsAccessScopeContentWithContext.
-func (mr *MockEC2APIMockRecorder) GetNetworkInsightsAccessScopeContentWithContext(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, "GetNetworkInsightsAccessScopeContentWithContext", reflect.TypeOf((*MockEC2API)(nil).GetNetworkInsightsAccessScopeContentWithContext), varargs...)
-}
-
-// GetPasswordData mocks base method.
-func (m *MockEC2API) GetPasswordData(arg0 *ec2.GetPasswordDataInput) (*ec2.GetPasswordDataOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetPasswordData", arg0)
-	ret0, _ := ret[0].(*ec2.GetPasswordDataOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetPasswordData indicates an expected call of GetPasswordData.
-func (mr *MockEC2APIMockRecorder) GetPasswordData(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPasswordData", reflect.TypeOf((*MockEC2API)(nil).GetPasswordData), arg0)
-}
-
-// GetPasswordDataRequest mocks base method.
-func (m *MockEC2API) GetPasswordDataRequest(arg0 *ec2.GetPasswordDataInput) (*request.Request, *ec2.GetPasswordDataOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetPasswordDataRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetPasswordDataOutput)
-	return ret0, ret1
-}
-
-// GetPasswordDataRequest indicates an expected call of GetPasswordDataRequest.
-func (mr *MockEC2APIMockRecorder) GetPasswordDataRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPasswordDataRequest", reflect.TypeOf((*MockEC2API)(nil).GetPasswordDataRequest), arg0)
-}
-
-// GetPasswordDataWithContext mocks base method.
-func (m *MockEC2API) GetPasswordDataWithContext(arg0 context.Context, arg1 *ec2.GetPasswordDataInput, arg2 ...request.Option) (*ec2.GetPasswordDataOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetPasswordDataWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetPasswordDataOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetPasswordDataWithContext indicates an expected call of GetPasswordDataWithContext.
-func (mr *MockEC2APIMockRecorder) GetPasswordDataWithContext(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, "GetPasswordDataWithContext", reflect.TypeOf((*MockEC2API)(nil).GetPasswordDataWithContext), varargs...)
-}
-
-// GetReservedInstancesExchangeQuote mocks base method.
-func (m *MockEC2API) GetReservedInstancesExchangeQuote(arg0 *ec2.GetReservedInstancesExchangeQuoteInput) (*ec2.GetReservedInstancesExchangeQuoteOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetReservedInstancesExchangeQuote", arg0)
-	ret0, _ := ret[0].(*ec2.GetReservedInstancesExchangeQuoteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetReservedInstancesExchangeQuote indicates an expected call of GetReservedInstancesExchangeQuote.
-func (mr *MockEC2APIMockRecorder) GetReservedInstancesExchangeQuote(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReservedInstancesExchangeQuote", reflect.TypeOf((*MockEC2API)(nil).GetReservedInstancesExchangeQuote), arg0)
-}
-
-// GetReservedInstancesExchangeQuoteRequest mocks base method.
-func (m *MockEC2API) GetReservedInstancesExchangeQuoteRequest(arg0 *ec2.GetReservedInstancesExchangeQuoteInput) (*request.Request, *ec2.GetReservedInstancesExchangeQuoteOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetReservedInstancesExchangeQuoteRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetReservedInstancesExchangeQuoteOutput)
-	return ret0, ret1
-}
-
-// GetReservedInstancesExchangeQuoteRequest indicates an expected call of GetReservedInstancesExchangeQuoteRequest.
-func (mr *MockEC2APIMockRecorder) GetReservedInstancesExchangeQuoteRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReservedInstancesExchangeQuoteRequest", reflect.TypeOf((*MockEC2API)(nil).GetReservedInstancesExchangeQuoteRequest), arg0)
-}
-
-// GetReservedInstancesExchangeQuoteWithContext mocks base method.
-func (m *MockEC2API) GetReservedInstancesExchangeQuoteWithContext(arg0 context.Context, arg1 *ec2.GetReservedInstancesExchangeQuoteInput, arg2 ...request.Option) (*ec2.GetReservedInstancesExchangeQuoteOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetReservedInstancesExchangeQuoteWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetReservedInstancesExchangeQuoteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetReservedInstancesExchangeQuoteWithContext indicates an expected call of GetReservedInstancesExchangeQuoteWithContext.
-func (mr *MockEC2APIMockRecorder) GetReservedInstancesExchangeQuoteWithContext(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, "GetReservedInstancesExchangeQuoteWithContext", reflect.TypeOf((*MockEC2API)(nil).GetReservedInstancesExchangeQuoteWithContext), varargs...)
-}
-
-// GetSecurityGroupsForVpc mocks base method.
-func (m *MockEC2API) GetSecurityGroupsForVpc(arg0 *ec2.GetSecurityGroupsForVpcInput) (*ec2.GetSecurityGroupsForVpcOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetSecurityGroupsForVpc", arg0)
-	ret0, _ := ret[0].(*ec2.GetSecurityGroupsForVpcOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetSecurityGroupsForVpc indicates an expected call of GetSecurityGroupsForVpc.
-func (mr *MockEC2APIMockRecorder) GetSecurityGroupsForVpc(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecurityGroupsForVpc", reflect.TypeOf((*MockEC2API)(nil).GetSecurityGroupsForVpc), arg0)
-}
-
-// GetSecurityGroupsForVpcPages mocks base method.
-func (m *MockEC2API) GetSecurityGroupsForVpcPages(arg0 *ec2.GetSecurityGroupsForVpcInput, arg1 func(*ec2.GetSecurityGroupsForVpcOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetSecurityGroupsForVpcPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetSecurityGroupsForVpcPages indicates an expected call of GetSecurityGroupsForVpcPages.
-func (mr *MockEC2APIMockRecorder) GetSecurityGroupsForVpcPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecurityGroupsForVpcPages", reflect.TypeOf((*MockEC2API)(nil).GetSecurityGroupsForVpcPages), arg0, arg1)
-}
-
-// GetSecurityGroupsForVpcPagesWithContext mocks base method.
-func (m *MockEC2API) GetSecurityGroupsForVpcPagesWithContext(arg0 context.Context, arg1 *ec2.GetSecurityGroupsForVpcInput, arg2 func(*ec2.GetSecurityGroupsForVpcOutput, 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, "GetSecurityGroupsForVpcPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetSecurityGroupsForVpcPagesWithContext indicates an expected call of GetSecurityGroupsForVpcPagesWithContext.
-func (mr *MockEC2APIMockRecorder) GetSecurityGroupsForVpcPagesWithContext(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, "GetSecurityGroupsForVpcPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetSecurityGroupsForVpcPagesWithContext), varargs...)
-}
-
-// GetSecurityGroupsForVpcRequest mocks base method.
-func (m *MockEC2API) GetSecurityGroupsForVpcRequest(arg0 *ec2.GetSecurityGroupsForVpcInput) (*request.Request, *ec2.GetSecurityGroupsForVpcOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetSecurityGroupsForVpcRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetSecurityGroupsForVpcOutput)
-	return ret0, ret1
-}
-
-// GetSecurityGroupsForVpcRequest indicates an expected call of GetSecurityGroupsForVpcRequest.
-func (mr *MockEC2APIMockRecorder) GetSecurityGroupsForVpcRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecurityGroupsForVpcRequest", reflect.TypeOf((*MockEC2API)(nil).GetSecurityGroupsForVpcRequest), arg0)
-}
-
-// GetSecurityGroupsForVpcWithContext mocks base method.
-func (m *MockEC2API) GetSecurityGroupsForVpcWithContext(arg0 context.Context, arg1 *ec2.GetSecurityGroupsForVpcInput, arg2 ...request.Option) (*ec2.GetSecurityGroupsForVpcOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetSecurityGroupsForVpcWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetSecurityGroupsForVpcOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetSecurityGroupsForVpcWithContext indicates an expected call of GetSecurityGroupsForVpcWithContext.
-func (mr *MockEC2APIMockRecorder) GetSecurityGroupsForVpcWithContext(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, "GetSecurityGroupsForVpcWithContext", reflect.TypeOf((*MockEC2API)(nil).GetSecurityGroupsForVpcWithContext), varargs...)
-}
-
-// GetSerialConsoleAccessStatus mocks base method.
-func (m *MockEC2API) GetSerialConsoleAccessStatus(arg0 *ec2.GetSerialConsoleAccessStatusInput) (*ec2.GetSerialConsoleAccessStatusOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetSerialConsoleAccessStatus", arg0)
-	ret0, _ := ret[0].(*ec2.GetSerialConsoleAccessStatusOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetSerialConsoleAccessStatus indicates an expected call of GetSerialConsoleAccessStatus.
-func (mr *MockEC2APIMockRecorder) GetSerialConsoleAccessStatus(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSerialConsoleAccessStatus", reflect.TypeOf((*MockEC2API)(nil).GetSerialConsoleAccessStatus), arg0)
-}
-
-// GetSerialConsoleAccessStatusRequest mocks base method.
-func (m *MockEC2API) GetSerialConsoleAccessStatusRequest(arg0 *ec2.GetSerialConsoleAccessStatusInput) (*request.Request, *ec2.GetSerialConsoleAccessStatusOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetSerialConsoleAccessStatusRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetSerialConsoleAccessStatusOutput)
-	return ret0, ret1
-}
-
-// GetSerialConsoleAccessStatusRequest indicates an expected call of GetSerialConsoleAccessStatusRequest.
-func (mr *MockEC2APIMockRecorder) GetSerialConsoleAccessStatusRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSerialConsoleAccessStatusRequest", reflect.TypeOf((*MockEC2API)(nil).GetSerialConsoleAccessStatusRequest), arg0)
-}
-
-// GetSerialConsoleAccessStatusWithContext mocks base method.
-func (m *MockEC2API) GetSerialConsoleAccessStatusWithContext(arg0 context.Context, arg1 *ec2.GetSerialConsoleAccessStatusInput, arg2 ...request.Option) (*ec2.GetSerialConsoleAccessStatusOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetSerialConsoleAccessStatusWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetSerialConsoleAccessStatusOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetSerialConsoleAccessStatusWithContext indicates an expected call of GetSerialConsoleAccessStatusWithContext.
-func (mr *MockEC2APIMockRecorder) GetSerialConsoleAccessStatusWithContext(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, "GetSerialConsoleAccessStatusWithContext", reflect.TypeOf((*MockEC2API)(nil).GetSerialConsoleAccessStatusWithContext), varargs...)
-}
-
-// GetSnapshotBlockPublicAccessState mocks base method.
-func (m *MockEC2API) GetSnapshotBlockPublicAccessState(arg0 *ec2.GetSnapshotBlockPublicAccessStateInput) (*ec2.GetSnapshotBlockPublicAccessStateOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetSnapshotBlockPublicAccessState", arg0)
-	ret0, _ := ret[0].(*ec2.GetSnapshotBlockPublicAccessStateOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetSnapshotBlockPublicAccessState indicates an expected call of GetSnapshotBlockPublicAccessState.
-func (mr *MockEC2APIMockRecorder) GetSnapshotBlockPublicAccessState(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshotBlockPublicAccessState", reflect.TypeOf((*MockEC2API)(nil).GetSnapshotBlockPublicAccessState), arg0)
-}
-
-// GetSnapshotBlockPublicAccessStateRequest mocks base method.
-func (m *MockEC2API) GetSnapshotBlockPublicAccessStateRequest(arg0 *ec2.GetSnapshotBlockPublicAccessStateInput) (*request.Request, *ec2.GetSnapshotBlockPublicAccessStateOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetSnapshotBlockPublicAccessStateRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetSnapshotBlockPublicAccessStateOutput)
-	return ret0, ret1
-}
-
-// GetSnapshotBlockPublicAccessStateRequest indicates an expected call of GetSnapshotBlockPublicAccessStateRequest.
-func (mr *MockEC2APIMockRecorder) GetSnapshotBlockPublicAccessStateRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshotBlockPublicAccessStateRequest", reflect.TypeOf((*MockEC2API)(nil).GetSnapshotBlockPublicAccessStateRequest), arg0)
-}
-
-// GetSnapshotBlockPublicAccessStateWithContext mocks base method.
-func (m *MockEC2API) GetSnapshotBlockPublicAccessStateWithContext(arg0 context.Context, arg1 *ec2.GetSnapshotBlockPublicAccessStateInput, arg2 ...request.Option) (*ec2.GetSnapshotBlockPublicAccessStateOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetSnapshotBlockPublicAccessStateWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetSnapshotBlockPublicAccessStateOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetSnapshotBlockPublicAccessStateWithContext indicates an expected call of GetSnapshotBlockPublicAccessStateWithContext.
-func (mr *MockEC2APIMockRecorder) GetSnapshotBlockPublicAccessStateWithContext(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, "GetSnapshotBlockPublicAccessStateWithContext", reflect.TypeOf((*MockEC2API)(nil).GetSnapshotBlockPublicAccessStateWithContext), varargs...)
-}
-
-// GetSpotPlacementScores mocks base method.
-func (m *MockEC2API) GetSpotPlacementScores(arg0 *ec2.GetSpotPlacementScoresInput) (*ec2.GetSpotPlacementScoresOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetSpotPlacementScores", arg0)
-	ret0, _ := ret[0].(*ec2.GetSpotPlacementScoresOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetSpotPlacementScores indicates an expected call of GetSpotPlacementScores.
-func (mr *MockEC2APIMockRecorder) GetSpotPlacementScores(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSpotPlacementScores", reflect.TypeOf((*MockEC2API)(nil).GetSpotPlacementScores), arg0)
-}
-
-// GetSpotPlacementScoresPages mocks base method.
-func (m *MockEC2API) GetSpotPlacementScoresPages(arg0 *ec2.GetSpotPlacementScoresInput, arg1 func(*ec2.GetSpotPlacementScoresOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetSpotPlacementScoresPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetSpotPlacementScoresPages indicates an expected call of GetSpotPlacementScoresPages.
-func (mr *MockEC2APIMockRecorder) GetSpotPlacementScoresPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSpotPlacementScoresPages", reflect.TypeOf((*MockEC2API)(nil).GetSpotPlacementScoresPages), arg0, arg1)
-}
-
-// GetSpotPlacementScoresPagesWithContext mocks base method.
-func (m *MockEC2API) GetSpotPlacementScoresPagesWithContext(arg0 context.Context, arg1 *ec2.GetSpotPlacementScoresInput, arg2 func(*ec2.GetSpotPlacementScoresOutput, 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, "GetSpotPlacementScoresPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetSpotPlacementScoresPagesWithContext indicates an expected call of GetSpotPlacementScoresPagesWithContext.
-func (mr *MockEC2APIMockRecorder) GetSpotPlacementScoresPagesWithContext(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, "GetSpotPlacementScoresPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetSpotPlacementScoresPagesWithContext), varargs...)
-}
-
-// GetSpotPlacementScoresRequest mocks base method.
-func (m *MockEC2API) GetSpotPlacementScoresRequest(arg0 *ec2.GetSpotPlacementScoresInput) (*request.Request, *ec2.GetSpotPlacementScoresOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetSpotPlacementScoresRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetSpotPlacementScoresOutput)
-	return ret0, ret1
-}
-
-// GetSpotPlacementScoresRequest indicates an expected call of GetSpotPlacementScoresRequest.
-func (mr *MockEC2APIMockRecorder) GetSpotPlacementScoresRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSpotPlacementScoresRequest", reflect.TypeOf((*MockEC2API)(nil).GetSpotPlacementScoresRequest), arg0)
-}
-
-// GetSpotPlacementScoresWithContext mocks base method.
-func (m *MockEC2API) GetSpotPlacementScoresWithContext(arg0 context.Context, arg1 *ec2.GetSpotPlacementScoresInput, arg2 ...request.Option) (*ec2.GetSpotPlacementScoresOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetSpotPlacementScoresWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetSpotPlacementScoresOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetSpotPlacementScoresWithContext indicates an expected call of GetSpotPlacementScoresWithContext.
-func (mr *MockEC2APIMockRecorder) GetSpotPlacementScoresWithContext(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, "GetSpotPlacementScoresWithContext", reflect.TypeOf((*MockEC2API)(nil).GetSpotPlacementScoresWithContext), varargs...)
-}
-
-// GetSubnetCidrReservations mocks base method.
-func (m *MockEC2API) GetSubnetCidrReservations(arg0 *ec2.GetSubnetCidrReservationsInput) (*ec2.GetSubnetCidrReservationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetSubnetCidrReservations", arg0)
-	ret0, _ := ret[0].(*ec2.GetSubnetCidrReservationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetSubnetCidrReservations indicates an expected call of GetSubnetCidrReservations.
-func (mr *MockEC2APIMockRecorder) GetSubnetCidrReservations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubnetCidrReservations", reflect.TypeOf((*MockEC2API)(nil).GetSubnetCidrReservations), arg0)
-}
-
-// GetSubnetCidrReservationsRequest mocks base method.
-func (m *MockEC2API) GetSubnetCidrReservationsRequest(arg0 *ec2.GetSubnetCidrReservationsInput) (*request.Request, *ec2.GetSubnetCidrReservationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetSubnetCidrReservationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetSubnetCidrReservationsOutput)
-	return ret0, ret1
-}
-
-// GetSubnetCidrReservationsRequest indicates an expected call of GetSubnetCidrReservationsRequest.
-func (mr *MockEC2APIMockRecorder) GetSubnetCidrReservationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubnetCidrReservationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetSubnetCidrReservationsRequest), arg0)
-}
-
-// GetSubnetCidrReservationsWithContext mocks base method.
-func (m *MockEC2API) GetSubnetCidrReservationsWithContext(arg0 context.Context, arg1 *ec2.GetSubnetCidrReservationsInput, arg2 ...request.Option) (*ec2.GetSubnetCidrReservationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetSubnetCidrReservationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetSubnetCidrReservationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetSubnetCidrReservationsWithContext indicates an expected call of GetSubnetCidrReservationsWithContext.
-func (mr *MockEC2APIMockRecorder) GetSubnetCidrReservationsWithContext(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, "GetSubnetCidrReservationsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetSubnetCidrReservationsWithContext), varargs...)
-}
-
-// GetTransitGatewayAttachmentPropagations mocks base method.
-func (m *MockEC2API) GetTransitGatewayAttachmentPropagations(arg0 *ec2.GetTransitGatewayAttachmentPropagationsInput) (*ec2.GetTransitGatewayAttachmentPropagationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTransitGatewayAttachmentPropagations", arg0)
-	ret0, _ := ret[0].(*ec2.GetTransitGatewayAttachmentPropagationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetTransitGatewayAttachmentPropagations indicates an expected call of GetTransitGatewayAttachmentPropagations.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayAttachmentPropagations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayAttachmentPropagations", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayAttachmentPropagations), arg0)
-}
-
-// GetTransitGatewayAttachmentPropagationsPages mocks base method.
-func (m *MockEC2API) GetTransitGatewayAttachmentPropagationsPages(arg0 *ec2.GetTransitGatewayAttachmentPropagationsInput, arg1 func(*ec2.GetTransitGatewayAttachmentPropagationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTransitGatewayAttachmentPropagationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetTransitGatewayAttachmentPropagationsPages indicates an expected call of GetTransitGatewayAttachmentPropagationsPages.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayAttachmentPropagationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayAttachmentPropagationsPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayAttachmentPropagationsPages), arg0, arg1)
-}
-
-// GetTransitGatewayAttachmentPropagationsPagesWithContext mocks base method.
-func (m *MockEC2API) GetTransitGatewayAttachmentPropagationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayAttachmentPropagationsInput, arg2 func(*ec2.GetTransitGatewayAttachmentPropagationsOutput, 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, "GetTransitGatewayAttachmentPropagationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetTransitGatewayAttachmentPropagationsPagesWithContext indicates an expected call of GetTransitGatewayAttachmentPropagationsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayAttachmentPropagationsPagesWithContext(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, "GetTransitGatewayAttachmentPropagationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayAttachmentPropagationsPagesWithContext), varargs...)
-}
-
-// GetTransitGatewayAttachmentPropagationsRequest mocks base method.
-func (m *MockEC2API) GetTransitGatewayAttachmentPropagationsRequest(arg0 *ec2.GetTransitGatewayAttachmentPropagationsInput) (*request.Request, *ec2.GetTransitGatewayAttachmentPropagationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTransitGatewayAttachmentPropagationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetTransitGatewayAttachmentPropagationsOutput)
-	return ret0, ret1
-}
-
-// GetTransitGatewayAttachmentPropagationsRequest indicates an expected call of GetTransitGatewayAttachmentPropagationsRequest.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayAttachmentPropagationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayAttachmentPropagationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayAttachmentPropagationsRequest), arg0)
-}
-
-// GetTransitGatewayAttachmentPropagationsWithContext mocks base method.
-func (m *MockEC2API) GetTransitGatewayAttachmentPropagationsWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayAttachmentPropagationsInput, arg2 ...request.Option) (*ec2.GetTransitGatewayAttachmentPropagationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetTransitGatewayAttachmentPropagationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetTransitGatewayAttachmentPropagationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetTransitGatewayAttachmentPropagationsWithContext indicates an expected call of GetTransitGatewayAttachmentPropagationsWithContext.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayAttachmentPropagationsWithContext(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, "GetTransitGatewayAttachmentPropagationsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayAttachmentPropagationsWithContext), varargs...)
-}
-
-// GetTransitGatewayMulticastDomainAssociations mocks base method.
-func (m *MockEC2API) GetTransitGatewayMulticastDomainAssociations(arg0 *ec2.GetTransitGatewayMulticastDomainAssociationsInput) (*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTransitGatewayMulticastDomainAssociations", arg0)
-	ret0, _ := ret[0].(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetTransitGatewayMulticastDomainAssociations indicates an expected call of GetTransitGatewayMulticastDomainAssociations.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayMulticastDomainAssociations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayMulticastDomainAssociations", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayMulticastDomainAssociations), arg0)
-}
-
-// GetTransitGatewayMulticastDomainAssociationsPages mocks base method.
-func (m *MockEC2API) GetTransitGatewayMulticastDomainAssociationsPages(arg0 *ec2.GetTransitGatewayMulticastDomainAssociationsInput, arg1 func(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTransitGatewayMulticastDomainAssociationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetTransitGatewayMulticastDomainAssociationsPages indicates an expected call of GetTransitGatewayMulticastDomainAssociationsPages.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayMulticastDomainAssociationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayMulticastDomainAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayMulticastDomainAssociationsPages), arg0, arg1)
-}
-
-// GetTransitGatewayMulticastDomainAssociationsPagesWithContext mocks base method.
-func (m *MockEC2API) GetTransitGatewayMulticastDomainAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayMulticastDomainAssociationsInput, arg2 func(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, 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, "GetTransitGatewayMulticastDomainAssociationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetTransitGatewayMulticastDomainAssociationsPagesWithContext indicates an expected call of GetTransitGatewayMulticastDomainAssociationsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayMulticastDomainAssociationsPagesWithContext(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, "GetTransitGatewayMulticastDomainAssociationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayMulticastDomainAssociationsPagesWithContext), varargs...)
-}
-
-// GetTransitGatewayMulticastDomainAssociationsRequest mocks base method.
-func (m *MockEC2API) GetTransitGatewayMulticastDomainAssociationsRequest(arg0 *ec2.GetTransitGatewayMulticastDomainAssociationsInput) (*request.Request, *ec2.GetTransitGatewayMulticastDomainAssociationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTransitGatewayMulticastDomainAssociationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput)
-	return ret0, ret1
-}
-
-// GetTransitGatewayMulticastDomainAssociationsRequest indicates an expected call of GetTransitGatewayMulticastDomainAssociationsRequest.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayMulticastDomainAssociationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayMulticastDomainAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayMulticastDomainAssociationsRequest), arg0)
-}
-
-// GetTransitGatewayMulticastDomainAssociationsWithContext mocks base method.
-func (m *MockEC2API) GetTransitGatewayMulticastDomainAssociationsWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayMulticastDomainAssociationsInput, arg2 ...request.Option) (*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetTransitGatewayMulticastDomainAssociationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetTransitGatewayMulticastDomainAssociationsWithContext indicates an expected call of GetTransitGatewayMulticastDomainAssociationsWithContext.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayMulticastDomainAssociationsWithContext(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, "GetTransitGatewayMulticastDomainAssociationsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayMulticastDomainAssociationsWithContext), varargs...)
-}
-
-// GetTransitGatewayPolicyTableAssociations mocks base method.
-func (m *MockEC2API) GetTransitGatewayPolicyTableAssociations(arg0 *ec2.GetTransitGatewayPolicyTableAssociationsInput) (*ec2.GetTransitGatewayPolicyTableAssociationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTransitGatewayPolicyTableAssociations", arg0)
-	ret0, _ := ret[0].(*ec2.GetTransitGatewayPolicyTableAssociationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetTransitGatewayPolicyTableAssociations indicates an expected call of GetTransitGatewayPolicyTableAssociations.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayPolicyTableAssociations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPolicyTableAssociations", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPolicyTableAssociations), arg0)
-}
-
-// GetTransitGatewayPolicyTableAssociationsPages mocks base method.
-func (m *MockEC2API) GetTransitGatewayPolicyTableAssociationsPages(arg0 *ec2.GetTransitGatewayPolicyTableAssociationsInput, arg1 func(*ec2.GetTransitGatewayPolicyTableAssociationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTransitGatewayPolicyTableAssociationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetTransitGatewayPolicyTableAssociationsPages indicates an expected call of GetTransitGatewayPolicyTableAssociationsPages.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayPolicyTableAssociationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPolicyTableAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPolicyTableAssociationsPages), arg0, arg1)
-}
-
-// GetTransitGatewayPolicyTableAssociationsPagesWithContext mocks base method.
-func (m *MockEC2API) GetTransitGatewayPolicyTableAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayPolicyTableAssociationsInput, arg2 func(*ec2.GetTransitGatewayPolicyTableAssociationsOutput, 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, "GetTransitGatewayPolicyTableAssociationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetTransitGatewayPolicyTableAssociationsPagesWithContext indicates an expected call of GetTransitGatewayPolicyTableAssociationsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayPolicyTableAssociationsPagesWithContext(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, "GetTransitGatewayPolicyTableAssociationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPolicyTableAssociationsPagesWithContext), varargs...)
-}
-
-// GetTransitGatewayPolicyTableAssociationsRequest mocks base method.
-func (m *MockEC2API) GetTransitGatewayPolicyTableAssociationsRequest(arg0 *ec2.GetTransitGatewayPolicyTableAssociationsInput) (*request.Request, *ec2.GetTransitGatewayPolicyTableAssociationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTransitGatewayPolicyTableAssociationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetTransitGatewayPolicyTableAssociationsOutput)
-	return ret0, ret1
-}
-
-// GetTransitGatewayPolicyTableAssociationsRequest indicates an expected call of GetTransitGatewayPolicyTableAssociationsRequest.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayPolicyTableAssociationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPolicyTableAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPolicyTableAssociationsRequest), arg0)
-}
-
-// GetTransitGatewayPolicyTableAssociationsWithContext mocks base method.
-func (m *MockEC2API) GetTransitGatewayPolicyTableAssociationsWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayPolicyTableAssociationsInput, arg2 ...request.Option) (*ec2.GetTransitGatewayPolicyTableAssociationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetTransitGatewayPolicyTableAssociationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetTransitGatewayPolicyTableAssociationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetTransitGatewayPolicyTableAssociationsWithContext indicates an expected call of GetTransitGatewayPolicyTableAssociationsWithContext.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayPolicyTableAssociationsWithContext(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, "GetTransitGatewayPolicyTableAssociationsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPolicyTableAssociationsWithContext), varargs...)
-}
-
-// GetTransitGatewayPolicyTableEntries mocks base method.
-func (m *MockEC2API) GetTransitGatewayPolicyTableEntries(arg0 *ec2.GetTransitGatewayPolicyTableEntriesInput) (*ec2.GetTransitGatewayPolicyTableEntriesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTransitGatewayPolicyTableEntries", arg0)
-	ret0, _ := ret[0].(*ec2.GetTransitGatewayPolicyTableEntriesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetTransitGatewayPolicyTableEntries indicates an expected call of GetTransitGatewayPolicyTableEntries.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayPolicyTableEntries(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPolicyTableEntries", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPolicyTableEntries), arg0)
-}
-
-// GetTransitGatewayPolicyTableEntriesRequest mocks base method.
-func (m *MockEC2API) GetTransitGatewayPolicyTableEntriesRequest(arg0 *ec2.GetTransitGatewayPolicyTableEntriesInput) (*request.Request, *ec2.GetTransitGatewayPolicyTableEntriesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTransitGatewayPolicyTableEntriesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetTransitGatewayPolicyTableEntriesOutput)
-	return ret0, ret1
-}
-
-// GetTransitGatewayPolicyTableEntriesRequest indicates an expected call of GetTransitGatewayPolicyTableEntriesRequest.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayPolicyTableEntriesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPolicyTableEntriesRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPolicyTableEntriesRequest), arg0)
-}
-
-// GetTransitGatewayPolicyTableEntriesWithContext mocks base method.
-func (m *MockEC2API) GetTransitGatewayPolicyTableEntriesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayPolicyTableEntriesInput, arg2 ...request.Option) (*ec2.GetTransitGatewayPolicyTableEntriesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetTransitGatewayPolicyTableEntriesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetTransitGatewayPolicyTableEntriesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetTransitGatewayPolicyTableEntriesWithContext indicates an expected call of GetTransitGatewayPolicyTableEntriesWithContext.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayPolicyTableEntriesWithContext(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, "GetTransitGatewayPolicyTableEntriesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPolicyTableEntriesWithContext), varargs...)
-}
-
-// GetTransitGatewayPrefixListReferences mocks base method.
-func (m *MockEC2API) GetTransitGatewayPrefixListReferences(arg0 *ec2.GetTransitGatewayPrefixListReferencesInput) (*ec2.GetTransitGatewayPrefixListReferencesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTransitGatewayPrefixListReferences", arg0)
-	ret0, _ := ret[0].(*ec2.GetTransitGatewayPrefixListReferencesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetTransitGatewayPrefixListReferences indicates an expected call of GetTransitGatewayPrefixListReferences.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayPrefixListReferences(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPrefixListReferences", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPrefixListReferences), arg0)
-}
-
-// GetTransitGatewayPrefixListReferencesPages mocks base method.
-func (m *MockEC2API) GetTransitGatewayPrefixListReferencesPages(arg0 *ec2.GetTransitGatewayPrefixListReferencesInput, arg1 func(*ec2.GetTransitGatewayPrefixListReferencesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTransitGatewayPrefixListReferencesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetTransitGatewayPrefixListReferencesPages indicates an expected call of GetTransitGatewayPrefixListReferencesPages.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayPrefixListReferencesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPrefixListReferencesPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPrefixListReferencesPages), arg0, arg1)
-}
-
-// GetTransitGatewayPrefixListReferencesPagesWithContext mocks base method.
-func (m *MockEC2API) GetTransitGatewayPrefixListReferencesPagesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayPrefixListReferencesInput, arg2 func(*ec2.GetTransitGatewayPrefixListReferencesOutput, 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, "GetTransitGatewayPrefixListReferencesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetTransitGatewayPrefixListReferencesPagesWithContext indicates an expected call of GetTransitGatewayPrefixListReferencesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayPrefixListReferencesPagesWithContext(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, "GetTransitGatewayPrefixListReferencesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPrefixListReferencesPagesWithContext), varargs...)
-}
-
-// GetTransitGatewayPrefixListReferencesRequest mocks base method.
-func (m *MockEC2API) GetTransitGatewayPrefixListReferencesRequest(arg0 *ec2.GetTransitGatewayPrefixListReferencesInput) (*request.Request, *ec2.GetTransitGatewayPrefixListReferencesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTransitGatewayPrefixListReferencesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetTransitGatewayPrefixListReferencesOutput)
-	return ret0, ret1
-}
-
-// GetTransitGatewayPrefixListReferencesRequest indicates an expected call of GetTransitGatewayPrefixListReferencesRequest.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayPrefixListReferencesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPrefixListReferencesRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPrefixListReferencesRequest), arg0)
-}
-
-// GetTransitGatewayPrefixListReferencesWithContext mocks base method.
-func (m *MockEC2API) GetTransitGatewayPrefixListReferencesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayPrefixListReferencesInput, arg2 ...request.Option) (*ec2.GetTransitGatewayPrefixListReferencesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetTransitGatewayPrefixListReferencesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetTransitGatewayPrefixListReferencesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetTransitGatewayPrefixListReferencesWithContext indicates an expected call of GetTransitGatewayPrefixListReferencesWithContext.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayPrefixListReferencesWithContext(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, "GetTransitGatewayPrefixListReferencesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPrefixListReferencesWithContext), varargs...)
-}
-
-// GetTransitGatewayRouteTableAssociations mocks base method.
-func (m *MockEC2API) GetTransitGatewayRouteTableAssociations(arg0 *ec2.GetTransitGatewayRouteTableAssociationsInput) (*ec2.GetTransitGatewayRouteTableAssociationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTransitGatewayRouteTableAssociations", arg0)
-	ret0, _ := ret[0].(*ec2.GetTransitGatewayRouteTableAssociationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetTransitGatewayRouteTableAssociations indicates an expected call of GetTransitGatewayRouteTableAssociations.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTableAssociations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTableAssociations", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTableAssociations), arg0)
-}
-
-// GetTransitGatewayRouteTableAssociationsPages mocks base method.
-func (m *MockEC2API) GetTransitGatewayRouteTableAssociationsPages(arg0 *ec2.GetTransitGatewayRouteTableAssociationsInput, arg1 func(*ec2.GetTransitGatewayRouteTableAssociationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTransitGatewayRouteTableAssociationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetTransitGatewayRouteTableAssociationsPages indicates an expected call of GetTransitGatewayRouteTableAssociationsPages.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTableAssociationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTableAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTableAssociationsPages), arg0, arg1)
-}
-
-// GetTransitGatewayRouteTableAssociationsPagesWithContext mocks base method.
-func (m *MockEC2API) GetTransitGatewayRouteTableAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayRouteTableAssociationsInput, arg2 func(*ec2.GetTransitGatewayRouteTableAssociationsOutput, 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, "GetTransitGatewayRouteTableAssociationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetTransitGatewayRouteTableAssociationsPagesWithContext indicates an expected call of GetTransitGatewayRouteTableAssociationsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTableAssociationsPagesWithContext(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, "GetTransitGatewayRouteTableAssociationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTableAssociationsPagesWithContext), varargs...)
-}
-
-// GetTransitGatewayRouteTableAssociationsRequest mocks base method.
-func (m *MockEC2API) GetTransitGatewayRouteTableAssociationsRequest(arg0 *ec2.GetTransitGatewayRouteTableAssociationsInput) (*request.Request, *ec2.GetTransitGatewayRouteTableAssociationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTransitGatewayRouteTableAssociationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetTransitGatewayRouteTableAssociationsOutput)
-	return ret0, ret1
-}
-
-// GetTransitGatewayRouteTableAssociationsRequest indicates an expected call of GetTransitGatewayRouteTableAssociationsRequest.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTableAssociationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTableAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTableAssociationsRequest), arg0)
-}
-
-// GetTransitGatewayRouteTableAssociationsWithContext mocks base method.
-func (m *MockEC2API) GetTransitGatewayRouteTableAssociationsWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayRouteTableAssociationsInput, arg2 ...request.Option) (*ec2.GetTransitGatewayRouteTableAssociationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetTransitGatewayRouteTableAssociationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetTransitGatewayRouteTableAssociationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetTransitGatewayRouteTableAssociationsWithContext indicates an expected call of GetTransitGatewayRouteTableAssociationsWithContext.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTableAssociationsWithContext(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, "GetTransitGatewayRouteTableAssociationsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTableAssociationsWithContext), varargs...)
-}
-
-// GetTransitGatewayRouteTablePropagations mocks base method.
-func (m *MockEC2API) GetTransitGatewayRouteTablePropagations(arg0 *ec2.GetTransitGatewayRouteTablePropagationsInput) (*ec2.GetTransitGatewayRouteTablePropagationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTransitGatewayRouteTablePropagations", arg0)
-	ret0, _ := ret[0].(*ec2.GetTransitGatewayRouteTablePropagationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetTransitGatewayRouteTablePropagations indicates an expected call of GetTransitGatewayRouteTablePropagations.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTablePropagations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTablePropagations", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTablePropagations), arg0)
-}
-
-// GetTransitGatewayRouteTablePropagationsPages mocks base method.
-func (m *MockEC2API) GetTransitGatewayRouteTablePropagationsPages(arg0 *ec2.GetTransitGatewayRouteTablePropagationsInput, arg1 func(*ec2.GetTransitGatewayRouteTablePropagationsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTransitGatewayRouteTablePropagationsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetTransitGatewayRouteTablePropagationsPages indicates an expected call of GetTransitGatewayRouteTablePropagationsPages.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTablePropagationsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTablePropagationsPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTablePropagationsPages), arg0, arg1)
-}
-
-// GetTransitGatewayRouteTablePropagationsPagesWithContext mocks base method.
-func (m *MockEC2API) GetTransitGatewayRouteTablePropagationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayRouteTablePropagationsInput, arg2 func(*ec2.GetTransitGatewayRouteTablePropagationsOutput, 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, "GetTransitGatewayRouteTablePropagationsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetTransitGatewayRouteTablePropagationsPagesWithContext indicates an expected call of GetTransitGatewayRouteTablePropagationsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTablePropagationsPagesWithContext(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, "GetTransitGatewayRouteTablePropagationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTablePropagationsPagesWithContext), varargs...)
-}
-
-// GetTransitGatewayRouteTablePropagationsRequest mocks base method.
-func (m *MockEC2API) GetTransitGatewayRouteTablePropagationsRequest(arg0 *ec2.GetTransitGatewayRouteTablePropagationsInput) (*request.Request, *ec2.GetTransitGatewayRouteTablePropagationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTransitGatewayRouteTablePropagationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetTransitGatewayRouteTablePropagationsOutput)
-	return ret0, ret1
-}
-
-// GetTransitGatewayRouteTablePropagationsRequest indicates an expected call of GetTransitGatewayRouteTablePropagationsRequest.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTablePropagationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTablePropagationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTablePropagationsRequest), arg0)
-}
-
-// GetTransitGatewayRouteTablePropagationsWithContext mocks base method.
-func (m *MockEC2API) GetTransitGatewayRouteTablePropagationsWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayRouteTablePropagationsInput, arg2 ...request.Option) (*ec2.GetTransitGatewayRouteTablePropagationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetTransitGatewayRouteTablePropagationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetTransitGatewayRouteTablePropagationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetTransitGatewayRouteTablePropagationsWithContext indicates an expected call of GetTransitGatewayRouteTablePropagationsWithContext.
-func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTablePropagationsWithContext(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, "GetTransitGatewayRouteTablePropagationsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTablePropagationsWithContext), varargs...)
-}
-
-// GetVerifiedAccessEndpointPolicy mocks base method.
-func (m *MockEC2API) GetVerifiedAccessEndpointPolicy(arg0 *ec2.GetVerifiedAccessEndpointPolicyInput) (*ec2.GetVerifiedAccessEndpointPolicyOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetVerifiedAccessEndpointPolicy", arg0)
-	ret0, _ := ret[0].(*ec2.GetVerifiedAccessEndpointPolicyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetVerifiedAccessEndpointPolicy indicates an expected call of GetVerifiedAccessEndpointPolicy.
-func (mr *MockEC2APIMockRecorder) GetVerifiedAccessEndpointPolicy(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVerifiedAccessEndpointPolicy", reflect.TypeOf((*MockEC2API)(nil).GetVerifiedAccessEndpointPolicy), arg0)
-}
-
-// GetVerifiedAccessEndpointPolicyRequest mocks base method.
-func (m *MockEC2API) GetVerifiedAccessEndpointPolicyRequest(arg0 *ec2.GetVerifiedAccessEndpointPolicyInput) (*request.Request, *ec2.GetVerifiedAccessEndpointPolicyOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetVerifiedAccessEndpointPolicyRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetVerifiedAccessEndpointPolicyOutput)
-	return ret0, ret1
-}
-
-// GetVerifiedAccessEndpointPolicyRequest indicates an expected call of GetVerifiedAccessEndpointPolicyRequest.
-func (mr *MockEC2APIMockRecorder) GetVerifiedAccessEndpointPolicyRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVerifiedAccessEndpointPolicyRequest", reflect.TypeOf((*MockEC2API)(nil).GetVerifiedAccessEndpointPolicyRequest), arg0)
-}
-
-// GetVerifiedAccessEndpointPolicyWithContext mocks base method.
-func (m *MockEC2API) GetVerifiedAccessEndpointPolicyWithContext(arg0 context.Context, arg1 *ec2.GetVerifiedAccessEndpointPolicyInput, arg2 ...request.Option) (*ec2.GetVerifiedAccessEndpointPolicyOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetVerifiedAccessEndpointPolicyWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetVerifiedAccessEndpointPolicyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetVerifiedAccessEndpointPolicyWithContext indicates an expected call of GetVerifiedAccessEndpointPolicyWithContext.
-func (mr *MockEC2APIMockRecorder) GetVerifiedAccessEndpointPolicyWithContext(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, "GetVerifiedAccessEndpointPolicyWithContext", reflect.TypeOf((*MockEC2API)(nil).GetVerifiedAccessEndpointPolicyWithContext), varargs...)
-}
-
-// GetVerifiedAccessGroupPolicy mocks base method.
-func (m *MockEC2API) GetVerifiedAccessGroupPolicy(arg0 *ec2.GetVerifiedAccessGroupPolicyInput) (*ec2.GetVerifiedAccessGroupPolicyOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetVerifiedAccessGroupPolicy", arg0)
-	ret0, _ := ret[0].(*ec2.GetVerifiedAccessGroupPolicyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetVerifiedAccessGroupPolicy indicates an expected call of GetVerifiedAccessGroupPolicy.
-func (mr *MockEC2APIMockRecorder) GetVerifiedAccessGroupPolicy(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVerifiedAccessGroupPolicy", reflect.TypeOf((*MockEC2API)(nil).GetVerifiedAccessGroupPolicy), arg0)
-}
-
-// GetVerifiedAccessGroupPolicyRequest mocks base method.
-func (m *MockEC2API) GetVerifiedAccessGroupPolicyRequest(arg0 *ec2.GetVerifiedAccessGroupPolicyInput) (*request.Request, *ec2.GetVerifiedAccessGroupPolicyOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetVerifiedAccessGroupPolicyRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetVerifiedAccessGroupPolicyOutput)
-	return ret0, ret1
-}
-
-// GetVerifiedAccessGroupPolicyRequest indicates an expected call of GetVerifiedAccessGroupPolicyRequest.
-func (mr *MockEC2APIMockRecorder) GetVerifiedAccessGroupPolicyRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVerifiedAccessGroupPolicyRequest", reflect.TypeOf((*MockEC2API)(nil).GetVerifiedAccessGroupPolicyRequest), arg0)
-}
-
-// GetVerifiedAccessGroupPolicyWithContext mocks base method.
-func (m *MockEC2API) GetVerifiedAccessGroupPolicyWithContext(arg0 context.Context, arg1 *ec2.GetVerifiedAccessGroupPolicyInput, arg2 ...request.Option) (*ec2.GetVerifiedAccessGroupPolicyOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetVerifiedAccessGroupPolicyWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetVerifiedAccessGroupPolicyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetVerifiedAccessGroupPolicyWithContext indicates an expected call of GetVerifiedAccessGroupPolicyWithContext.
-func (mr *MockEC2APIMockRecorder) GetVerifiedAccessGroupPolicyWithContext(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, "GetVerifiedAccessGroupPolicyWithContext", reflect.TypeOf((*MockEC2API)(nil).GetVerifiedAccessGroupPolicyWithContext), varargs...)
-}
-
-// GetVpnConnectionDeviceSampleConfiguration mocks base method.
-func (m *MockEC2API) GetVpnConnectionDeviceSampleConfiguration(arg0 *ec2.GetVpnConnectionDeviceSampleConfigurationInput) (*ec2.GetVpnConnectionDeviceSampleConfigurationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetVpnConnectionDeviceSampleConfiguration", arg0)
-	ret0, _ := ret[0].(*ec2.GetVpnConnectionDeviceSampleConfigurationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetVpnConnectionDeviceSampleConfiguration indicates an expected call of GetVpnConnectionDeviceSampleConfiguration.
-func (mr *MockEC2APIMockRecorder) GetVpnConnectionDeviceSampleConfiguration(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnConnectionDeviceSampleConfiguration", reflect.TypeOf((*MockEC2API)(nil).GetVpnConnectionDeviceSampleConfiguration), arg0)
-}
-
-// GetVpnConnectionDeviceSampleConfigurationRequest mocks base method.
-func (m *MockEC2API) GetVpnConnectionDeviceSampleConfigurationRequest(arg0 *ec2.GetVpnConnectionDeviceSampleConfigurationInput) (*request.Request, *ec2.GetVpnConnectionDeviceSampleConfigurationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetVpnConnectionDeviceSampleConfigurationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetVpnConnectionDeviceSampleConfigurationOutput)
-	return ret0, ret1
-}
-
-// GetVpnConnectionDeviceSampleConfigurationRequest indicates an expected call of GetVpnConnectionDeviceSampleConfigurationRequest.
-func (mr *MockEC2APIMockRecorder) GetVpnConnectionDeviceSampleConfigurationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnConnectionDeviceSampleConfigurationRequest", reflect.TypeOf((*MockEC2API)(nil).GetVpnConnectionDeviceSampleConfigurationRequest), arg0)
-}
-
-// GetVpnConnectionDeviceSampleConfigurationWithContext mocks base method.
-func (m *MockEC2API) GetVpnConnectionDeviceSampleConfigurationWithContext(arg0 context.Context, arg1 *ec2.GetVpnConnectionDeviceSampleConfigurationInput, arg2 ...request.Option) (*ec2.GetVpnConnectionDeviceSampleConfigurationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetVpnConnectionDeviceSampleConfigurationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetVpnConnectionDeviceSampleConfigurationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetVpnConnectionDeviceSampleConfigurationWithContext indicates an expected call of GetVpnConnectionDeviceSampleConfigurationWithContext.
-func (mr *MockEC2APIMockRecorder) GetVpnConnectionDeviceSampleConfigurationWithContext(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, "GetVpnConnectionDeviceSampleConfigurationWithContext", reflect.TypeOf((*MockEC2API)(nil).GetVpnConnectionDeviceSampleConfigurationWithContext), varargs...)
-}
-
-// GetVpnConnectionDeviceTypes mocks base method.
-func (m *MockEC2API) GetVpnConnectionDeviceTypes(arg0 *ec2.GetVpnConnectionDeviceTypesInput) (*ec2.GetVpnConnectionDeviceTypesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetVpnConnectionDeviceTypes", arg0)
-	ret0, _ := ret[0].(*ec2.GetVpnConnectionDeviceTypesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetVpnConnectionDeviceTypes indicates an expected call of GetVpnConnectionDeviceTypes.
-func (mr *MockEC2APIMockRecorder) GetVpnConnectionDeviceTypes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnConnectionDeviceTypes", reflect.TypeOf((*MockEC2API)(nil).GetVpnConnectionDeviceTypes), arg0)
-}
-
-// GetVpnConnectionDeviceTypesPages mocks base method.
-func (m *MockEC2API) GetVpnConnectionDeviceTypesPages(arg0 *ec2.GetVpnConnectionDeviceTypesInput, arg1 func(*ec2.GetVpnConnectionDeviceTypesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetVpnConnectionDeviceTypesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetVpnConnectionDeviceTypesPages indicates an expected call of GetVpnConnectionDeviceTypesPages.
-func (mr *MockEC2APIMockRecorder) GetVpnConnectionDeviceTypesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnConnectionDeviceTypesPages", reflect.TypeOf((*MockEC2API)(nil).GetVpnConnectionDeviceTypesPages), arg0, arg1)
-}
-
-// GetVpnConnectionDeviceTypesPagesWithContext mocks base method.
-func (m *MockEC2API) GetVpnConnectionDeviceTypesPagesWithContext(arg0 context.Context, arg1 *ec2.GetVpnConnectionDeviceTypesInput, arg2 func(*ec2.GetVpnConnectionDeviceTypesOutput, 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, "GetVpnConnectionDeviceTypesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// GetVpnConnectionDeviceTypesPagesWithContext indicates an expected call of GetVpnConnectionDeviceTypesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) GetVpnConnectionDeviceTypesPagesWithContext(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, "GetVpnConnectionDeviceTypesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetVpnConnectionDeviceTypesPagesWithContext), varargs...)
-}
-
-// GetVpnConnectionDeviceTypesRequest mocks base method.
-func (m *MockEC2API) GetVpnConnectionDeviceTypesRequest(arg0 *ec2.GetVpnConnectionDeviceTypesInput) (*request.Request, *ec2.GetVpnConnectionDeviceTypesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetVpnConnectionDeviceTypesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetVpnConnectionDeviceTypesOutput)
-	return ret0, ret1
-}
-
-// GetVpnConnectionDeviceTypesRequest indicates an expected call of GetVpnConnectionDeviceTypesRequest.
-func (mr *MockEC2APIMockRecorder) GetVpnConnectionDeviceTypesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnConnectionDeviceTypesRequest", reflect.TypeOf((*MockEC2API)(nil).GetVpnConnectionDeviceTypesRequest), arg0)
-}
-
-// GetVpnConnectionDeviceTypesWithContext mocks base method.
-func (m *MockEC2API) GetVpnConnectionDeviceTypesWithContext(arg0 context.Context, arg1 *ec2.GetVpnConnectionDeviceTypesInput, arg2 ...request.Option) (*ec2.GetVpnConnectionDeviceTypesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetVpnConnectionDeviceTypesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetVpnConnectionDeviceTypesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetVpnConnectionDeviceTypesWithContext indicates an expected call of GetVpnConnectionDeviceTypesWithContext.
-func (mr *MockEC2APIMockRecorder) GetVpnConnectionDeviceTypesWithContext(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, "GetVpnConnectionDeviceTypesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetVpnConnectionDeviceTypesWithContext), varargs...)
-}
-
-// GetVpnTunnelReplacementStatus mocks base method.
-func (m *MockEC2API) GetVpnTunnelReplacementStatus(arg0 *ec2.GetVpnTunnelReplacementStatusInput) (*ec2.GetVpnTunnelReplacementStatusOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetVpnTunnelReplacementStatus", arg0)
-	ret0, _ := ret[0].(*ec2.GetVpnTunnelReplacementStatusOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetVpnTunnelReplacementStatus indicates an expected call of GetVpnTunnelReplacementStatus.
-func (mr *MockEC2APIMockRecorder) GetVpnTunnelReplacementStatus(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnTunnelReplacementStatus", reflect.TypeOf((*MockEC2API)(nil).GetVpnTunnelReplacementStatus), arg0)
-}
-
-// GetVpnTunnelReplacementStatusRequest mocks base method.
-func (m *MockEC2API) GetVpnTunnelReplacementStatusRequest(arg0 *ec2.GetVpnTunnelReplacementStatusInput) (*request.Request, *ec2.GetVpnTunnelReplacementStatusOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetVpnTunnelReplacementStatusRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.GetVpnTunnelReplacementStatusOutput)
-	return ret0, ret1
-}
-
-// GetVpnTunnelReplacementStatusRequest indicates an expected call of GetVpnTunnelReplacementStatusRequest.
-func (mr *MockEC2APIMockRecorder) GetVpnTunnelReplacementStatusRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnTunnelReplacementStatusRequest", reflect.TypeOf((*MockEC2API)(nil).GetVpnTunnelReplacementStatusRequest), arg0)
-}
-
-// GetVpnTunnelReplacementStatusWithContext mocks base method.
-func (m *MockEC2API) GetVpnTunnelReplacementStatusWithContext(arg0 context.Context, arg1 *ec2.GetVpnTunnelReplacementStatusInput, arg2 ...request.Option) (*ec2.GetVpnTunnelReplacementStatusOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GetVpnTunnelReplacementStatusWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.GetVpnTunnelReplacementStatusOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetVpnTunnelReplacementStatusWithContext indicates an expected call of GetVpnTunnelReplacementStatusWithContext.
-func (mr *MockEC2APIMockRecorder) GetVpnTunnelReplacementStatusWithContext(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, "GetVpnTunnelReplacementStatusWithContext", reflect.TypeOf((*MockEC2API)(nil).GetVpnTunnelReplacementStatusWithContext), varargs...)
-}
-
-// ImportClientVpnClientCertificateRevocationList mocks base method.
-func (m *MockEC2API) ImportClientVpnClientCertificateRevocationList(arg0 *ec2.ImportClientVpnClientCertificateRevocationListInput) (*ec2.ImportClientVpnClientCertificateRevocationListOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ImportClientVpnClientCertificateRevocationList", arg0)
-	ret0, _ := ret[0].(*ec2.ImportClientVpnClientCertificateRevocationListOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ImportClientVpnClientCertificateRevocationList indicates an expected call of ImportClientVpnClientCertificateRevocationList.
-func (mr *MockEC2APIMockRecorder) ImportClientVpnClientCertificateRevocationList(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportClientVpnClientCertificateRevocationList", reflect.TypeOf((*MockEC2API)(nil).ImportClientVpnClientCertificateRevocationList), arg0)
-}
-
-// ImportClientVpnClientCertificateRevocationListRequest mocks base method.
-func (m *MockEC2API) ImportClientVpnClientCertificateRevocationListRequest(arg0 *ec2.ImportClientVpnClientCertificateRevocationListInput) (*request.Request, *ec2.ImportClientVpnClientCertificateRevocationListOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ImportClientVpnClientCertificateRevocationListRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ImportClientVpnClientCertificateRevocationListOutput)
-	return ret0, ret1
-}
-
-// ImportClientVpnClientCertificateRevocationListRequest indicates an expected call of ImportClientVpnClientCertificateRevocationListRequest.
-func (mr *MockEC2APIMockRecorder) ImportClientVpnClientCertificateRevocationListRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportClientVpnClientCertificateRevocationListRequest", reflect.TypeOf((*MockEC2API)(nil).ImportClientVpnClientCertificateRevocationListRequest), arg0)
-}
-
-// ImportClientVpnClientCertificateRevocationListWithContext mocks base method.
-func (m *MockEC2API) ImportClientVpnClientCertificateRevocationListWithContext(arg0 context.Context, arg1 *ec2.ImportClientVpnClientCertificateRevocationListInput, arg2 ...request.Option) (*ec2.ImportClientVpnClientCertificateRevocationListOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ImportClientVpnClientCertificateRevocationListWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ImportClientVpnClientCertificateRevocationListOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ImportClientVpnClientCertificateRevocationListWithContext indicates an expected call of ImportClientVpnClientCertificateRevocationListWithContext.
-func (mr *MockEC2APIMockRecorder) ImportClientVpnClientCertificateRevocationListWithContext(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, "ImportClientVpnClientCertificateRevocationListWithContext", reflect.TypeOf((*MockEC2API)(nil).ImportClientVpnClientCertificateRevocationListWithContext), varargs...)
-}
-
-// ImportImage mocks base method.
-func (m *MockEC2API) ImportImage(arg0 *ec2.ImportImageInput) (*ec2.ImportImageOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ImportImage", arg0)
-	ret0, _ := ret[0].(*ec2.ImportImageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ImportImage indicates an expected call of ImportImage.
-func (mr *MockEC2APIMockRecorder) ImportImage(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportImage", reflect.TypeOf((*MockEC2API)(nil).ImportImage), arg0)
-}
-
-// ImportImageRequest mocks base method.
-func (m *MockEC2API) ImportImageRequest(arg0 *ec2.ImportImageInput) (*request.Request, *ec2.ImportImageOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ImportImageRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ImportImageOutput)
-	return ret0, ret1
-}
-
-// ImportImageRequest indicates an expected call of ImportImageRequest.
-func (mr *MockEC2APIMockRecorder) ImportImageRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportImageRequest", reflect.TypeOf((*MockEC2API)(nil).ImportImageRequest), arg0)
-}
-
-// ImportImageWithContext mocks base method.
-func (m *MockEC2API) ImportImageWithContext(arg0 context.Context, arg1 *ec2.ImportImageInput, arg2 ...request.Option) (*ec2.ImportImageOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ImportImageWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ImportImageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ImportImageWithContext indicates an expected call of ImportImageWithContext.
-func (mr *MockEC2APIMockRecorder) ImportImageWithContext(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, "ImportImageWithContext", reflect.TypeOf((*MockEC2API)(nil).ImportImageWithContext), varargs...)
-}
-
-// ImportInstance mocks base method.
-func (m *MockEC2API) ImportInstance(arg0 *ec2.ImportInstanceInput) (*ec2.ImportInstanceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ImportInstance", arg0)
-	ret0, _ := ret[0].(*ec2.ImportInstanceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ImportInstance indicates an expected call of ImportInstance.
-func (mr *MockEC2APIMockRecorder) ImportInstance(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportInstance", reflect.TypeOf((*MockEC2API)(nil).ImportInstance), arg0)
-}
-
-// ImportInstanceRequest mocks base method.
-func (m *MockEC2API) ImportInstanceRequest(arg0 *ec2.ImportInstanceInput) (*request.Request, *ec2.ImportInstanceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ImportInstanceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ImportInstanceOutput)
-	return ret0, ret1
-}
-
-// ImportInstanceRequest indicates an expected call of ImportInstanceRequest.
-func (mr *MockEC2APIMockRecorder) ImportInstanceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportInstanceRequest", reflect.TypeOf((*MockEC2API)(nil).ImportInstanceRequest), arg0)
-}
-
-// ImportInstanceWithContext mocks base method.
-func (m *MockEC2API) ImportInstanceWithContext(arg0 context.Context, arg1 *ec2.ImportInstanceInput, arg2 ...request.Option) (*ec2.ImportInstanceOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ImportInstanceWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ImportInstanceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ImportInstanceWithContext indicates an expected call of ImportInstanceWithContext.
-func (mr *MockEC2APIMockRecorder) ImportInstanceWithContext(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, "ImportInstanceWithContext", reflect.TypeOf((*MockEC2API)(nil).ImportInstanceWithContext), varargs...)
-}
-
-// ImportKeyPair mocks base method.
-func (m *MockEC2API) ImportKeyPair(arg0 *ec2.ImportKeyPairInput) (*ec2.ImportKeyPairOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ImportKeyPair", arg0)
-	ret0, _ := ret[0].(*ec2.ImportKeyPairOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ImportKeyPair indicates an expected call of ImportKeyPair.
-func (mr *MockEC2APIMockRecorder) ImportKeyPair(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportKeyPair", reflect.TypeOf((*MockEC2API)(nil).ImportKeyPair), arg0)
-}
-
-// ImportKeyPairRequest mocks base method.
-func (m *MockEC2API) ImportKeyPairRequest(arg0 *ec2.ImportKeyPairInput) (*request.Request, *ec2.ImportKeyPairOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ImportKeyPairRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ImportKeyPairOutput)
-	return ret0, ret1
-}
-
-// ImportKeyPairRequest indicates an expected call of ImportKeyPairRequest.
-func (mr *MockEC2APIMockRecorder) ImportKeyPairRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportKeyPairRequest", reflect.TypeOf((*MockEC2API)(nil).ImportKeyPairRequest), arg0)
-}
-
-// ImportKeyPairWithContext mocks base method.
-func (m *MockEC2API) ImportKeyPairWithContext(arg0 context.Context, arg1 *ec2.ImportKeyPairInput, arg2 ...request.Option) (*ec2.ImportKeyPairOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ImportKeyPairWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ImportKeyPairOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ImportKeyPairWithContext indicates an expected call of ImportKeyPairWithContext.
-func (mr *MockEC2APIMockRecorder) ImportKeyPairWithContext(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, "ImportKeyPairWithContext", reflect.TypeOf((*MockEC2API)(nil).ImportKeyPairWithContext), varargs...)
-}
-
-// ImportSnapshot mocks base method.
-func (m *MockEC2API) ImportSnapshot(arg0 *ec2.ImportSnapshotInput) (*ec2.ImportSnapshotOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ImportSnapshot", arg0)
-	ret0, _ := ret[0].(*ec2.ImportSnapshotOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ImportSnapshot indicates an expected call of ImportSnapshot.
-func (mr *MockEC2APIMockRecorder) ImportSnapshot(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportSnapshot", reflect.TypeOf((*MockEC2API)(nil).ImportSnapshot), arg0)
-}
-
-// ImportSnapshotRequest mocks base method.
-func (m *MockEC2API) ImportSnapshotRequest(arg0 *ec2.ImportSnapshotInput) (*request.Request, *ec2.ImportSnapshotOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ImportSnapshotRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ImportSnapshotOutput)
-	return ret0, ret1
-}
-
-// ImportSnapshotRequest indicates an expected call of ImportSnapshotRequest.
-func (mr *MockEC2APIMockRecorder) ImportSnapshotRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportSnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).ImportSnapshotRequest), arg0)
-}
-
-// ImportSnapshotWithContext mocks base method.
-func (m *MockEC2API) ImportSnapshotWithContext(arg0 context.Context, arg1 *ec2.ImportSnapshotInput, arg2 ...request.Option) (*ec2.ImportSnapshotOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ImportSnapshotWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ImportSnapshotOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ImportSnapshotWithContext indicates an expected call of ImportSnapshotWithContext.
-func (mr *MockEC2APIMockRecorder) ImportSnapshotWithContext(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, "ImportSnapshotWithContext", reflect.TypeOf((*MockEC2API)(nil).ImportSnapshotWithContext), varargs...)
-}
-
-// ImportVolume mocks base method.
-func (m *MockEC2API) ImportVolume(arg0 *ec2.ImportVolumeInput) (*ec2.ImportVolumeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ImportVolume", arg0)
-	ret0, _ := ret[0].(*ec2.ImportVolumeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ImportVolume indicates an expected call of ImportVolume.
-func (mr *MockEC2APIMockRecorder) ImportVolume(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportVolume", reflect.TypeOf((*MockEC2API)(nil).ImportVolume), arg0)
-}
-
-// ImportVolumeRequest mocks base method.
-func (m *MockEC2API) ImportVolumeRequest(arg0 *ec2.ImportVolumeInput) (*request.Request, *ec2.ImportVolumeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ImportVolumeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ImportVolumeOutput)
-	return ret0, ret1
-}
-
-// ImportVolumeRequest indicates an expected call of ImportVolumeRequest.
-func (mr *MockEC2APIMockRecorder) ImportVolumeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).ImportVolumeRequest), arg0)
-}
-
-// ImportVolumeWithContext mocks base method.
-func (m *MockEC2API) ImportVolumeWithContext(arg0 context.Context, arg1 *ec2.ImportVolumeInput, arg2 ...request.Option) (*ec2.ImportVolumeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ImportVolumeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ImportVolumeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ImportVolumeWithContext indicates an expected call of ImportVolumeWithContext.
-func (mr *MockEC2APIMockRecorder) ImportVolumeWithContext(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, "ImportVolumeWithContext", reflect.TypeOf((*MockEC2API)(nil).ImportVolumeWithContext), varargs...)
-}
-
-// ListImagesInRecycleBin mocks base method.
-func (m *MockEC2API) ListImagesInRecycleBin(arg0 *ec2.ListImagesInRecycleBinInput) (*ec2.ListImagesInRecycleBinOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListImagesInRecycleBin", arg0)
-	ret0, _ := ret[0].(*ec2.ListImagesInRecycleBinOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListImagesInRecycleBin indicates an expected call of ListImagesInRecycleBin.
-func (mr *MockEC2APIMockRecorder) ListImagesInRecycleBin(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImagesInRecycleBin", reflect.TypeOf((*MockEC2API)(nil).ListImagesInRecycleBin), arg0)
-}
-
-// ListImagesInRecycleBinPages mocks base method.
-func (m *MockEC2API) ListImagesInRecycleBinPages(arg0 *ec2.ListImagesInRecycleBinInput, arg1 func(*ec2.ListImagesInRecycleBinOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListImagesInRecycleBinPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// ListImagesInRecycleBinPages indicates an expected call of ListImagesInRecycleBinPages.
-func (mr *MockEC2APIMockRecorder) ListImagesInRecycleBinPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImagesInRecycleBinPages", reflect.TypeOf((*MockEC2API)(nil).ListImagesInRecycleBinPages), arg0, arg1)
-}
-
-// ListImagesInRecycleBinPagesWithContext mocks base method.
-func (m *MockEC2API) ListImagesInRecycleBinPagesWithContext(arg0 context.Context, arg1 *ec2.ListImagesInRecycleBinInput, arg2 func(*ec2.ListImagesInRecycleBinOutput, 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, "ListImagesInRecycleBinPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// ListImagesInRecycleBinPagesWithContext indicates an expected call of ListImagesInRecycleBinPagesWithContext.
-func (mr *MockEC2APIMockRecorder) ListImagesInRecycleBinPagesWithContext(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, "ListImagesInRecycleBinPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).ListImagesInRecycleBinPagesWithContext), varargs...)
-}
-
-// ListImagesInRecycleBinRequest mocks base method.
-func (m *MockEC2API) ListImagesInRecycleBinRequest(arg0 *ec2.ListImagesInRecycleBinInput) (*request.Request, *ec2.ListImagesInRecycleBinOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListImagesInRecycleBinRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ListImagesInRecycleBinOutput)
-	return ret0, ret1
-}
-
-// ListImagesInRecycleBinRequest indicates an expected call of ListImagesInRecycleBinRequest.
-func (mr *MockEC2APIMockRecorder) ListImagesInRecycleBinRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImagesInRecycleBinRequest", reflect.TypeOf((*MockEC2API)(nil).ListImagesInRecycleBinRequest), arg0)
-}
-
-// ListImagesInRecycleBinWithContext mocks base method.
-func (m *MockEC2API) ListImagesInRecycleBinWithContext(arg0 context.Context, arg1 *ec2.ListImagesInRecycleBinInput, arg2 ...request.Option) (*ec2.ListImagesInRecycleBinOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ListImagesInRecycleBinWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ListImagesInRecycleBinOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListImagesInRecycleBinWithContext indicates an expected call of ListImagesInRecycleBinWithContext.
-func (mr *MockEC2APIMockRecorder) ListImagesInRecycleBinWithContext(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, "ListImagesInRecycleBinWithContext", reflect.TypeOf((*MockEC2API)(nil).ListImagesInRecycleBinWithContext), varargs...)
-}
-
-// ListSnapshotsInRecycleBin mocks base method.
-func (m *MockEC2API) ListSnapshotsInRecycleBin(arg0 *ec2.ListSnapshotsInRecycleBinInput) (*ec2.ListSnapshotsInRecycleBinOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListSnapshotsInRecycleBin", arg0)
-	ret0, _ := ret[0].(*ec2.ListSnapshotsInRecycleBinOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListSnapshotsInRecycleBin indicates an expected call of ListSnapshotsInRecycleBin.
-func (mr *MockEC2APIMockRecorder) ListSnapshotsInRecycleBin(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSnapshotsInRecycleBin", reflect.TypeOf((*MockEC2API)(nil).ListSnapshotsInRecycleBin), arg0)
-}
-
-// ListSnapshotsInRecycleBinPages mocks base method.
-func (m *MockEC2API) ListSnapshotsInRecycleBinPages(arg0 *ec2.ListSnapshotsInRecycleBinInput, arg1 func(*ec2.ListSnapshotsInRecycleBinOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListSnapshotsInRecycleBinPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// ListSnapshotsInRecycleBinPages indicates an expected call of ListSnapshotsInRecycleBinPages.
-func (mr *MockEC2APIMockRecorder) ListSnapshotsInRecycleBinPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSnapshotsInRecycleBinPages", reflect.TypeOf((*MockEC2API)(nil).ListSnapshotsInRecycleBinPages), arg0, arg1)
-}
-
-// ListSnapshotsInRecycleBinPagesWithContext mocks base method.
-func (m *MockEC2API) ListSnapshotsInRecycleBinPagesWithContext(arg0 context.Context, arg1 *ec2.ListSnapshotsInRecycleBinInput, arg2 func(*ec2.ListSnapshotsInRecycleBinOutput, 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, "ListSnapshotsInRecycleBinPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// ListSnapshotsInRecycleBinPagesWithContext indicates an expected call of ListSnapshotsInRecycleBinPagesWithContext.
-func (mr *MockEC2APIMockRecorder) ListSnapshotsInRecycleBinPagesWithContext(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, "ListSnapshotsInRecycleBinPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).ListSnapshotsInRecycleBinPagesWithContext), varargs...)
-}
-
-// ListSnapshotsInRecycleBinRequest mocks base method.
-func (m *MockEC2API) ListSnapshotsInRecycleBinRequest(arg0 *ec2.ListSnapshotsInRecycleBinInput) (*request.Request, *ec2.ListSnapshotsInRecycleBinOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListSnapshotsInRecycleBinRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ListSnapshotsInRecycleBinOutput)
-	return ret0, ret1
-}
-
-// ListSnapshotsInRecycleBinRequest indicates an expected call of ListSnapshotsInRecycleBinRequest.
-func (mr *MockEC2APIMockRecorder) ListSnapshotsInRecycleBinRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSnapshotsInRecycleBinRequest", reflect.TypeOf((*MockEC2API)(nil).ListSnapshotsInRecycleBinRequest), arg0)
-}
-
-// ListSnapshotsInRecycleBinWithContext mocks base method.
-func (m *MockEC2API) ListSnapshotsInRecycleBinWithContext(arg0 context.Context, arg1 *ec2.ListSnapshotsInRecycleBinInput, arg2 ...request.Option) (*ec2.ListSnapshotsInRecycleBinOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ListSnapshotsInRecycleBinWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ListSnapshotsInRecycleBinOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListSnapshotsInRecycleBinWithContext indicates an expected call of ListSnapshotsInRecycleBinWithContext.
-func (mr *MockEC2APIMockRecorder) ListSnapshotsInRecycleBinWithContext(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, "ListSnapshotsInRecycleBinWithContext", reflect.TypeOf((*MockEC2API)(nil).ListSnapshotsInRecycleBinWithContext), varargs...)
-}
-
-// LockSnapshot mocks base method.
-func (m *MockEC2API) LockSnapshot(arg0 *ec2.LockSnapshotInput) (*ec2.LockSnapshotOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "LockSnapshot", arg0)
-	ret0, _ := ret[0].(*ec2.LockSnapshotOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// LockSnapshot indicates an expected call of LockSnapshot.
-func (mr *MockEC2APIMockRecorder) LockSnapshot(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LockSnapshot", reflect.TypeOf((*MockEC2API)(nil).LockSnapshot), arg0)
-}
-
-// LockSnapshotRequest mocks base method.
-func (m *MockEC2API) LockSnapshotRequest(arg0 *ec2.LockSnapshotInput) (*request.Request, *ec2.LockSnapshotOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "LockSnapshotRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.LockSnapshotOutput)
-	return ret0, ret1
-}
-
-// LockSnapshotRequest indicates an expected call of LockSnapshotRequest.
-func (mr *MockEC2APIMockRecorder) LockSnapshotRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LockSnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).LockSnapshotRequest), arg0)
-}
-
-// LockSnapshotWithContext mocks base method.
-func (m *MockEC2API) LockSnapshotWithContext(arg0 context.Context, arg1 *ec2.LockSnapshotInput, arg2 ...request.Option) (*ec2.LockSnapshotOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "LockSnapshotWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.LockSnapshotOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// LockSnapshotWithContext indicates an expected call of LockSnapshotWithContext.
-func (mr *MockEC2APIMockRecorder) LockSnapshotWithContext(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, "LockSnapshotWithContext", reflect.TypeOf((*MockEC2API)(nil).LockSnapshotWithContext), varargs...)
-}
-
-// ModifyAddressAttribute mocks base method.
-func (m *MockEC2API) ModifyAddressAttribute(arg0 *ec2.ModifyAddressAttributeInput) (*ec2.ModifyAddressAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyAddressAttribute", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyAddressAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyAddressAttribute indicates an expected call of ModifyAddressAttribute.
-func (mr *MockEC2APIMockRecorder) ModifyAddressAttribute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyAddressAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyAddressAttribute), arg0)
-}
-
-// ModifyAddressAttributeRequest mocks base method.
-func (m *MockEC2API) ModifyAddressAttributeRequest(arg0 *ec2.ModifyAddressAttributeInput) (*request.Request, *ec2.ModifyAddressAttributeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyAddressAttributeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyAddressAttributeOutput)
-	return ret0, ret1
-}
-
-// ModifyAddressAttributeRequest indicates an expected call of ModifyAddressAttributeRequest.
-func (mr *MockEC2APIMockRecorder) ModifyAddressAttributeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyAddressAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyAddressAttributeRequest), arg0)
-}
-
-// ModifyAddressAttributeWithContext mocks base method.
-func (m *MockEC2API) ModifyAddressAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyAddressAttributeInput, arg2 ...request.Option) (*ec2.ModifyAddressAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyAddressAttributeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyAddressAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyAddressAttributeWithContext indicates an expected call of ModifyAddressAttributeWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyAddressAttributeWithContext(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, "ModifyAddressAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyAddressAttributeWithContext), varargs...)
-}
-
-// ModifyAvailabilityZoneGroup mocks base method.
-func (m *MockEC2API) ModifyAvailabilityZoneGroup(arg0 *ec2.ModifyAvailabilityZoneGroupInput) (*ec2.ModifyAvailabilityZoneGroupOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyAvailabilityZoneGroup", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyAvailabilityZoneGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyAvailabilityZoneGroup indicates an expected call of ModifyAvailabilityZoneGroup.
-func (mr *MockEC2APIMockRecorder) ModifyAvailabilityZoneGroup(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyAvailabilityZoneGroup", reflect.TypeOf((*MockEC2API)(nil).ModifyAvailabilityZoneGroup), arg0)
-}
-
-// ModifyAvailabilityZoneGroupRequest mocks base method.
-func (m *MockEC2API) ModifyAvailabilityZoneGroupRequest(arg0 *ec2.ModifyAvailabilityZoneGroupInput) (*request.Request, *ec2.ModifyAvailabilityZoneGroupOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyAvailabilityZoneGroupRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyAvailabilityZoneGroupOutput)
-	return ret0, ret1
-}
-
-// ModifyAvailabilityZoneGroupRequest indicates an expected call of ModifyAvailabilityZoneGroupRequest.
-func (mr *MockEC2APIMockRecorder) ModifyAvailabilityZoneGroupRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyAvailabilityZoneGroupRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyAvailabilityZoneGroupRequest), arg0)
-}
-
-// ModifyAvailabilityZoneGroupWithContext mocks base method.
-func (m *MockEC2API) ModifyAvailabilityZoneGroupWithContext(arg0 context.Context, arg1 *ec2.ModifyAvailabilityZoneGroupInput, arg2 ...request.Option) (*ec2.ModifyAvailabilityZoneGroupOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyAvailabilityZoneGroupWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyAvailabilityZoneGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyAvailabilityZoneGroupWithContext indicates an expected call of ModifyAvailabilityZoneGroupWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyAvailabilityZoneGroupWithContext(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, "ModifyAvailabilityZoneGroupWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyAvailabilityZoneGroupWithContext), varargs...)
-}
-
-// ModifyCapacityReservation mocks base method.
-func (m *MockEC2API) ModifyCapacityReservation(arg0 *ec2.ModifyCapacityReservationInput) (*ec2.ModifyCapacityReservationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyCapacityReservation", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyCapacityReservationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyCapacityReservation indicates an expected call of ModifyCapacityReservation.
-func (mr *MockEC2APIMockRecorder) ModifyCapacityReservation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCapacityReservation", reflect.TypeOf((*MockEC2API)(nil).ModifyCapacityReservation), arg0)
-}
-
-// ModifyCapacityReservationFleet mocks base method.
-func (m *MockEC2API) ModifyCapacityReservationFleet(arg0 *ec2.ModifyCapacityReservationFleetInput) (*ec2.ModifyCapacityReservationFleetOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyCapacityReservationFleet", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyCapacityReservationFleetOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyCapacityReservationFleet indicates an expected call of ModifyCapacityReservationFleet.
-func (mr *MockEC2APIMockRecorder) ModifyCapacityReservationFleet(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCapacityReservationFleet", reflect.TypeOf((*MockEC2API)(nil).ModifyCapacityReservationFleet), arg0)
-}
-
-// ModifyCapacityReservationFleetRequest mocks base method.
-func (m *MockEC2API) ModifyCapacityReservationFleetRequest(arg0 *ec2.ModifyCapacityReservationFleetInput) (*request.Request, *ec2.ModifyCapacityReservationFleetOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyCapacityReservationFleetRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyCapacityReservationFleetOutput)
-	return ret0, ret1
-}
-
-// ModifyCapacityReservationFleetRequest indicates an expected call of ModifyCapacityReservationFleetRequest.
-func (mr *MockEC2APIMockRecorder) ModifyCapacityReservationFleetRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCapacityReservationFleetRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyCapacityReservationFleetRequest), arg0)
-}
-
-// ModifyCapacityReservationFleetWithContext mocks base method.
-func (m *MockEC2API) ModifyCapacityReservationFleetWithContext(arg0 context.Context, arg1 *ec2.ModifyCapacityReservationFleetInput, arg2 ...request.Option) (*ec2.ModifyCapacityReservationFleetOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyCapacityReservationFleetWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyCapacityReservationFleetOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyCapacityReservationFleetWithContext indicates an expected call of ModifyCapacityReservationFleetWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyCapacityReservationFleetWithContext(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, "ModifyCapacityReservationFleetWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyCapacityReservationFleetWithContext), varargs...)
-}
-
-// ModifyCapacityReservationRequest mocks base method.
-func (m *MockEC2API) ModifyCapacityReservationRequest(arg0 *ec2.ModifyCapacityReservationInput) (*request.Request, *ec2.ModifyCapacityReservationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyCapacityReservationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyCapacityReservationOutput)
-	return ret0, ret1
-}
-
-// ModifyCapacityReservationRequest indicates an expected call of ModifyCapacityReservationRequest.
-func (mr *MockEC2APIMockRecorder) ModifyCapacityReservationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCapacityReservationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyCapacityReservationRequest), arg0)
-}
-
-// ModifyCapacityReservationWithContext mocks base method.
-func (m *MockEC2API) ModifyCapacityReservationWithContext(arg0 context.Context, arg1 *ec2.ModifyCapacityReservationInput, arg2 ...request.Option) (*ec2.ModifyCapacityReservationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyCapacityReservationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyCapacityReservationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyCapacityReservationWithContext indicates an expected call of ModifyCapacityReservationWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyCapacityReservationWithContext(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, "ModifyCapacityReservationWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyCapacityReservationWithContext), varargs...)
-}
-
-// ModifyClientVpnEndpoint mocks base method.
-func (m *MockEC2API) ModifyClientVpnEndpoint(arg0 *ec2.ModifyClientVpnEndpointInput) (*ec2.ModifyClientVpnEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyClientVpnEndpoint", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyClientVpnEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyClientVpnEndpoint indicates an expected call of ModifyClientVpnEndpoint.
-func (mr *MockEC2APIMockRecorder) ModifyClientVpnEndpoint(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyClientVpnEndpoint", reflect.TypeOf((*MockEC2API)(nil).ModifyClientVpnEndpoint), arg0)
-}
-
-// ModifyClientVpnEndpointRequest mocks base method.
-func (m *MockEC2API) ModifyClientVpnEndpointRequest(arg0 *ec2.ModifyClientVpnEndpointInput) (*request.Request, *ec2.ModifyClientVpnEndpointOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyClientVpnEndpointRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyClientVpnEndpointOutput)
-	return ret0, ret1
-}
-
-// ModifyClientVpnEndpointRequest indicates an expected call of ModifyClientVpnEndpointRequest.
-func (mr *MockEC2APIMockRecorder) ModifyClientVpnEndpointRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyClientVpnEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyClientVpnEndpointRequest), arg0)
-}
-
-// ModifyClientVpnEndpointWithContext mocks base method.
-func (m *MockEC2API) ModifyClientVpnEndpointWithContext(arg0 context.Context, arg1 *ec2.ModifyClientVpnEndpointInput, arg2 ...request.Option) (*ec2.ModifyClientVpnEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyClientVpnEndpointWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyClientVpnEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyClientVpnEndpointWithContext indicates an expected call of ModifyClientVpnEndpointWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyClientVpnEndpointWithContext(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, "ModifyClientVpnEndpointWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyClientVpnEndpointWithContext), varargs...)
-}
-
-// ModifyDefaultCreditSpecification mocks base method.
-func (m *MockEC2API) ModifyDefaultCreditSpecification(arg0 *ec2.ModifyDefaultCreditSpecificationInput) (*ec2.ModifyDefaultCreditSpecificationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyDefaultCreditSpecification", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyDefaultCreditSpecificationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyDefaultCreditSpecification indicates an expected call of ModifyDefaultCreditSpecification.
-func (mr *MockEC2APIMockRecorder) ModifyDefaultCreditSpecification(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDefaultCreditSpecification", reflect.TypeOf((*MockEC2API)(nil).ModifyDefaultCreditSpecification), arg0)
-}
-
-// ModifyDefaultCreditSpecificationRequest mocks base method.
-func (m *MockEC2API) ModifyDefaultCreditSpecificationRequest(arg0 *ec2.ModifyDefaultCreditSpecificationInput) (*request.Request, *ec2.ModifyDefaultCreditSpecificationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyDefaultCreditSpecificationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyDefaultCreditSpecificationOutput)
-	return ret0, ret1
-}
-
-// ModifyDefaultCreditSpecificationRequest indicates an expected call of ModifyDefaultCreditSpecificationRequest.
-func (mr *MockEC2APIMockRecorder) ModifyDefaultCreditSpecificationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDefaultCreditSpecificationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyDefaultCreditSpecificationRequest), arg0)
-}
-
-// ModifyDefaultCreditSpecificationWithContext mocks base method.
-func (m *MockEC2API) ModifyDefaultCreditSpecificationWithContext(arg0 context.Context, arg1 *ec2.ModifyDefaultCreditSpecificationInput, arg2 ...request.Option) (*ec2.ModifyDefaultCreditSpecificationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyDefaultCreditSpecificationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyDefaultCreditSpecificationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyDefaultCreditSpecificationWithContext indicates an expected call of ModifyDefaultCreditSpecificationWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyDefaultCreditSpecificationWithContext(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, "ModifyDefaultCreditSpecificationWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyDefaultCreditSpecificationWithContext), varargs...)
-}
-
-// ModifyEbsDefaultKmsKeyId mocks base method.
-func (m *MockEC2API) ModifyEbsDefaultKmsKeyId(arg0 *ec2.ModifyEbsDefaultKmsKeyIdInput) (*ec2.ModifyEbsDefaultKmsKeyIdOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyEbsDefaultKmsKeyId", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyEbsDefaultKmsKeyIdOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyEbsDefaultKmsKeyId indicates an expected call of ModifyEbsDefaultKmsKeyId.
-func (mr *MockEC2APIMockRecorder) ModifyEbsDefaultKmsKeyId(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyEbsDefaultKmsKeyId", reflect.TypeOf((*MockEC2API)(nil).ModifyEbsDefaultKmsKeyId), arg0)
-}
-
-// ModifyEbsDefaultKmsKeyIdRequest mocks base method.
-func (m *MockEC2API) ModifyEbsDefaultKmsKeyIdRequest(arg0 *ec2.ModifyEbsDefaultKmsKeyIdInput) (*request.Request, *ec2.ModifyEbsDefaultKmsKeyIdOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyEbsDefaultKmsKeyIdRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyEbsDefaultKmsKeyIdOutput)
-	return ret0, ret1
-}
-
-// ModifyEbsDefaultKmsKeyIdRequest indicates an expected call of ModifyEbsDefaultKmsKeyIdRequest.
-func (mr *MockEC2APIMockRecorder) ModifyEbsDefaultKmsKeyIdRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyEbsDefaultKmsKeyIdRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyEbsDefaultKmsKeyIdRequest), arg0)
-}
-
-// ModifyEbsDefaultKmsKeyIdWithContext mocks base method.
-func (m *MockEC2API) ModifyEbsDefaultKmsKeyIdWithContext(arg0 context.Context, arg1 *ec2.ModifyEbsDefaultKmsKeyIdInput, arg2 ...request.Option) (*ec2.ModifyEbsDefaultKmsKeyIdOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyEbsDefaultKmsKeyIdWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyEbsDefaultKmsKeyIdOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyEbsDefaultKmsKeyIdWithContext indicates an expected call of ModifyEbsDefaultKmsKeyIdWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyEbsDefaultKmsKeyIdWithContext(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, "ModifyEbsDefaultKmsKeyIdWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyEbsDefaultKmsKeyIdWithContext), varargs...)
-}
-
-// ModifyFleet mocks base method.
-func (m *MockEC2API) ModifyFleet(arg0 *ec2.ModifyFleetInput) (*ec2.ModifyFleetOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyFleet", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyFleetOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyFleet indicates an expected call of ModifyFleet.
-func (mr *MockEC2APIMockRecorder) ModifyFleet(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFleet", reflect.TypeOf((*MockEC2API)(nil).ModifyFleet), arg0)
-}
-
-// ModifyFleetRequest mocks base method.
-func (m *MockEC2API) ModifyFleetRequest(arg0 *ec2.ModifyFleetInput) (*request.Request, *ec2.ModifyFleetOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyFleetRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyFleetOutput)
-	return ret0, ret1
-}
-
-// ModifyFleetRequest indicates an expected call of ModifyFleetRequest.
-func (mr *MockEC2APIMockRecorder) ModifyFleetRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFleetRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyFleetRequest), arg0)
-}
-
-// ModifyFleetWithContext mocks base method.
-func (m *MockEC2API) ModifyFleetWithContext(arg0 context.Context, arg1 *ec2.ModifyFleetInput, arg2 ...request.Option) (*ec2.ModifyFleetOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyFleetWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyFleetOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyFleetWithContext indicates an expected call of ModifyFleetWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyFleetWithContext(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, "ModifyFleetWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyFleetWithContext), varargs...)
-}
-
-// ModifyFpgaImageAttribute mocks base method.
-func (m *MockEC2API) ModifyFpgaImageAttribute(arg0 *ec2.ModifyFpgaImageAttributeInput) (*ec2.ModifyFpgaImageAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyFpgaImageAttribute", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyFpgaImageAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyFpgaImageAttribute indicates an expected call of ModifyFpgaImageAttribute.
-func (mr *MockEC2APIMockRecorder) ModifyFpgaImageAttribute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFpgaImageAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyFpgaImageAttribute), arg0)
-}
-
-// ModifyFpgaImageAttributeRequest mocks base method.
-func (m *MockEC2API) ModifyFpgaImageAttributeRequest(arg0 *ec2.ModifyFpgaImageAttributeInput) (*request.Request, *ec2.ModifyFpgaImageAttributeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyFpgaImageAttributeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyFpgaImageAttributeOutput)
-	return ret0, ret1
-}
-
-// ModifyFpgaImageAttributeRequest indicates an expected call of ModifyFpgaImageAttributeRequest.
-func (mr *MockEC2APIMockRecorder) ModifyFpgaImageAttributeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFpgaImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyFpgaImageAttributeRequest), arg0)
-}
-
-// ModifyFpgaImageAttributeWithContext mocks base method.
-func (m *MockEC2API) ModifyFpgaImageAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyFpgaImageAttributeInput, arg2 ...request.Option) (*ec2.ModifyFpgaImageAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyFpgaImageAttributeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyFpgaImageAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyFpgaImageAttributeWithContext indicates an expected call of ModifyFpgaImageAttributeWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyFpgaImageAttributeWithContext(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, "ModifyFpgaImageAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyFpgaImageAttributeWithContext), varargs...)
-}
-
-// ModifyHosts mocks base method.
-func (m *MockEC2API) ModifyHosts(arg0 *ec2.ModifyHostsInput) (*ec2.ModifyHostsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyHosts", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyHostsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyHosts indicates an expected call of ModifyHosts.
-func (mr *MockEC2APIMockRecorder) ModifyHosts(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyHosts", reflect.TypeOf((*MockEC2API)(nil).ModifyHosts), arg0)
-}
-
-// ModifyHostsRequest mocks base method.
-func (m *MockEC2API) ModifyHostsRequest(arg0 *ec2.ModifyHostsInput) (*request.Request, *ec2.ModifyHostsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyHostsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyHostsOutput)
-	return ret0, ret1
-}
-
-// ModifyHostsRequest indicates an expected call of ModifyHostsRequest.
-func (mr *MockEC2APIMockRecorder) ModifyHostsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyHostsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyHostsRequest), arg0)
-}
-
-// ModifyHostsWithContext mocks base method.
-func (m *MockEC2API) ModifyHostsWithContext(arg0 context.Context, arg1 *ec2.ModifyHostsInput, arg2 ...request.Option) (*ec2.ModifyHostsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyHostsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyHostsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyHostsWithContext indicates an expected call of ModifyHostsWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyHostsWithContext(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, "ModifyHostsWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyHostsWithContext), varargs...)
-}
-
-// ModifyIdFormat mocks base method.
-func (m *MockEC2API) ModifyIdFormat(arg0 *ec2.ModifyIdFormatInput) (*ec2.ModifyIdFormatOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyIdFormat", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyIdFormatOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyIdFormat indicates an expected call of ModifyIdFormat.
-func (mr *MockEC2APIMockRecorder) ModifyIdFormat(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdFormat", reflect.TypeOf((*MockEC2API)(nil).ModifyIdFormat), arg0)
-}
-
-// ModifyIdFormatRequest mocks base method.
-func (m *MockEC2API) ModifyIdFormatRequest(arg0 *ec2.ModifyIdFormatInput) (*request.Request, *ec2.ModifyIdFormatOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyIdFormatRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyIdFormatOutput)
-	return ret0, ret1
-}
-
-// ModifyIdFormatRequest indicates an expected call of ModifyIdFormatRequest.
-func (mr *MockEC2APIMockRecorder) ModifyIdFormatRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyIdFormatRequest), arg0)
-}
-
-// ModifyIdFormatWithContext mocks base method.
-func (m *MockEC2API) ModifyIdFormatWithContext(arg0 context.Context, arg1 *ec2.ModifyIdFormatInput, arg2 ...request.Option) (*ec2.ModifyIdFormatOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyIdFormatWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyIdFormatOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyIdFormatWithContext indicates an expected call of ModifyIdFormatWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyIdFormatWithContext(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, "ModifyIdFormatWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyIdFormatWithContext), varargs...)
-}
-
-// ModifyIdentityIdFormat mocks base method.
-func (m *MockEC2API) ModifyIdentityIdFormat(arg0 *ec2.ModifyIdentityIdFormatInput) (*ec2.ModifyIdentityIdFormatOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyIdentityIdFormat", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyIdentityIdFormatOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyIdentityIdFormat indicates an expected call of ModifyIdentityIdFormat.
-func (mr *MockEC2APIMockRecorder) ModifyIdentityIdFormat(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdentityIdFormat", reflect.TypeOf((*MockEC2API)(nil).ModifyIdentityIdFormat), arg0)
-}
-
-// ModifyIdentityIdFormatRequest mocks base method.
-func (m *MockEC2API) ModifyIdentityIdFormatRequest(arg0 *ec2.ModifyIdentityIdFormatInput) (*request.Request, *ec2.ModifyIdentityIdFormatOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyIdentityIdFormatRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyIdentityIdFormatOutput)
-	return ret0, ret1
-}
-
-// ModifyIdentityIdFormatRequest indicates an expected call of ModifyIdentityIdFormatRequest.
-func (mr *MockEC2APIMockRecorder) ModifyIdentityIdFormatRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdentityIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyIdentityIdFormatRequest), arg0)
-}
-
-// ModifyIdentityIdFormatWithContext mocks base method.
-func (m *MockEC2API) ModifyIdentityIdFormatWithContext(arg0 context.Context, arg1 *ec2.ModifyIdentityIdFormatInput, arg2 ...request.Option) (*ec2.ModifyIdentityIdFormatOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyIdentityIdFormatWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyIdentityIdFormatOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyIdentityIdFormatWithContext indicates an expected call of ModifyIdentityIdFormatWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyIdentityIdFormatWithContext(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, "ModifyIdentityIdFormatWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyIdentityIdFormatWithContext), varargs...)
-}
-
-// ModifyImageAttribute mocks base method.
-func (m *MockEC2API) ModifyImageAttribute(arg0 *ec2.ModifyImageAttributeInput) (*ec2.ModifyImageAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyImageAttribute", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyImageAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyImageAttribute indicates an expected call of ModifyImageAttribute.
-func (mr *MockEC2APIMockRecorder) ModifyImageAttribute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyImageAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyImageAttribute), arg0)
-}
-
-// ModifyImageAttributeRequest mocks base method.
-func (m *MockEC2API) ModifyImageAttributeRequest(arg0 *ec2.ModifyImageAttributeInput) (*request.Request, *ec2.ModifyImageAttributeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyImageAttributeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyImageAttributeOutput)
-	return ret0, ret1
-}
-
-// ModifyImageAttributeRequest indicates an expected call of ModifyImageAttributeRequest.
-func (mr *MockEC2APIMockRecorder) ModifyImageAttributeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyImageAttributeRequest), arg0)
-}
-
-// ModifyImageAttributeWithContext mocks base method.
-func (m *MockEC2API) ModifyImageAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyImageAttributeInput, arg2 ...request.Option) (*ec2.ModifyImageAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyImageAttributeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyImageAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyImageAttributeWithContext indicates an expected call of ModifyImageAttributeWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyImageAttributeWithContext(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, "ModifyImageAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyImageAttributeWithContext), varargs...)
-}
-
-// ModifyInstanceAttribute mocks base method.
-func (m *MockEC2API) ModifyInstanceAttribute(arg0 *ec2.ModifyInstanceAttributeInput) (*ec2.ModifyInstanceAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyInstanceAttribute", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyInstanceAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyInstanceAttribute indicates an expected call of ModifyInstanceAttribute.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceAttribute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceAttribute), arg0)
-}
-
-// ModifyInstanceAttributeRequest mocks base method.
-func (m *MockEC2API) ModifyInstanceAttributeRequest(arg0 *ec2.ModifyInstanceAttributeInput) (*request.Request, *ec2.ModifyInstanceAttributeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyInstanceAttributeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyInstanceAttributeOutput)
-	return ret0, ret1
-}
-
-// ModifyInstanceAttributeRequest indicates an expected call of ModifyInstanceAttributeRequest.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceAttributeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceAttributeRequest), arg0)
-}
-
-// ModifyInstanceAttributeWithContext mocks base method.
-func (m *MockEC2API) ModifyInstanceAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceAttributeInput, arg2 ...request.Option) (*ec2.ModifyInstanceAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyInstanceAttributeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyInstanceAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyInstanceAttributeWithContext indicates an expected call of ModifyInstanceAttributeWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceAttributeWithContext(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, "ModifyInstanceAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceAttributeWithContext), varargs...)
-}
-
-// ModifyInstanceCapacityReservationAttributes mocks base method.
-func (m *MockEC2API) ModifyInstanceCapacityReservationAttributes(arg0 *ec2.ModifyInstanceCapacityReservationAttributesInput) (*ec2.ModifyInstanceCapacityReservationAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyInstanceCapacityReservationAttributes", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyInstanceCapacityReservationAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyInstanceCapacityReservationAttributes indicates an expected call of ModifyInstanceCapacityReservationAttributes.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceCapacityReservationAttributes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCapacityReservationAttributes", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCapacityReservationAttributes), arg0)
-}
-
-// ModifyInstanceCapacityReservationAttributesRequest mocks base method.
-func (m *MockEC2API) ModifyInstanceCapacityReservationAttributesRequest(arg0 *ec2.ModifyInstanceCapacityReservationAttributesInput) (*request.Request, *ec2.ModifyInstanceCapacityReservationAttributesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyInstanceCapacityReservationAttributesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyInstanceCapacityReservationAttributesOutput)
-	return ret0, ret1
-}
-
-// ModifyInstanceCapacityReservationAttributesRequest indicates an expected call of ModifyInstanceCapacityReservationAttributesRequest.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceCapacityReservationAttributesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCapacityReservationAttributesRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCapacityReservationAttributesRequest), arg0)
-}
-
-// ModifyInstanceCapacityReservationAttributesWithContext mocks base method.
-func (m *MockEC2API) ModifyInstanceCapacityReservationAttributesWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceCapacityReservationAttributesInput, arg2 ...request.Option) (*ec2.ModifyInstanceCapacityReservationAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyInstanceCapacityReservationAttributesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyInstanceCapacityReservationAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyInstanceCapacityReservationAttributesWithContext indicates an expected call of ModifyInstanceCapacityReservationAttributesWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceCapacityReservationAttributesWithContext(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, "ModifyInstanceCapacityReservationAttributesWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCapacityReservationAttributesWithContext), varargs...)
-}
-
-// ModifyInstanceCreditSpecification mocks base method.
-func (m *MockEC2API) ModifyInstanceCreditSpecification(arg0 *ec2.ModifyInstanceCreditSpecificationInput) (*ec2.ModifyInstanceCreditSpecificationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyInstanceCreditSpecification", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyInstanceCreditSpecificationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyInstanceCreditSpecification indicates an expected call of ModifyInstanceCreditSpecification.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceCreditSpecification(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCreditSpecification", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCreditSpecification), arg0)
-}
-
-// ModifyInstanceCreditSpecificationRequest mocks base method.
-func (m *MockEC2API) ModifyInstanceCreditSpecificationRequest(arg0 *ec2.ModifyInstanceCreditSpecificationInput) (*request.Request, *ec2.ModifyInstanceCreditSpecificationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyInstanceCreditSpecificationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyInstanceCreditSpecificationOutput)
-	return ret0, ret1
-}
-
-// ModifyInstanceCreditSpecificationRequest indicates an expected call of ModifyInstanceCreditSpecificationRequest.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceCreditSpecificationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCreditSpecificationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCreditSpecificationRequest), arg0)
-}
-
-// ModifyInstanceCreditSpecificationWithContext mocks base method.
-func (m *MockEC2API) ModifyInstanceCreditSpecificationWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceCreditSpecificationInput, arg2 ...request.Option) (*ec2.ModifyInstanceCreditSpecificationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyInstanceCreditSpecificationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyInstanceCreditSpecificationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyInstanceCreditSpecificationWithContext indicates an expected call of ModifyInstanceCreditSpecificationWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceCreditSpecificationWithContext(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, "ModifyInstanceCreditSpecificationWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCreditSpecificationWithContext), varargs...)
-}
-
-// ModifyInstanceEventStartTime mocks base method.
-func (m *MockEC2API) ModifyInstanceEventStartTime(arg0 *ec2.ModifyInstanceEventStartTimeInput) (*ec2.ModifyInstanceEventStartTimeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyInstanceEventStartTime", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyInstanceEventStartTimeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyInstanceEventStartTime indicates an expected call of ModifyInstanceEventStartTime.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceEventStartTime(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceEventStartTime", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceEventStartTime), arg0)
-}
-
-// ModifyInstanceEventStartTimeRequest mocks base method.
-func (m *MockEC2API) ModifyInstanceEventStartTimeRequest(arg0 *ec2.ModifyInstanceEventStartTimeInput) (*request.Request, *ec2.ModifyInstanceEventStartTimeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyInstanceEventStartTimeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyInstanceEventStartTimeOutput)
-	return ret0, ret1
-}
-
-// ModifyInstanceEventStartTimeRequest indicates an expected call of ModifyInstanceEventStartTimeRequest.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceEventStartTimeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceEventStartTimeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceEventStartTimeRequest), arg0)
-}
-
-// ModifyInstanceEventStartTimeWithContext mocks base method.
-func (m *MockEC2API) ModifyInstanceEventStartTimeWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceEventStartTimeInput, arg2 ...request.Option) (*ec2.ModifyInstanceEventStartTimeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyInstanceEventStartTimeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyInstanceEventStartTimeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyInstanceEventStartTimeWithContext indicates an expected call of ModifyInstanceEventStartTimeWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceEventStartTimeWithContext(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, "ModifyInstanceEventStartTimeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceEventStartTimeWithContext), varargs...)
-}
-
-// ModifyInstanceEventWindow mocks base method.
-func (m *MockEC2API) ModifyInstanceEventWindow(arg0 *ec2.ModifyInstanceEventWindowInput) (*ec2.ModifyInstanceEventWindowOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyInstanceEventWindow", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyInstanceEventWindowOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyInstanceEventWindow indicates an expected call of ModifyInstanceEventWindow.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceEventWindow(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceEventWindow", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceEventWindow), arg0)
-}
-
-// ModifyInstanceEventWindowRequest mocks base method.
-func (m *MockEC2API) ModifyInstanceEventWindowRequest(arg0 *ec2.ModifyInstanceEventWindowInput) (*request.Request, *ec2.ModifyInstanceEventWindowOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyInstanceEventWindowRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyInstanceEventWindowOutput)
-	return ret0, ret1
-}
-
-// ModifyInstanceEventWindowRequest indicates an expected call of ModifyInstanceEventWindowRequest.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceEventWindowRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceEventWindowRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceEventWindowRequest), arg0)
-}
-
-// ModifyInstanceEventWindowWithContext mocks base method.
-func (m *MockEC2API) ModifyInstanceEventWindowWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceEventWindowInput, arg2 ...request.Option) (*ec2.ModifyInstanceEventWindowOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyInstanceEventWindowWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyInstanceEventWindowOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyInstanceEventWindowWithContext indicates an expected call of ModifyInstanceEventWindowWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceEventWindowWithContext(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, "ModifyInstanceEventWindowWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceEventWindowWithContext), varargs...)
-}
-
-// ModifyInstanceMaintenanceOptions mocks base method.
-func (m *MockEC2API) ModifyInstanceMaintenanceOptions(arg0 *ec2.ModifyInstanceMaintenanceOptionsInput) (*ec2.ModifyInstanceMaintenanceOptionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyInstanceMaintenanceOptions", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyInstanceMaintenanceOptionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyInstanceMaintenanceOptions indicates an expected call of ModifyInstanceMaintenanceOptions.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceMaintenanceOptions(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceMaintenanceOptions", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceMaintenanceOptions), arg0)
-}
-
-// ModifyInstanceMaintenanceOptionsRequest mocks base method.
-func (m *MockEC2API) ModifyInstanceMaintenanceOptionsRequest(arg0 *ec2.ModifyInstanceMaintenanceOptionsInput) (*request.Request, *ec2.ModifyInstanceMaintenanceOptionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyInstanceMaintenanceOptionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyInstanceMaintenanceOptionsOutput)
-	return ret0, ret1
-}
-
-// ModifyInstanceMaintenanceOptionsRequest indicates an expected call of ModifyInstanceMaintenanceOptionsRequest.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceMaintenanceOptionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceMaintenanceOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceMaintenanceOptionsRequest), arg0)
-}
-
-// ModifyInstanceMaintenanceOptionsWithContext mocks base method.
-func (m *MockEC2API) ModifyInstanceMaintenanceOptionsWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceMaintenanceOptionsInput, arg2 ...request.Option) (*ec2.ModifyInstanceMaintenanceOptionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyInstanceMaintenanceOptionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyInstanceMaintenanceOptionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyInstanceMaintenanceOptionsWithContext indicates an expected call of ModifyInstanceMaintenanceOptionsWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceMaintenanceOptionsWithContext(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, "ModifyInstanceMaintenanceOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceMaintenanceOptionsWithContext), varargs...)
-}
-
-// ModifyInstanceMetadataDefaults mocks base method.
-func (m *MockEC2API) ModifyInstanceMetadataDefaults(arg0 *ec2.ModifyInstanceMetadataDefaultsInput) (*ec2.ModifyInstanceMetadataDefaultsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyInstanceMetadataDefaults", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyInstanceMetadataDefaultsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyInstanceMetadataDefaults indicates an expected call of ModifyInstanceMetadataDefaults.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceMetadataDefaults(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceMetadataDefaults", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceMetadataDefaults), arg0)
-}
-
-// ModifyInstanceMetadataDefaultsRequest mocks base method.
-func (m *MockEC2API) ModifyInstanceMetadataDefaultsRequest(arg0 *ec2.ModifyInstanceMetadataDefaultsInput) (*request.Request, *ec2.ModifyInstanceMetadataDefaultsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyInstanceMetadataDefaultsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyInstanceMetadataDefaultsOutput)
-	return ret0, ret1
-}
-
-// ModifyInstanceMetadataDefaultsRequest indicates an expected call of ModifyInstanceMetadataDefaultsRequest.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceMetadataDefaultsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceMetadataDefaultsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceMetadataDefaultsRequest), arg0)
-}
-
-// ModifyInstanceMetadataDefaultsWithContext mocks base method.
-func (m *MockEC2API) ModifyInstanceMetadataDefaultsWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceMetadataDefaultsInput, arg2 ...request.Option) (*ec2.ModifyInstanceMetadataDefaultsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyInstanceMetadataDefaultsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyInstanceMetadataDefaultsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyInstanceMetadataDefaultsWithContext indicates an expected call of ModifyInstanceMetadataDefaultsWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceMetadataDefaultsWithContext(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, "ModifyInstanceMetadataDefaultsWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceMetadataDefaultsWithContext), varargs...)
-}
-
-// ModifyInstanceMetadataOptions mocks base method.
-func (m *MockEC2API) ModifyInstanceMetadataOptions(arg0 *ec2.ModifyInstanceMetadataOptionsInput) (*ec2.ModifyInstanceMetadataOptionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyInstanceMetadataOptions", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyInstanceMetadataOptionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyInstanceMetadataOptions indicates an expected call of ModifyInstanceMetadataOptions.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceMetadataOptions(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceMetadataOptions", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceMetadataOptions), arg0)
-}
-
-// ModifyInstanceMetadataOptionsRequest mocks base method.
-func (m *MockEC2API) ModifyInstanceMetadataOptionsRequest(arg0 *ec2.ModifyInstanceMetadataOptionsInput) (*request.Request, *ec2.ModifyInstanceMetadataOptionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyInstanceMetadataOptionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyInstanceMetadataOptionsOutput)
-	return ret0, ret1
-}
-
-// ModifyInstanceMetadataOptionsRequest indicates an expected call of ModifyInstanceMetadataOptionsRequest.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceMetadataOptionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceMetadataOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceMetadataOptionsRequest), arg0)
-}
-
-// ModifyInstanceMetadataOptionsWithContext mocks base method.
-func (m *MockEC2API) ModifyInstanceMetadataOptionsWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceMetadataOptionsInput, arg2 ...request.Option) (*ec2.ModifyInstanceMetadataOptionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyInstanceMetadataOptionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyInstanceMetadataOptionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyInstanceMetadataOptionsWithContext indicates an expected call of ModifyInstanceMetadataOptionsWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyInstanceMetadataOptionsWithContext(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, "ModifyInstanceMetadataOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceMetadataOptionsWithContext), varargs...)
-}
-
-// ModifyInstancePlacement mocks base method.
-func (m *MockEC2API) ModifyInstancePlacement(arg0 *ec2.ModifyInstancePlacementInput) (*ec2.ModifyInstancePlacementOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyInstancePlacement", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyInstancePlacementOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyInstancePlacement indicates an expected call of ModifyInstancePlacement.
-func (mr *MockEC2APIMockRecorder) ModifyInstancePlacement(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstancePlacement", reflect.TypeOf((*MockEC2API)(nil).ModifyInstancePlacement), arg0)
-}
-
-// ModifyInstancePlacementRequest mocks base method.
-func (m *MockEC2API) ModifyInstancePlacementRequest(arg0 *ec2.ModifyInstancePlacementInput) (*request.Request, *ec2.ModifyInstancePlacementOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyInstancePlacementRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyInstancePlacementOutput)
-	return ret0, ret1
-}
-
-// ModifyInstancePlacementRequest indicates an expected call of ModifyInstancePlacementRequest.
-func (mr *MockEC2APIMockRecorder) ModifyInstancePlacementRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstancePlacementRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstancePlacementRequest), arg0)
-}
-
-// ModifyInstancePlacementWithContext mocks base method.
-func (m *MockEC2API) ModifyInstancePlacementWithContext(arg0 context.Context, arg1 *ec2.ModifyInstancePlacementInput, arg2 ...request.Option) (*ec2.ModifyInstancePlacementOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyInstancePlacementWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyInstancePlacementOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyInstancePlacementWithContext indicates an expected call of ModifyInstancePlacementWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyInstancePlacementWithContext(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, "ModifyInstancePlacementWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyInstancePlacementWithContext), varargs...)
-}
-
-// ModifyIpam mocks base method.
-func (m *MockEC2API) ModifyIpam(arg0 *ec2.ModifyIpamInput) (*ec2.ModifyIpamOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyIpam", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyIpamOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyIpam indicates an expected call of ModifyIpam.
-func (mr *MockEC2APIMockRecorder) ModifyIpam(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpam", reflect.TypeOf((*MockEC2API)(nil).ModifyIpam), arg0)
-}
-
-// ModifyIpamPool mocks base method.
-func (m *MockEC2API) ModifyIpamPool(arg0 *ec2.ModifyIpamPoolInput) (*ec2.ModifyIpamPoolOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyIpamPool", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyIpamPoolOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyIpamPool indicates an expected call of ModifyIpamPool.
-func (mr *MockEC2APIMockRecorder) ModifyIpamPool(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamPool", reflect.TypeOf((*MockEC2API)(nil).ModifyIpamPool), arg0)
-}
-
-// ModifyIpamPoolRequest mocks base method.
-func (m *MockEC2API) ModifyIpamPoolRequest(arg0 *ec2.ModifyIpamPoolInput) (*request.Request, *ec2.ModifyIpamPoolOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyIpamPoolRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyIpamPoolOutput)
-	return ret0, ret1
-}
-
-// ModifyIpamPoolRequest indicates an expected call of ModifyIpamPoolRequest.
-func (mr *MockEC2APIMockRecorder) ModifyIpamPoolRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamPoolRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyIpamPoolRequest), arg0)
-}
-
-// ModifyIpamPoolWithContext mocks base method.
-func (m *MockEC2API) ModifyIpamPoolWithContext(arg0 context.Context, arg1 *ec2.ModifyIpamPoolInput, arg2 ...request.Option) (*ec2.ModifyIpamPoolOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyIpamPoolWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyIpamPoolOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyIpamPoolWithContext indicates an expected call of ModifyIpamPoolWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyIpamPoolWithContext(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, "ModifyIpamPoolWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyIpamPoolWithContext), varargs...)
-}
-
-// ModifyIpamRequest mocks base method.
-func (m *MockEC2API) ModifyIpamRequest(arg0 *ec2.ModifyIpamInput) (*request.Request, *ec2.ModifyIpamOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyIpamRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyIpamOutput)
-	return ret0, ret1
-}
-
-// ModifyIpamRequest indicates an expected call of ModifyIpamRequest.
-func (mr *MockEC2APIMockRecorder) ModifyIpamRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyIpamRequest), arg0)
-}
-
-// ModifyIpamResourceCidr mocks base method.
-func (m *MockEC2API) ModifyIpamResourceCidr(arg0 *ec2.ModifyIpamResourceCidrInput) (*ec2.ModifyIpamResourceCidrOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyIpamResourceCidr", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyIpamResourceCidrOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyIpamResourceCidr indicates an expected call of ModifyIpamResourceCidr.
-func (mr *MockEC2APIMockRecorder) ModifyIpamResourceCidr(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamResourceCidr", reflect.TypeOf((*MockEC2API)(nil).ModifyIpamResourceCidr), arg0)
-}
-
-// ModifyIpamResourceCidrRequest mocks base method.
-func (m *MockEC2API) ModifyIpamResourceCidrRequest(arg0 *ec2.ModifyIpamResourceCidrInput) (*request.Request, *ec2.ModifyIpamResourceCidrOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyIpamResourceCidrRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyIpamResourceCidrOutput)
-	return ret0, ret1
-}
-
-// ModifyIpamResourceCidrRequest indicates an expected call of ModifyIpamResourceCidrRequest.
-func (mr *MockEC2APIMockRecorder) ModifyIpamResourceCidrRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamResourceCidrRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyIpamResourceCidrRequest), arg0)
-}
-
-// ModifyIpamResourceCidrWithContext mocks base method.
-func (m *MockEC2API) ModifyIpamResourceCidrWithContext(arg0 context.Context, arg1 *ec2.ModifyIpamResourceCidrInput, arg2 ...request.Option) (*ec2.ModifyIpamResourceCidrOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyIpamResourceCidrWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyIpamResourceCidrOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyIpamResourceCidrWithContext indicates an expected call of ModifyIpamResourceCidrWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyIpamResourceCidrWithContext(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, "ModifyIpamResourceCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyIpamResourceCidrWithContext), varargs...)
-}
-
-// ModifyIpamResourceDiscovery mocks base method.
-func (m *MockEC2API) ModifyIpamResourceDiscovery(arg0 *ec2.ModifyIpamResourceDiscoveryInput) (*ec2.ModifyIpamResourceDiscoveryOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyIpamResourceDiscovery", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyIpamResourceDiscoveryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyIpamResourceDiscovery indicates an expected call of ModifyIpamResourceDiscovery.
-func (mr *MockEC2APIMockRecorder) ModifyIpamResourceDiscovery(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamResourceDiscovery", reflect.TypeOf((*MockEC2API)(nil).ModifyIpamResourceDiscovery), arg0)
-}
-
-// ModifyIpamResourceDiscoveryRequest mocks base method.
-func (m *MockEC2API) ModifyIpamResourceDiscoveryRequest(arg0 *ec2.ModifyIpamResourceDiscoveryInput) (*request.Request, *ec2.ModifyIpamResourceDiscoveryOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyIpamResourceDiscoveryRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyIpamResourceDiscoveryOutput)
-	return ret0, ret1
-}
-
-// ModifyIpamResourceDiscoveryRequest indicates an expected call of ModifyIpamResourceDiscoveryRequest.
-func (mr *MockEC2APIMockRecorder) ModifyIpamResourceDiscoveryRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamResourceDiscoveryRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyIpamResourceDiscoveryRequest), arg0)
-}
-
-// ModifyIpamResourceDiscoveryWithContext mocks base method.
-func (m *MockEC2API) ModifyIpamResourceDiscoveryWithContext(arg0 context.Context, arg1 *ec2.ModifyIpamResourceDiscoveryInput, arg2 ...request.Option) (*ec2.ModifyIpamResourceDiscoveryOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyIpamResourceDiscoveryWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyIpamResourceDiscoveryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyIpamResourceDiscoveryWithContext indicates an expected call of ModifyIpamResourceDiscoveryWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyIpamResourceDiscoveryWithContext(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, "ModifyIpamResourceDiscoveryWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyIpamResourceDiscoveryWithContext), varargs...)
-}
-
-// ModifyIpamScope mocks base method.
-func (m *MockEC2API) ModifyIpamScope(arg0 *ec2.ModifyIpamScopeInput) (*ec2.ModifyIpamScopeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyIpamScope", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyIpamScopeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyIpamScope indicates an expected call of ModifyIpamScope.
-func (mr *MockEC2APIMockRecorder) ModifyIpamScope(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamScope", reflect.TypeOf((*MockEC2API)(nil).ModifyIpamScope), arg0)
-}
-
-// ModifyIpamScopeRequest mocks base method.
-func (m *MockEC2API) ModifyIpamScopeRequest(arg0 *ec2.ModifyIpamScopeInput) (*request.Request, *ec2.ModifyIpamScopeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyIpamScopeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyIpamScopeOutput)
-	return ret0, ret1
-}
-
-// ModifyIpamScopeRequest indicates an expected call of ModifyIpamScopeRequest.
-func (mr *MockEC2APIMockRecorder) ModifyIpamScopeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamScopeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyIpamScopeRequest), arg0)
-}
-
-// ModifyIpamScopeWithContext mocks base method.
-func (m *MockEC2API) ModifyIpamScopeWithContext(arg0 context.Context, arg1 *ec2.ModifyIpamScopeInput, arg2 ...request.Option) (*ec2.ModifyIpamScopeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyIpamScopeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyIpamScopeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyIpamScopeWithContext indicates an expected call of ModifyIpamScopeWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyIpamScopeWithContext(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, "ModifyIpamScopeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyIpamScopeWithContext), varargs...)
-}
-
-// ModifyIpamWithContext mocks base method.
-func (m *MockEC2API) ModifyIpamWithContext(arg0 context.Context, arg1 *ec2.ModifyIpamInput, arg2 ...request.Option) (*ec2.ModifyIpamOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyIpamWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyIpamOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyIpamWithContext indicates an expected call of ModifyIpamWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyIpamWithContext(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, "ModifyIpamWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyIpamWithContext), varargs...)
-}
-
-// ModifyLaunchTemplate mocks base method.
-func (m *MockEC2API) ModifyLaunchTemplate(arg0 *ec2.ModifyLaunchTemplateInput) (*ec2.ModifyLaunchTemplateOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyLaunchTemplate", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyLaunchTemplateOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyLaunchTemplate indicates an expected call of ModifyLaunchTemplate.
-func (mr *MockEC2APIMockRecorder) ModifyLaunchTemplate(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLaunchTemplate", reflect.TypeOf((*MockEC2API)(nil).ModifyLaunchTemplate), arg0)
-}
-
-// ModifyLaunchTemplateRequest mocks base method.
-func (m *MockEC2API) ModifyLaunchTemplateRequest(arg0 *ec2.ModifyLaunchTemplateInput) (*request.Request, *ec2.ModifyLaunchTemplateOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyLaunchTemplateRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyLaunchTemplateOutput)
-	return ret0, ret1
-}
-
-// ModifyLaunchTemplateRequest indicates an expected call of ModifyLaunchTemplateRequest.
-func (mr *MockEC2APIMockRecorder) ModifyLaunchTemplateRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLaunchTemplateRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyLaunchTemplateRequest), arg0)
-}
-
-// ModifyLaunchTemplateWithContext mocks base method.
-func (m *MockEC2API) ModifyLaunchTemplateWithContext(arg0 context.Context, arg1 *ec2.ModifyLaunchTemplateInput, arg2 ...request.Option) (*ec2.ModifyLaunchTemplateOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyLaunchTemplateWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyLaunchTemplateOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyLaunchTemplateWithContext indicates an expected call of ModifyLaunchTemplateWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyLaunchTemplateWithContext(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, "ModifyLaunchTemplateWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyLaunchTemplateWithContext), varargs...)
-}
-
-// ModifyLocalGatewayRoute mocks base method.
-func (m *MockEC2API) ModifyLocalGatewayRoute(arg0 *ec2.ModifyLocalGatewayRouteInput) (*ec2.ModifyLocalGatewayRouteOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyLocalGatewayRoute", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyLocalGatewayRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyLocalGatewayRoute indicates an expected call of ModifyLocalGatewayRoute.
-func (mr *MockEC2APIMockRecorder) ModifyLocalGatewayRoute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLocalGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).ModifyLocalGatewayRoute), arg0)
-}
-
-// ModifyLocalGatewayRouteRequest mocks base method.
-func (m *MockEC2API) ModifyLocalGatewayRouteRequest(arg0 *ec2.ModifyLocalGatewayRouteInput) (*request.Request, *ec2.ModifyLocalGatewayRouteOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyLocalGatewayRouteRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyLocalGatewayRouteOutput)
-	return ret0, ret1
-}
-
-// ModifyLocalGatewayRouteRequest indicates an expected call of ModifyLocalGatewayRouteRequest.
-func (mr *MockEC2APIMockRecorder) ModifyLocalGatewayRouteRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLocalGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyLocalGatewayRouteRequest), arg0)
-}
-
-// ModifyLocalGatewayRouteWithContext mocks base method.
-func (m *MockEC2API) ModifyLocalGatewayRouteWithContext(arg0 context.Context, arg1 *ec2.ModifyLocalGatewayRouteInput, arg2 ...request.Option) (*ec2.ModifyLocalGatewayRouteOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyLocalGatewayRouteWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyLocalGatewayRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyLocalGatewayRouteWithContext indicates an expected call of ModifyLocalGatewayRouteWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyLocalGatewayRouteWithContext(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, "ModifyLocalGatewayRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyLocalGatewayRouteWithContext), varargs...)
-}
-
-// ModifyManagedPrefixList mocks base method.
-func (m *MockEC2API) ModifyManagedPrefixList(arg0 *ec2.ModifyManagedPrefixListInput) (*ec2.ModifyManagedPrefixListOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyManagedPrefixList", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyManagedPrefixListOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyManagedPrefixList indicates an expected call of ModifyManagedPrefixList.
-func (mr *MockEC2APIMockRecorder) ModifyManagedPrefixList(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyManagedPrefixList", reflect.TypeOf((*MockEC2API)(nil).ModifyManagedPrefixList), arg0)
-}
-
-// ModifyManagedPrefixListRequest mocks base method.
-func (m *MockEC2API) ModifyManagedPrefixListRequest(arg0 *ec2.ModifyManagedPrefixListInput) (*request.Request, *ec2.ModifyManagedPrefixListOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyManagedPrefixListRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyManagedPrefixListOutput)
-	return ret0, ret1
-}
-
-// ModifyManagedPrefixListRequest indicates an expected call of ModifyManagedPrefixListRequest.
-func (mr *MockEC2APIMockRecorder) ModifyManagedPrefixListRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyManagedPrefixListRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyManagedPrefixListRequest), arg0)
-}
-
-// ModifyManagedPrefixListWithContext mocks base method.
-func (m *MockEC2API) ModifyManagedPrefixListWithContext(arg0 context.Context, arg1 *ec2.ModifyManagedPrefixListInput, arg2 ...request.Option) (*ec2.ModifyManagedPrefixListOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyManagedPrefixListWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyManagedPrefixListOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyManagedPrefixListWithContext indicates an expected call of ModifyManagedPrefixListWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyManagedPrefixListWithContext(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, "ModifyManagedPrefixListWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyManagedPrefixListWithContext), varargs...)
-}
-
-// ModifyNetworkInterfaceAttribute mocks base method.
-func (m *MockEC2API) ModifyNetworkInterfaceAttribute(arg0 *ec2.ModifyNetworkInterfaceAttributeInput) (*ec2.ModifyNetworkInterfaceAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyNetworkInterfaceAttribute", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyNetworkInterfaceAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyNetworkInterfaceAttribute indicates an expected call of ModifyNetworkInterfaceAttribute.
-func (mr *MockEC2APIMockRecorder) ModifyNetworkInterfaceAttribute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyNetworkInterfaceAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyNetworkInterfaceAttribute), arg0)
-}
-
-// ModifyNetworkInterfaceAttributeRequest mocks base method.
-func (m *MockEC2API) ModifyNetworkInterfaceAttributeRequest(arg0 *ec2.ModifyNetworkInterfaceAttributeInput) (*request.Request, *ec2.ModifyNetworkInterfaceAttributeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyNetworkInterfaceAttributeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyNetworkInterfaceAttributeOutput)
-	return ret0, ret1
-}
-
-// ModifyNetworkInterfaceAttributeRequest indicates an expected call of ModifyNetworkInterfaceAttributeRequest.
-func (mr *MockEC2APIMockRecorder) ModifyNetworkInterfaceAttributeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyNetworkInterfaceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyNetworkInterfaceAttributeRequest), arg0)
-}
-
-// ModifyNetworkInterfaceAttributeWithContext mocks base method.
-func (m *MockEC2API) ModifyNetworkInterfaceAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyNetworkInterfaceAttributeInput, arg2 ...request.Option) (*ec2.ModifyNetworkInterfaceAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyNetworkInterfaceAttributeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyNetworkInterfaceAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyNetworkInterfaceAttributeWithContext indicates an expected call of ModifyNetworkInterfaceAttributeWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyNetworkInterfaceAttributeWithContext(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, "ModifyNetworkInterfaceAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyNetworkInterfaceAttributeWithContext), varargs...)
-}
-
-// ModifyPrivateDnsNameOptions mocks base method.
-func (m *MockEC2API) ModifyPrivateDnsNameOptions(arg0 *ec2.ModifyPrivateDnsNameOptionsInput) (*ec2.ModifyPrivateDnsNameOptionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyPrivateDnsNameOptions", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyPrivateDnsNameOptionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyPrivateDnsNameOptions indicates an expected call of ModifyPrivateDnsNameOptions.
-func (mr *MockEC2APIMockRecorder) ModifyPrivateDnsNameOptions(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyPrivateDnsNameOptions", reflect.TypeOf((*MockEC2API)(nil).ModifyPrivateDnsNameOptions), arg0)
-}
-
-// ModifyPrivateDnsNameOptionsRequest mocks base method.
-func (m *MockEC2API) ModifyPrivateDnsNameOptionsRequest(arg0 *ec2.ModifyPrivateDnsNameOptionsInput) (*request.Request, *ec2.ModifyPrivateDnsNameOptionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyPrivateDnsNameOptionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyPrivateDnsNameOptionsOutput)
-	return ret0, ret1
-}
-
-// ModifyPrivateDnsNameOptionsRequest indicates an expected call of ModifyPrivateDnsNameOptionsRequest.
-func (mr *MockEC2APIMockRecorder) ModifyPrivateDnsNameOptionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyPrivateDnsNameOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyPrivateDnsNameOptionsRequest), arg0)
-}
-
-// ModifyPrivateDnsNameOptionsWithContext mocks base method.
-func (m *MockEC2API) ModifyPrivateDnsNameOptionsWithContext(arg0 context.Context, arg1 *ec2.ModifyPrivateDnsNameOptionsInput, arg2 ...request.Option) (*ec2.ModifyPrivateDnsNameOptionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyPrivateDnsNameOptionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyPrivateDnsNameOptionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyPrivateDnsNameOptionsWithContext indicates an expected call of ModifyPrivateDnsNameOptionsWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyPrivateDnsNameOptionsWithContext(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, "ModifyPrivateDnsNameOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyPrivateDnsNameOptionsWithContext), varargs...)
-}
-
-// ModifyReservedInstances mocks base method.
-func (m *MockEC2API) ModifyReservedInstances(arg0 *ec2.ModifyReservedInstancesInput) (*ec2.ModifyReservedInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyReservedInstances", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyReservedInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyReservedInstances indicates an expected call of ModifyReservedInstances.
-func (mr *MockEC2APIMockRecorder) ModifyReservedInstances(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReservedInstances", reflect.TypeOf((*MockEC2API)(nil).ModifyReservedInstances), arg0)
-}
-
-// ModifyReservedInstancesRequest mocks base method.
-func (m *MockEC2API) ModifyReservedInstancesRequest(arg0 *ec2.ModifyReservedInstancesInput) (*request.Request, *ec2.ModifyReservedInstancesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyReservedInstancesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyReservedInstancesOutput)
-	return ret0, ret1
-}
-
-// ModifyReservedInstancesRequest indicates an expected call of ModifyReservedInstancesRequest.
-func (mr *MockEC2APIMockRecorder) ModifyReservedInstancesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReservedInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyReservedInstancesRequest), arg0)
-}
-
-// ModifyReservedInstancesWithContext mocks base method.
-func (m *MockEC2API) ModifyReservedInstancesWithContext(arg0 context.Context, arg1 *ec2.ModifyReservedInstancesInput, arg2 ...request.Option) (*ec2.ModifyReservedInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyReservedInstancesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyReservedInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyReservedInstancesWithContext indicates an expected call of ModifyReservedInstancesWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyReservedInstancesWithContext(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, "ModifyReservedInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyReservedInstancesWithContext), varargs...)
-}
-
-// ModifySecurityGroupRules mocks base method.
-func (m *MockEC2API) ModifySecurityGroupRules(arg0 *ec2.ModifySecurityGroupRulesInput) (*ec2.ModifySecurityGroupRulesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifySecurityGroupRules", arg0)
-	ret0, _ := ret[0].(*ec2.ModifySecurityGroupRulesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifySecurityGroupRules indicates an expected call of ModifySecurityGroupRules.
-func (mr *MockEC2APIMockRecorder) ModifySecurityGroupRules(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySecurityGroupRules", reflect.TypeOf((*MockEC2API)(nil).ModifySecurityGroupRules), arg0)
-}
-
-// ModifySecurityGroupRulesRequest mocks base method.
-func (m *MockEC2API) ModifySecurityGroupRulesRequest(arg0 *ec2.ModifySecurityGroupRulesInput) (*request.Request, *ec2.ModifySecurityGroupRulesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifySecurityGroupRulesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifySecurityGroupRulesOutput)
-	return ret0, ret1
-}
-
-// ModifySecurityGroupRulesRequest indicates an expected call of ModifySecurityGroupRulesRequest.
-func (mr *MockEC2APIMockRecorder) ModifySecurityGroupRulesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySecurityGroupRulesRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySecurityGroupRulesRequest), arg0)
-}
-
-// ModifySecurityGroupRulesWithContext mocks base method.
-func (m *MockEC2API) ModifySecurityGroupRulesWithContext(arg0 context.Context, arg1 *ec2.ModifySecurityGroupRulesInput, arg2 ...request.Option) (*ec2.ModifySecurityGroupRulesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifySecurityGroupRulesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifySecurityGroupRulesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifySecurityGroupRulesWithContext indicates an expected call of ModifySecurityGroupRulesWithContext.
-func (mr *MockEC2APIMockRecorder) ModifySecurityGroupRulesWithContext(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, "ModifySecurityGroupRulesWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifySecurityGroupRulesWithContext), varargs...)
-}
-
-// ModifySnapshotAttribute mocks base method.
-func (m *MockEC2API) ModifySnapshotAttribute(arg0 *ec2.ModifySnapshotAttributeInput) (*ec2.ModifySnapshotAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifySnapshotAttribute", arg0)
-	ret0, _ := ret[0].(*ec2.ModifySnapshotAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifySnapshotAttribute indicates an expected call of ModifySnapshotAttribute.
-func (mr *MockEC2APIMockRecorder) ModifySnapshotAttribute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySnapshotAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifySnapshotAttribute), arg0)
-}
-
-// ModifySnapshotAttributeRequest mocks base method.
-func (m *MockEC2API) ModifySnapshotAttributeRequest(arg0 *ec2.ModifySnapshotAttributeInput) (*request.Request, *ec2.ModifySnapshotAttributeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifySnapshotAttributeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifySnapshotAttributeOutput)
-	return ret0, ret1
-}
-
-// ModifySnapshotAttributeRequest indicates an expected call of ModifySnapshotAttributeRequest.
-func (mr *MockEC2APIMockRecorder) ModifySnapshotAttributeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySnapshotAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySnapshotAttributeRequest), arg0)
-}
-
-// ModifySnapshotAttributeWithContext mocks base method.
-func (m *MockEC2API) ModifySnapshotAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifySnapshotAttributeInput, arg2 ...request.Option) (*ec2.ModifySnapshotAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifySnapshotAttributeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifySnapshotAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifySnapshotAttributeWithContext indicates an expected call of ModifySnapshotAttributeWithContext.
-func (mr *MockEC2APIMockRecorder) ModifySnapshotAttributeWithContext(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, "ModifySnapshotAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifySnapshotAttributeWithContext), varargs...)
-}
-
-// ModifySnapshotTier mocks base method.
-func (m *MockEC2API) ModifySnapshotTier(arg0 *ec2.ModifySnapshotTierInput) (*ec2.ModifySnapshotTierOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifySnapshotTier", arg0)
-	ret0, _ := ret[0].(*ec2.ModifySnapshotTierOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifySnapshotTier indicates an expected call of ModifySnapshotTier.
-func (mr *MockEC2APIMockRecorder) ModifySnapshotTier(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySnapshotTier", reflect.TypeOf((*MockEC2API)(nil).ModifySnapshotTier), arg0)
-}
-
-// ModifySnapshotTierRequest mocks base method.
-func (m *MockEC2API) ModifySnapshotTierRequest(arg0 *ec2.ModifySnapshotTierInput) (*request.Request, *ec2.ModifySnapshotTierOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifySnapshotTierRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifySnapshotTierOutput)
-	return ret0, ret1
-}
-
-// ModifySnapshotTierRequest indicates an expected call of ModifySnapshotTierRequest.
-func (mr *MockEC2APIMockRecorder) ModifySnapshotTierRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySnapshotTierRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySnapshotTierRequest), arg0)
-}
-
-// ModifySnapshotTierWithContext mocks base method.
-func (m *MockEC2API) ModifySnapshotTierWithContext(arg0 context.Context, arg1 *ec2.ModifySnapshotTierInput, arg2 ...request.Option) (*ec2.ModifySnapshotTierOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifySnapshotTierWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifySnapshotTierOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifySnapshotTierWithContext indicates an expected call of ModifySnapshotTierWithContext.
-func (mr *MockEC2APIMockRecorder) ModifySnapshotTierWithContext(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, "ModifySnapshotTierWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifySnapshotTierWithContext), varargs...)
-}
-
-// ModifySpotFleetRequest mocks base method.
-func (m *MockEC2API) ModifySpotFleetRequest(arg0 *ec2.ModifySpotFleetRequestInput) (*ec2.ModifySpotFleetRequestOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifySpotFleetRequest", arg0)
-	ret0, _ := ret[0].(*ec2.ModifySpotFleetRequestOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifySpotFleetRequest indicates an expected call of ModifySpotFleetRequest.
-func (mr *MockEC2APIMockRecorder) ModifySpotFleetRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySpotFleetRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySpotFleetRequest), arg0)
-}
-
-// ModifySpotFleetRequestRequest mocks base method.
-func (m *MockEC2API) ModifySpotFleetRequestRequest(arg0 *ec2.ModifySpotFleetRequestInput) (*request.Request, *ec2.ModifySpotFleetRequestOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifySpotFleetRequestRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifySpotFleetRequestOutput)
-	return ret0, ret1
-}
-
-// ModifySpotFleetRequestRequest indicates an expected call of ModifySpotFleetRequestRequest.
-func (mr *MockEC2APIMockRecorder) ModifySpotFleetRequestRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySpotFleetRequestRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySpotFleetRequestRequest), arg0)
-}
-
-// ModifySpotFleetRequestWithContext mocks base method.
-func (m *MockEC2API) ModifySpotFleetRequestWithContext(arg0 context.Context, arg1 *ec2.ModifySpotFleetRequestInput, arg2 ...request.Option) (*ec2.ModifySpotFleetRequestOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifySpotFleetRequestWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifySpotFleetRequestOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifySpotFleetRequestWithContext indicates an expected call of ModifySpotFleetRequestWithContext.
-func (mr *MockEC2APIMockRecorder) ModifySpotFleetRequestWithContext(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, "ModifySpotFleetRequestWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifySpotFleetRequestWithContext), varargs...)
-}
-
-// ModifySubnetAttribute mocks base method.
-func (m *MockEC2API) ModifySubnetAttribute(arg0 *ec2.ModifySubnetAttributeInput) (*ec2.ModifySubnetAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifySubnetAttribute", arg0)
-	ret0, _ := ret[0].(*ec2.ModifySubnetAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifySubnetAttribute indicates an expected call of ModifySubnetAttribute.
-func (mr *MockEC2APIMockRecorder) ModifySubnetAttribute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySubnetAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifySubnetAttribute), arg0)
-}
-
-// ModifySubnetAttributeRequest mocks base method.
-func (m *MockEC2API) ModifySubnetAttributeRequest(arg0 *ec2.ModifySubnetAttributeInput) (*request.Request, *ec2.ModifySubnetAttributeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifySubnetAttributeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifySubnetAttributeOutput)
-	return ret0, ret1
-}
-
-// ModifySubnetAttributeRequest indicates an expected call of ModifySubnetAttributeRequest.
-func (mr *MockEC2APIMockRecorder) ModifySubnetAttributeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySubnetAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySubnetAttributeRequest), arg0)
-}
-
-// ModifySubnetAttributeWithContext mocks base method.
-func (m *MockEC2API) ModifySubnetAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifySubnetAttributeInput, arg2 ...request.Option) (*ec2.ModifySubnetAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifySubnetAttributeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifySubnetAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifySubnetAttributeWithContext indicates an expected call of ModifySubnetAttributeWithContext.
-func (mr *MockEC2APIMockRecorder) ModifySubnetAttributeWithContext(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, "ModifySubnetAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifySubnetAttributeWithContext), varargs...)
-}
-
-// ModifyTrafficMirrorFilterNetworkServices mocks base method.
-func (m *MockEC2API) ModifyTrafficMirrorFilterNetworkServices(arg0 *ec2.ModifyTrafficMirrorFilterNetworkServicesInput) (*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterNetworkServices", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyTrafficMirrorFilterNetworkServices indicates an expected call of ModifyTrafficMirrorFilterNetworkServices.
-func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterNetworkServices(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterNetworkServices", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterNetworkServices), arg0)
-}
-
-// ModifyTrafficMirrorFilterNetworkServicesRequest mocks base method.
-func (m *MockEC2API) ModifyTrafficMirrorFilterNetworkServicesRequest(arg0 *ec2.ModifyTrafficMirrorFilterNetworkServicesInput) (*request.Request, *ec2.ModifyTrafficMirrorFilterNetworkServicesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterNetworkServicesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput)
-	return ret0, ret1
-}
-
-// ModifyTrafficMirrorFilterNetworkServicesRequest indicates an expected call of ModifyTrafficMirrorFilterNetworkServicesRequest.
-func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterNetworkServicesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterNetworkServicesRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterNetworkServicesRequest), arg0)
-}
-
-// ModifyTrafficMirrorFilterNetworkServicesWithContext mocks base method.
-func (m *MockEC2API) ModifyTrafficMirrorFilterNetworkServicesWithContext(arg0 context.Context, arg1 *ec2.ModifyTrafficMirrorFilterNetworkServicesInput, arg2 ...request.Option) (*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterNetworkServicesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyTrafficMirrorFilterNetworkServicesWithContext indicates an expected call of ModifyTrafficMirrorFilterNetworkServicesWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterNetworkServicesWithContext(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, "ModifyTrafficMirrorFilterNetworkServicesWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterNetworkServicesWithContext), varargs...)
-}
-
-// ModifyTrafficMirrorFilterRule mocks base method.
-func (m *MockEC2API) ModifyTrafficMirrorFilterRule(arg0 *ec2.ModifyTrafficMirrorFilterRuleInput) (*ec2.ModifyTrafficMirrorFilterRuleOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterRule", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorFilterRuleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyTrafficMirrorFilterRule indicates an expected call of ModifyTrafficMirrorFilterRule.
-func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterRule(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterRule", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterRule), arg0)
-}
-
-// ModifyTrafficMirrorFilterRuleRequest mocks base method.
-func (m *MockEC2API) ModifyTrafficMirrorFilterRuleRequest(arg0 *ec2.ModifyTrafficMirrorFilterRuleInput) (*request.Request, *ec2.ModifyTrafficMirrorFilterRuleOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterRuleRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyTrafficMirrorFilterRuleOutput)
-	return ret0, ret1
-}
-
-// ModifyTrafficMirrorFilterRuleRequest indicates an expected call of ModifyTrafficMirrorFilterRuleRequest.
-func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterRuleRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterRuleRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterRuleRequest), arg0)
-}
-
-// ModifyTrafficMirrorFilterRuleWithContext mocks base method.
-func (m *MockEC2API) ModifyTrafficMirrorFilterRuleWithContext(arg0 context.Context, arg1 *ec2.ModifyTrafficMirrorFilterRuleInput, arg2 ...request.Option) (*ec2.ModifyTrafficMirrorFilterRuleOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterRuleWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorFilterRuleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyTrafficMirrorFilterRuleWithContext indicates an expected call of ModifyTrafficMirrorFilterRuleWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterRuleWithContext(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, "ModifyTrafficMirrorFilterRuleWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterRuleWithContext), varargs...)
-}
-
-// ModifyTrafficMirrorSession mocks base method.
-func (m *MockEC2API) ModifyTrafficMirrorSession(arg0 *ec2.ModifyTrafficMirrorSessionInput) (*ec2.ModifyTrafficMirrorSessionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyTrafficMirrorSession", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorSessionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyTrafficMirrorSession indicates an expected call of ModifyTrafficMirrorSession.
-func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorSession(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorSession", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorSession), arg0)
-}
-
-// ModifyTrafficMirrorSessionRequest mocks base method.
-func (m *MockEC2API) ModifyTrafficMirrorSessionRequest(arg0 *ec2.ModifyTrafficMirrorSessionInput) (*request.Request, *ec2.ModifyTrafficMirrorSessionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyTrafficMirrorSessionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyTrafficMirrorSessionOutput)
-	return ret0, ret1
-}
-
-// ModifyTrafficMirrorSessionRequest indicates an expected call of ModifyTrafficMirrorSessionRequest.
-func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorSessionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorSessionRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorSessionRequest), arg0)
-}
-
-// ModifyTrafficMirrorSessionWithContext mocks base method.
-func (m *MockEC2API) ModifyTrafficMirrorSessionWithContext(arg0 context.Context, arg1 *ec2.ModifyTrafficMirrorSessionInput, arg2 ...request.Option) (*ec2.ModifyTrafficMirrorSessionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyTrafficMirrorSessionWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorSessionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyTrafficMirrorSessionWithContext indicates an expected call of ModifyTrafficMirrorSessionWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorSessionWithContext(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, "ModifyTrafficMirrorSessionWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorSessionWithContext), varargs...)
-}
-
-// ModifyTransitGateway mocks base method.
-func (m *MockEC2API) ModifyTransitGateway(arg0 *ec2.ModifyTransitGatewayInput) (*ec2.ModifyTransitGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyTransitGateway", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyTransitGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyTransitGateway indicates an expected call of ModifyTransitGateway.
-func (mr *MockEC2APIMockRecorder) ModifyTransitGateway(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGateway", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGateway), arg0)
-}
-
-// ModifyTransitGatewayPrefixListReference mocks base method.
-func (m *MockEC2API) ModifyTransitGatewayPrefixListReference(arg0 *ec2.ModifyTransitGatewayPrefixListReferenceInput) (*ec2.ModifyTransitGatewayPrefixListReferenceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyTransitGatewayPrefixListReference", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyTransitGatewayPrefixListReferenceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyTransitGatewayPrefixListReference indicates an expected call of ModifyTransitGatewayPrefixListReference.
-func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayPrefixListReference(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayPrefixListReference", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayPrefixListReference), arg0)
-}
-
-// ModifyTransitGatewayPrefixListReferenceRequest mocks base method.
-func (m *MockEC2API) ModifyTransitGatewayPrefixListReferenceRequest(arg0 *ec2.ModifyTransitGatewayPrefixListReferenceInput) (*request.Request, *ec2.ModifyTransitGatewayPrefixListReferenceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyTransitGatewayPrefixListReferenceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyTransitGatewayPrefixListReferenceOutput)
-	return ret0, ret1
-}
-
-// ModifyTransitGatewayPrefixListReferenceRequest indicates an expected call of ModifyTransitGatewayPrefixListReferenceRequest.
-func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayPrefixListReferenceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayPrefixListReferenceRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayPrefixListReferenceRequest), arg0)
-}
-
-// ModifyTransitGatewayPrefixListReferenceWithContext mocks base method.
-func (m *MockEC2API) ModifyTransitGatewayPrefixListReferenceWithContext(arg0 context.Context, arg1 *ec2.ModifyTransitGatewayPrefixListReferenceInput, arg2 ...request.Option) (*ec2.ModifyTransitGatewayPrefixListReferenceOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyTransitGatewayPrefixListReferenceWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyTransitGatewayPrefixListReferenceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyTransitGatewayPrefixListReferenceWithContext indicates an expected call of ModifyTransitGatewayPrefixListReferenceWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayPrefixListReferenceWithContext(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, "ModifyTransitGatewayPrefixListReferenceWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayPrefixListReferenceWithContext), varargs...)
-}
-
-// ModifyTransitGatewayRequest mocks base method.
-func (m *MockEC2API) ModifyTransitGatewayRequest(arg0 *ec2.ModifyTransitGatewayInput) (*request.Request, *ec2.ModifyTransitGatewayOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyTransitGatewayRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyTransitGatewayOutput)
-	return ret0, ret1
-}
-
-// ModifyTransitGatewayRequest indicates an expected call of ModifyTransitGatewayRequest.
-func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayRequest), arg0)
-}
-
-// ModifyTransitGatewayVpcAttachment mocks base method.
-func (m *MockEC2API) ModifyTransitGatewayVpcAttachment(arg0 *ec2.ModifyTransitGatewayVpcAttachmentInput) (*ec2.ModifyTransitGatewayVpcAttachmentOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyTransitGatewayVpcAttachment", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyTransitGatewayVpcAttachmentOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyTransitGatewayVpcAttachment indicates an expected call of ModifyTransitGatewayVpcAttachment.
-func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayVpcAttachment), arg0)
-}
-
-// ModifyTransitGatewayVpcAttachmentRequest mocks base method.
-func (m *MockEC2API) ModifyTransitGatewayVpcAttachmentRequest(arg0 *ec2.ModifyTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.ModifyTransitGatewayVpcAttachmentOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyTransitGatewayVpcAttachmentRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyTransitGatewayVpcAttachmentOutput)
-	return ret0, ret1
-}
-
-// ModifyTransitGatewayVpcAttachmentRequest indicates an expected call of ModifyTransitGatewayVpcAttachmentRequest.
-func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayVpcAttachmentRequest), arg0)
-}
-
-// ModifyTransitGatewayVpcAttachmentWithContext mocks base method.
-func (m *MockEC2API) ModifyTransitGatewayVpcAttachmentWithContext(arg0 context.Context, arg1 *ec2.ModifyTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.ModifyTransitGatewayVpcAttachmentOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyTransitGatewayVpcAttachmentWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyTransitGatewayVpcAttachmentOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyTransitGatewayVpcAttachmentWithContext indicates an expected call of ModifyTransitGatewayVpcAttachmentWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayVpcAttachmentWithContext(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, "ModifyTransitGatewayVpcAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayVpcAttachmentWithContext), varargs...)
-}
-
-// ModifyTransitGatewayWithContext mocks base method.
-func (m *MockEC2API) ModifyTransitGatewayWithContext(arg0 context.Context, arg1 *ec2.ModifyTransitGatewayInput, arg2 ...request.Option) (*ec2.ModifyTransitGatewayOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyTransitGatewayWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyTransitGatewayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyTransitGatewayWithContext indicates an expected call of ModifyTransitGatewayWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayWithContext(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, "ModifyTransitGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayWithContext), varargs...)
-}
-
-// ModifyVerifiedAccessEndpoint mocks base method.
-func (m *MockEC2API) ModifyVerifiedAccessEndpoint(arg0 *ec2.ModifyVerifiedAccessEndpointInput) (*ec2.ModifyVerifiedAccessEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVerifiedAccessEndpoint", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVerifiedAccessEndpoint indicates an expected call of ModifyVerifiedAccessEndpoint.
-func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessEndpoint(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessEndpoint", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessEndpoint), arg0)
-}
-
-// ModifyVerifiedAccessEndpointPolicy mocks base method.
-func (m *MockEC2API) ModifyVerifiedAccessEndpointPolicy(arg0 *ec2.ModifyVerifiedAccessEndpointPolicyInput) (*ec2.ModifyVerifiedAccessEndpointPolicyOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVerifiedAccessEndpointPolicy", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessEndpointPolicyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVerifiedAccessEndpointPolicy indicates an expected call of ModifyVerifiedAccessEndpointPolicy.
-func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessEndpointPolicy(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessEndpointPolicy", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessEndpointPolicy), arg0)
-}
-
-// ModifyVerifiedAccessEndpointPolicyRequest mocks base method.
-func (m *MockEC2API) ModifyVerifiedAccessEndpointPolicyRequest(arg0 *ec2.ModifyVerifiedAccessEndpointPolicyInput) (*request.Request, *ec2.ModifyVerifiedAccessEndpointPolicyOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVerifiedAccessEndpointPolicyRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyVerifiedAccessEndpointPolicyOutput)
-	return ret0, ret1
-}
-
-// ModifyVerifiedAccessEndpointPolicyRequest indicates an expected call of ModifyVerifiedAccessEndpointPolicyRequest.
-func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessEndpointPolicyRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessEndpointPolicyRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessEndpointPolicyRequest), arg0)
-}
-
-// ModifyVerifiedAccessEndpointPolicyWithContext mocks base method.
-func (m *MockEC2API) ModifyVerifiedAccessEndpointPolicyWithContext(arg0 context.Context, arg1 *ec2.ModifyVerifiedAccessEndpointPolicyInput, arg2 ...request.Option) (*ec2.ModifyVerifiedAccessEndpointPolicyOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyVerifiedAccessEndpointPolicyWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessEndpointPolicyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVerifiedAccessEndpointPolicyWithContext indicates an expected call of ModifyVerifiedAccessEndpointPolicyWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessEndpointPolicyWithContext(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, "ModifyVerifiedAccessEndpointPolicyWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessEndpointPolicyWithContext), varargs...)
-}
-
-// ModifyVerifiedAccessEndpointRequest mocks base method.
-func (m *MockEC2API) ModifyVerifiedAccessEndpointRequest(arg0 *ec2.ModifyVerifiedAccessEndpointInput) (*request.Request, *ec2.ModifyVerifiedAccessEndpointOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVerifiedAccessEndpointRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyVerifiedAccessEndpointOutput)
-	return ret0, ret1
-}
-
-// ModifyVerifiedAccessEndpointRequest indicates an expected call of ModifyVerifiedAccessEndpointRequest.
-func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessEndpointRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessEndpointRequest), arg0)
-}
-
-// ModifyVerifiedAccessEndpointWithContext mocks base method.
-func (m *MockEC2API) ModifyVerifiedAccessEndpointWithContext(arg0 context.Context, arg1 *ec2.ModifyVerifiedAccessEndpointInput, arg2 ...request.Option) (*ec2.ModifyVerifiedAccessEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyVerifiedAccessEndpointWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVerifiedAccessEndpointWithContext indicates an expected call of ModifyVerifiedAccessEndpointWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessEndpointWithContext(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, "ModifyVerifiedAccessEndpointWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessEndpointWithContext), varargs...)
-}
-
-// ModifyVerifiedAccessGroup mocks base method.
-func (m *MockEC2API) ModifyVerifiedAccessGroup(arg0 *ec2.ModifyVerifiedAccessGroupInput) (*ec2.ModifyVerifiedAccessGroupOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVerifiedAccessGroup", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVerifiedAccessGroup indicates an expected call of ModifyVerifiedAccessGroup.
-func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessGroup(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessGroup", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessGroup), arg0)
-}
-
-// ModifyVerifiedAccessGroupPolicy mocks base method.
-func (m *MockEC2API) ModifyVerifiedAccessGroupPolicy(arg0 *ec2.ModifyVerifiedAccessGroupPolicyInput) (*ec2.ModifyVerifiedAccessGroupPolicyOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVerifiedAccessGroupPolicy", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessGroupPolicyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVerifiedAccessGroupPolicy indicates an expected call of ModifyVerifiedAccessGroupPolicy.
-func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessGroupPolicy(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessGroupPolicy", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessGroupPolicy), arg0)
-}
-
-// ModifyVerifiedAccessGroupPolicyRequest mocks base method.
-func (m *MockEC2API) ModifyVerifiedAccessGroupPolicyRequest(arg0 *ec2.ModifyVerifiedAccessGroupPolicyInput) (*request.Request, *ec2.ModifyVerifiedAccessGroupPolicyOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVerifiedAccessGroupPolicyRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyVerifiedAccessGroupPolicyOutput)
-	return ret0, ret1
-}
-
-// ModifyVerifiedAccessGroupPolicyRequest indicates an expected call of ModifyVerifiedAccessGroupPolicyRequest.
-func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessGroupPolicyRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessGroupPolicyRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessGroupPolicyRequest), arg0)
-}
-
-// ModifyVerifiedAccessGroupPolicyWithContext mocks base method.
-func (m *MockEC2API) ModifyVerifiedAccessGroupPolicyWithContext(arg0 context.Context, arg1 *ec2.ModifyVerifiedAccessGroupPolicyInput, arg2 ...request.Option) (*ec2.ModifyVerifiedAccessGroupPolicyOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyVerifiedAccessGroupPolicyWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessGroupPolicyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVerifiedAccessGroupPolicyWithContext indicates an expected call of ModifyVerifiedAccessGroupPolicyWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessGroupPolicyWithContext(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, "ModifyVerifiedAccessGroupPolicyWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessGroupPolicyWithContext), varargs...)
-}
-
-// ModifyVerifiedAccessGroupRequest mocks base method.
-func (m *MockEC2API) ModifyVerifiedAccessGroupRequest(arg0 *ec2.ModifyVerifiedAccessGroupInput) (*request.Request, *ec2.ModifyVerifiedAccessGroupOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVerifiedAccessGroupRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyVerifiedAccessGroupOutput)
-	return ret0, ret1
-}
-
-// ModifyVerifiedAccessGroupRequest indicates an expected call of ModifyVerifiedAccessGroupRequest.
-func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessGroupRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessGroupRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessGroupRequest), arg0)
-}
-
-// ModifyVerifiedAccessGroupWithContext mocks base method.
-func (m *MockEC2API) ModifyVerifiedAccessGroupWithContext(arg0 context.Context, arg1 *ec2.ModifyVerifiedAccessGroupInput, arg2 ...request.Option) (*ec2.ModifyVerifiedAccessGroupOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyVerifiedAccessGroupWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessGroupOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVerifiedAccessGroupWithContext indicates an expected call of ModifyVerifiedAccessGroupWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessGroupWithContext(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, "ModifyVerifiedAccessGroupWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessGroupWithContext), varargs...)
-}
-
-// ModifyVerifiedAccessInstance mocks base method.
-func (m *MockEC2API) ModifyVerifiedAccessInstance(arg0 *ec2.ModifyVerifiedAccessInstanceInput) (*ec2.ModifyVerifiedAccessInstanceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVerifiedAccessInstance", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessInstanceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVerifiedAccessInstance indicates an expected call of ModifyVerifiedAccessInstance.
-func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessInstance(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessInstance", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessInstance), arg0)
-}
-
-// ModifyVerifiedAccessInstanceLoggingConfiguration mocks base method.
-func (m *MockEC2API) ModifyVerifiedAccessInstanceLoggingConfiguration(arg0 *ec2.ModifyVerifiedAccessInstanceLoggingConfigurationInput) (*ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVerifiedAccessInstanceLoggingConfiguration", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVerifiedAccessInstanceLoggingConfiguration indicates an expected call of ModifyVerifiedAccessInstanceLoggingConfiguration.
-func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessInstanceLoggingConfiguration(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessInstanceLoggingConfiguration", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessInstanceLoggingConfiguration), arg0)
-}
-
-// ModifyVerifiedAccessInstanceLoggingConfigurationRequest mocks base method.
-func (m *MockEC2API) ModifyVerifiedAccessInstanceLoggingConfigurationRequest(arg0 *ec2.ModifyVerifiedAccessInstanceLoggingConfigurationInput) (*request.Request, *ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVerifiedAccessInstanceLoggingConfigurationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput)
-	return ret0, ret1
-}
-
-// ModifyVerifiedAccessInstanceLoggingConfigurationRequest indicates an expected call of ModifyVerifiedAccessInstanceLoggingConfigurationRequest.
-func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessInstanceLoggingConfigurationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessInstanceLoggingConfigurationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessInstanceLoggingConfigurationRequest), arg0)
-}
-
-// ModifyVerifiedAccessInstanceLoggingConfigurationWithContext mocks base method.
-func (m *MockEC2API) ModifyVerifiedAccessInstanceLoggingConfigurationWithContext(arg0 context.Context, arg1 *ec2.ModifyVerifiedAccessInstanceLoggingConfigurationInput, arg2 ...request.Option) (*ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyVerifiedAccessInstanceLoggingConfigurationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVerifiedAccessInstanceLoggingConfigurationWithContext indicates an expected call of ModifyVerifiedAccessInstanceLoggingConfigurationWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessInstanceLoggingConfigurationWithContext(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, "ModifyVerifiedAccessInstanceLoggingConfigurationWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessInstanceLoggingConfigurationWithContext), varargs...)
-}
-
-// ModifyVerifiedAccessInstanceRequest mocks base method.
-func (m *MockEC2API) ModifyVerifiedAccessInstanceRequest(arg0 *ec2.ModifyVerifiedAccessInstanceInput) (*request.Request, *ec2.ModifyVerifiedAccessInstanceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVerifiedAccessInstanceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyVerifiedAccessInstanceOutput)
-	return ret0, ret1
-}
-
-// ModifyVerifiedAccessInstanceRequest indicates an expected call of ModifyVerifiedAccessInstanceRequest.
-func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessInstanceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessInstanceRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessInstanceRequest), arg0)
-}
-
-// ModifyVerifiedAccessInstanceWithContext mocks base method.
-func (m *MockEC2API) ModifyVerifiedAccessInstanceWithContext(arg0 context.Context, arg1 *ec2.ModifyVerifiedAccessInstanceInput, arg2 ...request.Option) (*ec2.ModifyVerifiedAccessInstanceOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyVerifiedAccessInstanceWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessInstanceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVerifiedAccessInstanceWithContext indicates an expected call of ModifyVerifiedAccessInstanceWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessInstanceWithContext(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, "ModifyVerifiedAccessInstanceWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessInstanceWithContext), varargs...)
-}
-
-// ModifyVerifiedAccessTrustProvider mocks base method.
-func (m *MockEC2API) ModifyVerifiedAccessTrustProvider(arg0 *ec2.ModifyVerifiedAccessTrustProviderInput) (*ec2.ModifyVerifiedAccessTrustProviderOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVerifiedAccessTrustProvider", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessTrustProviderOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVerifiedAccessTrustProvider indicates an expected call of ModifyVerifiedAccessTrustProvider.
-func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessTrustProvider(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessTrustProvider", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessTrustProvider), arg0)
-}
-
-// ModifyVerifiedAccessTrustProviderRequest mocks base method.
-func (m *MockEC2API) ModifyVerifiedAccessTrustProviderRequest(arg0 *ec2.ModifyVerifiedAccessTrustProviderInput) (*request.Request, *ec2.ModifyVerifiedAccessTrustProviderOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVerifiedAccessTrustProviderRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyVerifiedAccessTrustProviderOutput)
-	return ret0, ret1
-}
-
-// ModifyVerifiedAccessTrustProviderRequest indicates an expected call of ModifyVerifiedAccessTrustProviderRequest.
-func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessTrustProviderRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessTrustProviderRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessTrustProviderRequest), arg0)
-}
-
-// ModifyVerifiedAccessTrustProviderWithContext mocks base method.
-func (m *MockEC2API) ModifyVerifiedAccessTrustProviderWithContext(arg0 context.Context, arg1 *ec2.ModifyVerifiedAccessTrustProviderInput, arg2 ...request.Option) (*ec2.ModifyVerifiedAccessTrustProviderOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyVerifiedAccessTrustProviderWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessTrustProviderOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVerifiedAccessTrustProviderWithContext indicates an expected call of ModifyVerifiedAccessTrustProviderWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessTrustProviderWithContext(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, "ModifyVerifiedAccessTrustProviderWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessTrustProviderWithContext), varargs...)
-}
-
-// ModifyVolume mocks base method.
-func (m *MockEC2API) ModifyVolume(arg0 *ec2.ModifyVolumeInput) (*ec2.ModifyVolumeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVolume", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyVolumeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVolume indicates an expected call of ModifyVolume.
-func (mr *MockEC2APIMockRecorder) ModifyVolume(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolume", reflect.TypeOf((*MockEC2API)(nil).ModifyVolume), arg0)
-}
-
-// ModifyVolumeAttribute mocks base method.
-func (m *MockEC2API) ModifyVolumeAttribute(arg0 *ec2.ModifyVolumeAttributeInput) (*ec2.ModifyVolumeAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVolumeAttribute", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyVolumeAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVolumeAttribute indicates an expected call of ModifyVolumeAttribute.
-func (mr *MockEC2APIMockRecorder) ModifyVolumeAttribute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolumeAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyVolumeAttribute), arg0)
-}
-
-// ModifyVolumeAttributeRequest mocks base method.
-func (m *MockEC2API) ModifyVolumeAttributeRequest(arg0 *ec2.ModifyVolumeAttributeInput) (*request.Request, *ec2.ModifyVolumeAttributeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVolumeAttributeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyVolumeAttributeOutput)
-	return ret0, ret1
-}
-
-// ModifyVolumeAttributeRequest indicates an expected call of ModifyVolumeAttributeRequest.
-func (mr *MockEC2APIMockRecorder) ModifyVolumeAttributeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolumeAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVolumeAttributeRequest), arg0)
-}
-
-// ModifyVolumeAttributeWithContext mocks base method.
-func (m *MockEC2API) ModifyVolumeAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyVolumeAttributeInput, arg2 ...request.Option) (*ec2.ModifyVolumeAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyVolumeAttributeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyVolumeAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVolumeAttributeWithContext indicates an expected call of ModifyVolumeAttributeWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyVolumeAttributeWithContext(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, "ModifyVolumeAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVolumeAttributeWithContext), varargs...)
-}
-
-// ModifyVolumeRequest mocks base method.
-func (m *MockEC2API) ModifyVolumeRequest(arg0 *ec2.ModifyVolumeInput) (*request.Request, *ec2.ModifyVolumeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVolumeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyVolumeOutput)
-	return ret0, ret1
-}
-
-// ModifyVolumeRequest indicates an expected call of ModifyVolumeRequest.
-func (mr *MockEC2APIMockRecorder) ModifyVolumeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVolumeRequest), arg0)
-}
-
-// ModifyVolumeWithContext mocks base method.
-func (m *MockEC2API) ModifyVolumeWithContext(arg0 context.Context, arg1 *ec2.ModifyVolumeInput, arg2 ...request.Option) (*ec2.ModifyVolumeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyVolumeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyVolumeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVolumeWithContext indicates an expected call of ModifyVolumeWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyVolumeWithContext(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, "ModifyVolumeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVolumeWithContext), varargs...)
-}
-
-// ModifyVpcAttribute mocks base method.
-func (m *MockEC2API) ModifyVpcAttribute(arg0 *ec2.ModifyVpcAttributeInput) (*ec2.ModifyVpcAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpcAttribute", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyVpcAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpcAttribute indicates an expected call of ModifyVpcAttribute.
-func (mr *MockEC2APIMockRecorder) ModifyVpcAttribute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcAttribute), arg0)
-}
-
-// ModifyVpcAttributeRequest mocks base method.
-func (m *MockEC2API) ModifyVpcAttributeRequest(arg0 *ec2.ModifyVpcAttributeInput) (*request.Request, *ec2.ModifyVpcAttributeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpcAttributeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyVpcAttributeOutput)
-	return ret0, ret1
-}
-
-// ModifyVpcAttributeRequest indicates an expected call of ModifyVpcAttributeRequest.
-func (mr *MockEC2APIMockRecorder) ModifyVpcAttributeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcAttributeRequest), arg0)
-}
-
-// ModifyVpcAttributeWithContext mocks base method.
-func (m *MockEC2API) ModifyVpcAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcAttributeInput, arg2 ...request.Option) (*ec2.ModifyVpcAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyVpcAttributeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyVpcAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpcAttributeWithContext indicates an expected call of ModifyVpcAttributeWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyVpcAttributeWithContext(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, "ModifyVpcAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcAttributeWithContext), varargs...)
-}
-
-// ModifyVpcEndpoint mocks base method.
-func (m *MockEC2API) ModifyVpcEndpoint(arg0 *ec2.ModifyVpcEndpointInput) (*ec2.ModifyVpcEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpcEndpoint", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyVpcEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpcEndpoint indicates an expected call of ModifyVpcEndpoint.
-func (mr *MockEC2APIMockRecorder) ModifyVpcEndpoint(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpoint", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpoint), arg0)
-}
-
-// ModifyVpcEndpointConnectionNotification mocks base method.
-func (m *MockEC2API) ModifyVpcEndpointConnectionNotification(arg0 *ec2.ModifyVpcEndpointConnectionNotificationInput) (*ec2.ModifyVpcEndpointConnectionNotificationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpcEndpointConnectionNotification", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyVpcEndpointConnectionNotificationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpcEndpointConnectionNotification indicates an expected call of ModifyVpcEndpointConnectionNotification.
-func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointConnectionNotification(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointConnectionNotification", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointConnectionNotification), arg0)
-}
-
-// ModifyVpcEndpointConnectionNotificationRequest mocks base method.
-func (m *MockEC2API) ModifyVpcEndpointConnectionNotificationRequest(arg0 *ec2.ModifyVpcEndpointConnectionNotificationInput) (*request.Request, *ec2.ModifyVpcEndpointConnectionNotificationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpcEndpointConnectionNotificationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyVpcEndpointConnectionNotificationOutput)
-	return ret0, ret1
-}
-
-// ModifyVpcEndpointConnectionNotificationRequest indicates an expected call of ModifyVpcEndpointConnectionNotificationRequest.
-func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointConnectionNotificationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointConnectionNotificationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointConnectionNotificationRequest), arg0)
-}
-
-// ModifyVpcEndpointConnectionNotificationWithContext mocks base method.
-func (m *MockEC2API) ModifyVpcEndpointConnectionNotificationWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcEndpointConnectionNotificationInput, arg2 ...request.Option) (*ec2.ModifyVpcEndpointConnectionNotificationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyVpcEndpointConnectionNotificationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyVpcEndpointConnectionNotificationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpcEndpointConnectionNotificationWithContext indicates an expected call of ModifyVpcEndpointConnectionNotificationWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointConnectionNotificationWithContext(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, "ModifyVpcEndpointConnectionNotificationWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointConnectionNotificationWithContext), varargs...)
-}
-
-// ModifyVpcEndpointRequest mocks base method.
-func (m *MockEC2API) ModifyVpcEndpointRequest(arg0 *ec2.ModifyVpcEndpointInput) (*request.Request, *ec2.ModifyVpcEndpointOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpcEndpointRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyVpcEndpointOutput)
-	return ret0, ret1
-}
-
-// ModifyVpcEndpointRequest indicates an expected call of ModifyVpcEndpointRequest.
-func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointRequest), arg0)
-}
-
-// ModifyVpcEndpointServiceConfiguration mocks base method.
-func (m *MockEC2API) ModifyVpcEndpointServiceConfiguration(arg0 *ec2.ModifyVpcEndpointServiceConfigurationInput) (*ec2.ModifyVpcEndpointServiceConfigurationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpcEndpointServiceConfiguration", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServiceConfigurationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpcEndpointServiceConfiguration indicates an expected call of ModifyVpcEndpointServiceConfiguration.
-func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServiceConfiguration(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServiceConfiguration", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServiceConfiguration), arg0)
-}
-
-// ModifyVpcEndpointServiceConfigurationRequest mocks base method.
-func (m *MockEC2API) ModifyVpcEndpointServiceConfigurationRequest(arg0 *ec2.ModifyVpcEndpointServiceConfigurationInput) (*request.Request, *ec2.ModifyVpcEndpointServiceConfigurationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpcEndpointServiceConfigurationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyVpcEndpointServiceConfigurationOutput)
-	return ret0, ret1
-}
-
-// ModifyVpcEndpointServiceConfigurationRequest indicates an expected call of ModifyVpcEndpointServiceConfigurationRequest.
-func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServiceConfigurationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServiceConfigurationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServiceConfigurationRequest), arg0)
-}
-
-// ModifyVpcEndpointServiceConfigurationWithContext mocks base method.
-func (m *MockEC2API) ModifyVpcEndpointServiceConfigurationWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcEndpointServiceConfigurationInput, arg2 ...request.Option) (*ec2.ModifyVpcEndpointServiceConfigurationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyVpcEndpointServiceConfigurationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServiceConfigurationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpcEndpointServiceConfigurationWithContext indicates an expected call of ModifyVpcEndpointServiceConfigurationWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServiceConfigurationWithContext(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, "ModifyVpcEndpointServiceConfigurationWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServiceConfigurationWithContext), varargs...)
-}
-
-// ModifyVpcEndpointServicePayerResponsibility mocks base method.
-func (m *MockEC2API) ModifyVpcEndpointServicePayerResponsibility(arg0 *ec2.ModifyVpcEndpointServicePayerResponsibilityInput) (*ec2.ModifyVpcEndpointServicePayerResponsibilityOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePayerResponsibility", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServicePayerResponsibilityOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpcEndpointServicePayerResponsibility indicates an expected call of ModifyVpcEndpointServicePayerResponsibility.
-func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServicePayerResponsibility(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServicePayerResponsibility", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServicePayerResponsibility), arg0)
-}
-
-// ModifyVpcEndpointServicePayerResponsibilityRequest mocks base method.
-func (m *MockEC2API) ModifyVpcEndpointServicePayerResponsibilityRequest(arg0 *ec2.ModifyVpcEndpointServicePayerResponsibilityInput) (*request.Request, *ec2.ModifyVpcEndpointServicePayerResponsibilityOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePayerResponsibilityRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyVpcEndpointServicePayerResponsibilityOutput)
-	return ret0, ret1
-}
-
-// ModifyVpcEndpointServicePayerResponsibilityRequest indicates an expected call of ModifyVpcEndpointServicePayerResponsibilityRequest.
-func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServicePayerResponsibilityRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServicePayerResponsibilityRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServicePayerResponsibilityRequest), arg0)
-}
-
-// ModifyVpcEndpointServicePayerResponsibilityWithContext mocks base method.
-func (m *MockEC2API) ModifyVpcEndpointServicePayerResponsibilityWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcEndpointServicePayerResponsibilityInput, arg2 ...request.Option) (*ec2.ModifyVpcEndpointServicePayerResponsibilityOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePayerResponsibilityWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServicePayerResponsibilityOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpcEndpointServicePayerResponsibilityWithContext indicates an expected call of ModifyVpcEndpointServicePayerResponsibilityWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServicePayerResponsibilityWithContext(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, "ModifyVpcEndpointServicePayerResponsibilityWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServicePayerResponsibilityWithContext), varargs...)
-}
-
-// ModifyVpcEndpointServicePermissions mocks base method.
-func (m *MockEC2API) ModifyVpcEndpointServicePermissions(arg0 *ec2.ModifyVpcEndpointServicePermissionsInput) (*ec2.ModifyVpcEndpointServicePermissionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePermissions", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServicePermissionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpcEndpointServicePermissions indicates an expected call of ModifyVpcEndpointServicePermissions.
-func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServicePermissions(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServicePermissions", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServicePermissions), arg0)
-}
-
-// ModifyVpcEndpointServicePermissionsRequest mocks base method.
-func (m *MockEC2API) ModifyVpcEndpointServicePermissionsRequest(arg0 *ec2.ModifyVpcEndpointServicePermissionsInput) (*request.Request, *ec2.ModifyVpcEndpointServicePermissionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePermissionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyVpcEndpointServicePermissionsOutput)
-	return ret0, ret1
-}
-
-// ModifyVpcEndpointServicePermissionsRequest indicates an expected call of ModifyVpcEndpointServicePermissionsRequest.
-func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServicePermissionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServicePermissionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServicePermissionsRequest), arg0)
-}
-
-// ModifyVpcEndpointServicePermissionsWithContext mocks base method.
-func (m *MockEC2API) ModifyVpcEndpointServicePermissionsWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcEndpointServicePermissionsInput, arg2 ...request.Option) (*ec2.ModifyVpcEndpointServicePermissionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePermissionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServicePermissionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpcEndpointServicePermissionsWithContext indicates an expected call of ModifyVpcEndpointServicePermissionsWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServicePermissionsWithContext(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, "ModifyVpcEndpointServicePermissionsWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServicePermissionsWithContext), varargs...)
-}
-
-// ModifyVpcEndpointWithContext mocks base method.
-func (m *MockEC2API) ModifyVpcEndpointWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcEndpointInput, arg2 ...request.Option) (*ec2.ModifyVpcEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyVpcEndpointWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyVpcEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpcEndpointWithContext indicates an expected call of ModifyVpcEndpointWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointWithContext(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, "ModifyVpcEndpointWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointWithContext), varargs...)
-}
-
-// ModifyVpcPeeringConnectionOptions mocks base method.
-func (m *MockEC2API) ModifyVpcPeeringConnectionOptions(arg0 *ec2.ModifyVpcPeeringConnectionOptionsInput) (*ec2.ModifyVpcPeeringConnectionOptionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpcPeeringConnectionOptions", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyVpcPeeringConnectionOptionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpcPeeringConnectionOptions indicates an expected call of ModifyVpcPeeringConnectionOptions.
-func (mr *MockEC2APIMockRecorder) ModifyVpcPeeringConnectionOptions(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcPeeringConnectionOptions", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcPeeringConnectionOptions), arg0)
-}
-
-// ModifyVpcPeeringConnectionOptionsRequest mocks base method.
-func (m *MockEC2API) ModifyVpcPeeringConnectionOptionsRequest(arg0 *ec2.ModifyVpcPeeringConnectionOptionsInput) (*request.Request, *ec2.ModifyVpcPeeringConnectionOptionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpcPeeringConnectionOptionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyVpcPeeringConnectionOptionsOutput)
-	return ret0, ret1
-}
-
-// ModifyVpcPeeringConnectionOptionsRequest indicates an expected call of ModifyVpcPeeringConnectionOptionsRequest.
-func (mr *MockEC2APIMockRecorder) ModifyVpcPeeringConnectionOptionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcPeeringConnectionOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcPeeringConnectionOptionsRequest), arg0)
-}
-
-// ModifyVpcPeeringConnectionOptionsWithContext mocks base method.
-func (m *MockEC2API) ModifyVpcPeeringConnectionOptionsWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcPeeringConnectionOptionsInput, arg2 ...request.Option) (*ec2.ModifyVpcPeeringConnectionOptionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyVpcPeeringConnectionOptionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyVpcPeeringConnectionOptionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpcPeeringConnectionOptionsWithContext indicates an expected call of ModifyVpcPeeringConnectionOptionsWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyVpcPeeringConnectionOptionsWithContext(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, "ModifyVpcPeeringConnectionOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcPeeringConnectionOptionsWithContext), varargs...)
-}
-
-// ModifyVpcTenancy mocks base method.
-func (m *MockEC2API) ModifyVpcTenancy(arg0 *ec2.ModifyVpcTenancyInput) (*ec2.ModifyVpcTenancyOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpcTenancy", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyVpcTenancyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpcTenancy indicates an expected call of ModifyVpcTenancy.
-func (mr *MockEC2APIMockRecorder) ModifyVpcTenancy(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcTenancy", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcTenancy), arg0)
-}
-
-// ModifyVpcTenancyRequest mocks base method.
-func (m *MockEC2API) ModifyVpcTenancyRequest(arg0 *ec2.ModifyVpcTenancyInput) (*request.Request, *ec2.ModifyVpcTenancyOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpcTenancyRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyVpcTenancyOutput)
-	return ret0, ret1
-}
-
-// ModifyVpcTenancyRequest indicates an expected call of ModifyVpcTenancyRequest.
-func (mr *MockEC2APIMockRecorder) ModifyVpcTenancyRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcTenancyRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcTenancyRequest), arg0)
-}
-
-// ModifyVpcTenancyWithContext mocks base method.
-func (m *MockEC2API) ModifyVpcTenancyWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcTenancyInput, arg2 ...request.Option) (*ec2.ModifyVpcTenancyOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyVpcTenancyWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyVpcTenancyOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpcTenancyWithContext indicates an expected call of ModifyVpcTenancyWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyVpcTenancyWithContext(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, "ModifyVpcTenancyWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcTenancyWithContext), varargs...)
-}
-
-// ModifyVpnConnection mocks base method.
-func (m *MockEC2API) ModifyVpnConnection(arg0 *ec2.ModifyVpnConnectionInput) (*ec2.ModifyVpnConnectionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpnConnection", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyVpnConnectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpnConnection indicates an expected call of ModifyVpnConnection.
-func (mr *MockEC2APIMockRecorder) ModifyVpnConnection(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnConnection", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnConnection), arg0)
-}
-
-// ModifyVpnConnectionOptions mocks base method.
-func (m *MockEC2API) ModifyVpnConnectionOptions(arg0 *ec2.ModifyVpnConnectionOptionsInput) (*ec2.ModifyVpnConnectionOptionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpnConnectionOptions", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyVpnConnectionOptionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpnConnectionOptions indicates an expected call of ModifyVpnConnectionOptions.
-func (mr *MockEC2APIMockRecorder) ModifyVpnConnectionOptions(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnConnectionOptions", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnConnectionOptions), arg0)
-}
-
-// ModifyVpnConnectionOptionsRequest mocks base method.
-func (m *MockEC2API) ModifyVpnConnectionOptionsRequest(arg0 *ec2.ModifyVpnConnectionOptionsInput) (*request.Request, *ec2.ModifyVpnConnectionOptionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpnConnectionOptionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyVpnConnectionOptionsOutput)
-	return ret0, ret1
-}
-
-// ModifyVpnConnectionOptionsRequest indicates an expected call of ModifyVpnConnectionOptionsRequest.
-func (mr *MockEC2APIMockRecorder) ModifyVpnConnectionOptionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnConnectionOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnConnectionOptionsRequest), arg0)
-}
-
-// ModifyVpnConnectionOptionsWithContext mocks base method.
-func (m *MockEC2API) ModifyVpnConnectionOptionsWithContext(arg0 context.Context, arg1 *ec2.ModifyVpnConnectionOptionsInput, arg2 ...request.Option) (*ec2.ModifyVpnConnectionOptionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyVpnConnectionOptionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyVpnConnectionOptionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpnConnectionOptionsWithContext indicates an expected call of ModifyVpnConnectionOptionsWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyVpnConnectionOptionsWithContext(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, "ModifyVpnConnectionOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnConnectionOptionsWithContext), varargs...)
-}
-
-// ModifyVpnConnectionRequest mocks base method.
-func (m *MockEC2API) ModifyVpnConnectionRequest(arg0 *ec2.ModifyVpnConnectionInput) (*request.Request, *ec2.ModifyVpnConnectionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpnConnectionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyVpnConnectionOutput)
-	return ret0, ret1
-}
-
-// ModifyVpnConnectionRequest indicates an expected call of ModifyVpnConnectionRequest.
-func (mr *MockEC2APIMockRecorder) ModifyVpnConnectionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnConnectionRequest), arg0)
-}
-
-// ModifyVpnConnectionWithContext mocks base method.
-func (m *MockEC2API) ModifyVpnConnectionWithContext(arg0 context.Context, arg1 *ec2.ModifyVpnConnectionInput, arg2 ...request.Option) (*ec2.ModifyVpnConnectionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyVpnConnectionWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyVpnConnectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpnConnectionWithContext indicates an expected call of ModifyVpnConnectionWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyVpnConnectionWithContext(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, "ModifyVpnConnectionWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnConnectionWithContext), varargs...)
-}
-
-// ModifyVpnTunnelCertificate mocks base method.
-func (m *MockEC2API) ModifyVpnTunnelCertificate(arg0 *ec2.ModifyVpnTunnelCertificateInput) (*ec2.ModifyVpnTunnelCertificateOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpnTunnelCertificate", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyVpnTunnelCertificateOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpnTunnelCertificate indicates an expected call of ModifyVpnTunnelCertificate.
-func (mr *MockEC2APIMockRecorder) ModifyVpnTunnelCertificate(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelCertificate", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelCertificate), arg0)
-}
-
-// ModifyVpnTunnelCertificateRequest mocks base method.
-func (m *MockEC2API) ModifyVpnTunnelCertificateRequest(arg0 *ec2.ModifyVpnTunnelCertificateInput) (*request.Request, *ec2.ModifyVpnTunnelCertificateOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpnTunnelCertificateRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyVpnTunnelCertificateOutput)
-	return ret0, ret1
-}
-
-// ModifyVpnTunnelCertificateRequest indicates an expected call of ModifyVpnTunnelCertificateRequest.
-func (mr *MockEC2APIMockRecorder) ModifyVpnTunnelCertificateRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelCertificateRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelCertificateRequest), arg0)
-}
-
-// ModifyVpnTunnelCertificateWithContext mocks base method.
-func (m *MockEC2API) ModifyVpnTunnelCertificateWithContext(arg0 context.Context, arg1 *ec2.ModifyVpnTunnelCertificateInput, arg2 ...request.Option) (*ec2.ModifyVpnTunnelCertificateOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyVpnTunnelCertificateWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyVpnTunnelCertificateOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpnTunnelCertificateWithContext indicates an expected call of ModifyVpnTunnelCertificateWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyVpnTunnelCertificateWithContext(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, "ModifyVpnTunnelCertificateWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelCertificateWithContext), varargs...)
-}
-
-// ModifyVpnTunnelOptions mocks base method.
-func (m *MockEC2API) ModifyVpnTunnelOptions(arg0 *ec2.ModifyVpnTunnelOptionsInput) (*ec2.ModifyVpnTunnelOptionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpnTunnelOptions", arg0)
-	ret0, _ := ret[0].(*ec2.ModifyVpnTunnelOptionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpnTunnelOptions indicates an expected call of ModifyVpnTunnelOptions.
-func (mr *MockEC2APIMockRecorder) ModifyVpnTunnelOptions(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelOptions", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelOptions), arg0)
-}
-
-// ModifyVpnTunnelOptionsRequest mocks base method.
-func (m *MockEC2API) ModifyVpnTunnelOptionsRequest(arg0 *ec2.ModifyVpnTunnelOptionsInput) (*request.Request, *ec2.ModifyVpnTunnelOptionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ModifyVpnTunnelOptionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ModifyVpnTunnelOptionsOutput)
-	return ret0, ret1
-}
-
-// ModifyVpnTunnelOptionsRequest indicates an expected call of ModifyVpnTunnelOptionsRequest.
-func (mr *MockEC2APIMockRecorder) ModifyVpnTunnelOptionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelOptionsRequest), arg0)
-}
-
-// ModifyVpnTunnelOptionsWithContext mocks base method.
-func (m *MockEC2API) ModifyVpnTunnelOptionsWithContext(arg0 context.Context, arg1 *ec2.ModifyVpnTunnelOptionsInput, arg2 ...request.Option) (*ec2.ModifyVpnTunnelOptionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ModifyVpnTunnelOptionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ModifyVpnTunnelOptionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ModifyVpnTunnelOptionsWithContext indicates an expected call of ModifyVpnTunnelOptionsWithContext.
-func (mr *MockEC2APIMockRecorder) ModifyVpnTunnelOptionsWithContext(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, "ModifyVpnTunnelOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelOptionsWithContext), varargs...)
-}
-
-// MonitorInstances mocks base method.
-func (m *MockEC2API) MonitorInstances(arg0 *ec2.MonitorInstancesInput) (*ec2.MonitorInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "MonitorInstances", arg0)
-	ret0, _ := ret[0].(*ec2.MonitorInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// MonitorInstances indicates an expected call of MonitorInstances.
-func (mr *MockEC2APIMockRecorder) MonitorInstances(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MonitorInstances", reflect.TypeOf((*MockEC2API)(nil).MonitorInstances), arg0)
-}
-
-// MonitorInstancesRequest mocks base method.
-func (m *MockEC2API) MonitorInstancesRequest(arg0 *ec2.MonitorInstancesInput) (*request.Request, *ec2.MonitorInstancesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "MonitorInstancesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.MonitorInstancesOutput)
-	return ret0, ret1
-}
-
-// MonitorInstancesRequest indicates an expected call of MonitorInstancesRequest.
-func (mr *MockEC2APIMockRecorder) MonitorInstancesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MonitorInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).MonitorInstancesRequest), arg0)
-}
-
-// MonitorInstancesWithContext mocks base method.
-func (m *MockEC2API) MonitorInstancesWithContext(arg0 context.Context, arg1 *ec2.MonitorInstancesInput, arg2 ...request.Option) (*ec2.MonitorInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "MonitorInstancesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.MonitorInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// MonitorInstancesWithContext indicates an expected call of MonitorInstancesWithContext.
-func (mr *MockEC2APIMockRecorder) MonitorInstancesWithContext(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, "MonitorInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).MonitorInstancesWithContext), varargs...)
-}
-
-// MoveAddressToVpc mocks base method.
-func (m *MockEC2API) MoveAddressToVpc(arg0 *ec2.MoveAddressToVpcInput) (*ec2.MoveAddressToVpcOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "MoveAddressToVpc", arg0)
-	ret0, _ := ret[0].(*ec2.MoveAddressToVpcOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// MoveAddressToVpc indicates an expected call of MoveAddressToVpc.
-func (mr *MockEC2APIMockRecorder) MoveAddressToVpc(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveAddressToVpc", reflect.TypeOf((*MockEC2API)(nil).MoveAddressToVpc), arg0)
-}
-
-// MoveAddressToVpcRequest mocks base method.
-func (m *MockEC2API) MoveAddressToVpcRequest(arg0 *ec2.MoveAddressToVpcInput) (*request.Request, *ec2.MoveAddressToVpcOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "MoveAddressToVpcRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.MoveAddressToVpcOutput)
-	return ret0, ret1
-}
-
-// MoveAddressToVpcRequest indicates an expected call of MoveAddressToVpcRequest.
-func (mr *MockEC2APIMockRecorder) MoveAddressToVpcRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveAddressToVpcRequest", reflect.TypeOf((*MockEC2API)(nil).MoveAddressToVpcRequest), arg0)
-}
-
-// MoveAddressToVpcWithContext mocks base method.
-func (m *MockEC2API) MoveAddressToVpcWithContext(arg0 context.Context, arg1 *ec2.MoveAddressToVpcInput, arg2 ...request.Option) (*ec2.MoveAddressToVpcOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "MoveAddressToVpcWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.MoveAddressToVpcOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// MoveAddressToVpcWithContext indicates an expected call of MoveAddressToVpcWithContext.
-func (mr *MockEC2APIMockRecorder) MoveAddressToVpcWithContext(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, "MoveAddressToVpcWithContext", reflect.TypeOf((*MockEC2API)(nil).MoveAddressToVpcWithContext), varargs...)
-}
-
-// MoveByoipCidrToIpam mocks base method.
-func (m *MockEC2API) MoveByoipCidrToIpam(arg0 *ec2.MoveByoipCidrToIpamInput) (*ec2.MoveByoipCidrToIpamOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "MoveByoipCidrToIpam", arg0)
-	ret0, _ := ret[0].(*ec2.MoveByoipCidrToIpamOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// MoveByoipCidrToIpam indicates an expected call of MoveByoipCidrToIpam.
-func (mr *MockEC2APIMockRecorder) MoveByoipCidrToIpam(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveByoipCidrToIpam", reflect.TypeOf((*MockEC2API)(nil).MoveByoipCidrToIpam), arg0)
-}
-
-// MoveByoipCidrToIpamRequest mocks base method.
-func (m *MockEC2API) MoveByoipCidrToIpamRequest(arg0 *ec2.MoveByoipCidrToIpamInput) (*request.Request, *ec2.MoveByoipCidrToIpamOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "MoveByoipCidrToIpamRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.MoveByoipCidrToIpamOutput)
-	return ret0, ret1
-}
-
-// MoveByoipCidrToIpamRequest indicates an expected call of MoveByoipCidrToIpamRequest.
-func (mr *MockEC2APIMockRecorder) MoveByoipCidrToIpamRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveByoipCidrToIpamRequest", reflect.TypeOf((*MockEC2API)(nil).MoveByoipCidrToIpamRequest), arg0)
-}
-
-// MoveByoipCidrToIpamWithContext mocks base method.
-func (m *MockEC2API) MoveByoipCidrToIpamWithContext(arg0 context.Context, arg1 *ec2.MoveByoipCidrToIpamInput, arg2 ...request.Option) (*ec2.MoveByoipCidrToIpamOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "MoveByoipCidrToIpamWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.MoveByoipCidrToIpamOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// MoveByoipCidrToIpamWithContext indicates an expected call of MoveByoipCidrToIpamWithContext.
-func (mr *MockEC2APIMockRecorder) MoveByoipCidrToIpamWithContext(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, "MoveByoipCidrToIpamWithContext", reflect.TypeOf((*MockEC2API)(nil).MoveByoipCidrToIpamWithContext), varargs...)
-}
-
-// ProvisionByoipCidr mocks base method.
-func (m *MockEC2API) ProvisionByoipCidr(arg0 *ec2.ProvisionByoipCidrInput) (*ec2.ProvisionByoipCidrOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ProvisionByoipCidr", arg0)
-	ret0, _ := ret[0].(*ec2.ProvisionByoipCidrOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ProvisionByoipCidr indicates an expected call of ProvisionByoipCidr.
-func (mr *MockEC2APIMockRecorder) ProvisionByoipCidr(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionByoipCidr", reflect.TypeOf((*MockEC2API)(nil).ProvisionByoipCidr), arg0)
-}
-
-// ProvisionByoipCidrRequest mocks base method.
-func (m *MockEC2API) ProvisionByoipCidrRequest(arg0 *ec2.ProvisionByoipCidrInput) (*request.Request, *ec2.ProvisionByoipCidrOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ProvisionByoipCidrRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ProvisionByoipCidrOutput)
-	return ret0, ret1
-}
-
-// ProvisionByoipCidrRequest indicates an expected call of ProvisionByoipCidrRequest.
-func (mr *MockEC2APIMockRecorder) ProvisionByoipCidrRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionByoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).ProvisionByoipCidrRequest), arg0)
-}
-
-// ProvisionByoipCidrWithContext mocks base method.
-func (m *MockEC2API) ProvisionByoipCidrWithContext(arg0 context.Context, arg1 *ec2.ProvisionByoipCidrInput, arg2 ...request.Option) (*ec2.ProvisionByoipCidrOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ProvisionByoipCidrWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ProvisionByoipCidrOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ProvisionByoipCidrWithContext indicates an expected call of ProvisionByoipCidrWithContext.
-func (mr *MockEC2APIMockRecorder) ProvisionByoipCidrWithContext(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, "ProvisionByoipCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).ProvisionByoipCidrWithContext), varargs...)
-}
-
-// ProvisionIpamByoasn mocks base method.
-func (m *MockEC2API) ProvisionIpamByoasn(arg0 *ec2.ProvisionIpamByoasnInput) (*ec2.ProvisionIpamByoasnOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ProvisionIpamByoasn", arg0)
-	ret0, _ := ret[0].(*ec2.ProvisionIpamByoasnOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ProvisionIpamByoasn indicates an expected call of ProvisionIpamByoasn.
-func (mr *MockEC2APIMockRecorder) ProvisionIpamByoasn(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionIpamByoasn", reflect.TypeOf((*MockEC2API)(nil).ProvisionIpamByoasn), arg0)
-}
-
-// ProvisionIpamByoasnRequest mocks base method.
-func (m *MockEC2API) ProvisionIpamByoasnRequest(arg0 *ec2.ProvisionIpamByoasnInput) (*request.Request, *ec2.ProvisionIpamByoasnOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ProvisionIpamByoasnRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ProvisionIpamByoasnOutput)
-	return ret0, ret1
-}
-
-// ProvisionIpamByoasnRequest indicates an expected call of ProvisionIpamByoasnRequest.
-func (mr *MockEC2APIMockRecorder) ProvisionIpamByoasnRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionIpamByoasnRequest", reflect.TypeOf((*MockEC2API)(nil).ProvisionIpamByoasnRequest), arg0)
-}
-
-// ProvisionIpamByoasnWithContext mocks base method.
-func (m *MockEC2API) ProvisionIpamByoasnWithContext(arg0 context.Context, arg1 *ec2.ProvisionIpamByoasnInput, arg2 ...request.Option) (*ec2.ProvisionIpamByoasnOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ProvisionIpamByoasnWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ProvisionIpamByoasnOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ProvisionIpamByoasnWithContext indicates an expected call of ProvisionIpamByoasnWithContext.
-func (mr *MockEC2APIMockRecorder) ProvisionIpamByoasnWithContext(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, "ProvisionIpamByoasnWithContext", reflect.TypeOf((*MockEC2API)(nil).ProvisionIpamByoasnWithContext), varargs...)
-}
-
-// ProvisionIpamPoolCidr mocks base method.
-func (m *MockEC2API) ProvisionIpamPoolCidr(arg0 *ec2.ProvisionIpamPoolCidrInput) (*ec2.ProvisionIpamPoolCidrOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ProvisionIpamPoolCidr", arg0)
-	ret0, _ := ret[0].(*ec2.ProvisionIpamPoolCidrOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ProvisionIpamPoolCidr indicates an expected call of ProvisionIpamPoolCidr.
-func (mr *MockEC2APIMockRecorder) ProvisionIpamPoolCidr(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionIpamPoolCidr", reflect.TypeOf((*MockEC2API)(nil).ProvisionIpamPoolCidr), arg0)
-}
-
-// ProvisionIpamPoolCidrRequest mocks base method.
-func (m *MockEC2API) ProvisionIpamPoolCidrRequest(arg0 *ec2.ProvisionIpamPoolCidrInput) (*request.Request, *ec2.ProvisionIpamPoolCidrOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ProvisionIpamPoolCidrRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ProvisionIpamPoolCidrOutput)
-	return ret0, ret1
-}
-
-// ProvisionIpamPoolCidrRequest indicates an expected call of ProvisionIpamPoolCidrRequest.
-func (mr *MockEC2APIMockRecorder) ProvisionIpamPoolCidrRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionIpamPoolCidrRequest", reflect.TypeOf((*MockEC2API)(nil).ProvisionIpamPoolCidrRequest), arg0)
-}
-
-// ProvisionIpamPoolCidrWithContext mocks base method.
-func (m *MockEC2API) ProvisionIpamPoolCidrWithContext(arg0 context.Context, arg1 *ec2.ProvisionIpamPoolCidrInput, arg2 ...request.Option) (*ec2.ProvisionIpamPoolCidrOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ProvisionIpamPoolCidrWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ProvisionIpamPoolCidrOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ProvisionIpamPoolCidrWithContext indicates an expected call of ProvisionIpamPoolCidrWithContext.
-func (mr *MockEC2APIMockRecorder) ProvisionIpamPoolCidrWithContext(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, "ProvisionIpamPoolCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).ProvisionIpamPoolCidrWithContext), varargs...)
-}
-
-// ProvisionPublicIpv4PoolCidr mocks base method.
-func (m *MockEC2API) ProvisionPublicIpv4PoolCidr(arg0 *ec2.ProvisionPublicIpv4PoolCidrInput) (*ec2.ProvisionPublicIpv4PoolCidrOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ProvisionPublicIpv4PoolCidr", arg0)
-	ret0, _ := ret[0].(*ec2.ProvisionPublicIpv4PoolCidrOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ProvisionPublicIpv4PoolCidr indicates an expected call of ProvisionPublicIpv4PoolCidr.
-func (mr *MockEC2APIMockRecorder) ProvisionPublicIpv4PoolCidr(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionPublicIpv4PoolCidr", reflect.TypeOf((*MockEC2API)(nil).ProvisionPublicIpv4PoolCidr), arg0)
-}
-
-// ProvisionPublicIpv4PoolCidrRequest mocks base method.
-func (m *MockEC2API) ProvisionPublicIpv4PoolCidrRequest(arg0 *ec2.ProvisionPublicIpv4PoolCidrInput) (*request.Request, *ec2.ProvisionPublicIpv4PoolCidrOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ProvisionPublicIpv4PoolCidrRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ProvisionPublicIpv4PoolCidrOutput)
-	return ret0, ret1
-}
-
-// ProvisionPublicIpv4PoolCidrRequest indicates an expected call of ProvisionPublicIpv4PoolCidrRequest.
-func (mr *MockEC2APIMockRecorder) ProvisionPublicIpv4PoolCidrRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionPublicIpv4PoolCidrRequest", reflect.TypeOf((*MockEC2API)(nil).ProvisionPublicIpv4PoolCidrRequest), arg0)
-}
-
-// ProvisionPublicIpv4PoolCidrWithContext mocks base method.
-func (m *MockEC2API) ProvisionPublicIpv4PoolCidrWithContext(arg0 context.Context, arg1 *ec2.ProvisionPublicIpv4PoolCidrInput, arg2 ...request.Option) (*ec2.ProvisionPublicIpv4PoolCidrOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ProvisionPublicIpv4PoolCidrWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ProvisionPublicIpv4PoolCidrOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ProvisionPublicIpv4PoolCidrWithContext indicates an expected call of ProvisionPublicIpv4PoolCidrWithContext.
-func (mr *MockEC2APIMockRecorder) ProvisionPublicIpv4PoolCidrWithContext(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, "ProvisionPublicIpv4PoolCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).ProvisionPublicIpv4PoolCidrWithContext), varargs...)
-}
-
-// PurchaseCapacityBlock mocks base method.
-func (m *MockEC2API) PurchaseCapacityBlock(arg0 *ec2.PurchaseCapacityBlockInput) (*ec2.PurchaseCapacityBlockOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PurchaseCapacityBlock", arg0)
-	ret0, _ := ret[0].(*ec2.PurchaseCapacityBlockOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PurchaseCapacityBlock indicates an expected call of PurchaseCapacityBlock.
-func (mr *MockEC2APIMockRecorder) PurchaseCapacityBlock(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseCapacityBlock", reflect.TypeOf((*MockEC2API)(nil).PurchaseCapacityBlock), arg0)
-}
-
-// PurchaseCapacityBlockRequest mocks base method.
-func (m *MockEC2API) PurchaseCapacityBlockRequest(arg0 *ec2.PurchaseCapacityBlockInput) (*request.Request, *ec2.PurchaseCapacityBlockOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PurchaseCapacityBlockRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.PurchaseCapacityBlockOutput)
-	return ret0, ret1
-}
-
-// PurchaseCapacityBlockRequest indicates an expected call of PurchaseCapacityBlockRequest.
-func (mr *MockEC2APIMockRecorder) PurchaseCapacityBlockRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseCapacityBlockRequest", reflect.TypeOf((*MockEC2API)(nil).PurchaseCapacityBlockRequest), arg0)
-}
-
-// PurchaseCapacityBlockWithContext mocks base method.
-func (m *MockEC2API) PurchaseCapacityBlockWithContext(arg0 context.Context, arg1 *ec2.PurchaseCapacityBlockInput, arg2 ...request.Option) (*ec2.PurchaseCapacityBlockOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "PurchaseCapacityBlockWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.PurchaseCapacityBlockOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PurchaseCapacityBlockWithContext indicates an expected call of PurchaseCapacityBlockWithContext.
-func (mr *MockEC2APIMockRecorder) PurchaseCapacityBlockWithContext(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, "PurchaseCapacityBlockWithContext", reflect.TypeOf((*MockEC2API)(nil).PurchaseCapacityBlockWithContext), varargs...)
-}
-
-// PurchaseHostReservation mocks base method.
-func (m *MockEC2API) PurchaseHostReservation(arg0 *ec2.PurchaseHostReservationInput) (*ec2.PurchaseHostReservationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PurchaseHostReservation", arg0)
-	ret0, _ := ret[0].(*ec2.PurchaseHostReservationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PurchaseHostReservation indicates an expected call of PurchaseHostReservation.
-func (mr *MockEC2APIMockRecorder) PurchaseHostReservation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseHostReservation", reflect.TypeOf((*MockEC2API)(nil).PurchaseHostReservation), arg0)
-}
-
-// PurchaseHostReservationRequest mocks base method.
-func (m *MockEC2API) PurchaseHostReservationRequest(arg0 *ec2.PurchaseHostReservationInput) (*request.Request, *ec2.PurchaseHostReservationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PurchaseHostReservationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.PurchaseHostReservationOutput)
-	return ret0, ret1
-}
-
-// PurchaseHostReservationRequest indicates an expected call of PurchaseHostReservationRequest.
-func (mr *MockEC2APIMockRecorder) PurchaseHostReservationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseHostReservationRequest", reflect.TypeOf((*MockEC2API)(nil).PurchaseHostReservationRequest), arg0)
-}
-
-// PurchaseHostReservationWithContext mocks base method.
-func (m *MockEC2API) PurchaseHostReservationWithContext(arg0 context.Context, arg1 *ec2.PurchaseHostReservationInput, arg2 ...request.Option) (*ec2.PurchaseHostReservationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "PurchaseHostReservationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.PurchaseHostReservationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PurchaseHostReservationWithContext indicates an expected call of PurchaseHostReservationWithContext.
-func (mr *MockEC2APIMockRecorder) PurchaseHostReservationWithContext(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, "PurchaseHostReservationWithContext", reflect.TypeOf((*MockEC2API)(nil).PurchaseHostReservationWithContext), varargs...)
-}
-
-// PurchaseReservedInstancesOffering mocks base method.
-func (m *MockEC2API) PurchaseReservedInstancesOffering(arg0 *ec2.PurchaseReservedInstancesOfferingInput) (*ec2.PurchaseReservedInstancesOfferingOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PurchaseReservedInstancesOffering", arg0)
-	ret0, _ := ret[0].(*ec2.PurchaseReservedInstancesOfferingOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PurchaseReservedInstancesOffering indicates an expected call of PurchaseReservedInstancesOffering.
-func (mr *MockEC2APIMockRecorder) PurchaseReservedInstancesOffering(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseReservedInstancesOffering", reflect.TypeOf((*MockEC2API)(nil).PurchaseReservedInstancesOffering), arg0)
-}
-
-// PurchaseReservedInstancesOfferingRequest mocks base method.
-func (m *MockEC2API) PurchaseReservedInstancesOfferingRequest(arg0 *ec2.PurchaseReservedInstancesOfferingInput) (*request.Request, *ec2.PurchaseReservedInstancesOfferingOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PurchaseReservedInstancesOfferingRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.PurchaseReservedInstancesOfferingOutput)
-	return ret0, ret1
-}
-
-// PurchaseReservedInstancesOfferingRequest indicates an expected call of PurchaseReservedInstancesOfferingRequest.
-func (mr *MockEC2APIMockRecorder) PurchaseReservedInstancesOfferingRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseReservedInstancesOfferingRequest", reflect.TypeOf((*MockEC2API)(nil).PurchaseReservedInstancesOfferingRequest), arg0)
-}
-
-// PurchaseReservedInstancesOfferingWithContext mocks base method.
-func (m *MockEC2API) PurchaseReservedInstancesOfferingWithContext(arg0 context.Context, arg1 *ec2.PurchaseReservedInstancesOfferingInput, arg2 ...request.Option) (*ec2.PurchaseReservedInstancesOfferingOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "PurchaseReservedInstancesOfferingWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.PurchaseReservedInstancesOfferingOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PurchaseReservedInstancesOfferingWithContext indicates an expected call of PurchaseReservedInstancesOfferingWithContext.
-func (mr *MockEC2APIMockRecorder) PurchaseReservedInstancesOfferingWithContext(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, "PurchaseReservedInstancesOfferingWithContext", reflect.TypeOf((*MockEC2API)(nil).PurchaseReservedInstancesOfferingWithContext), varargs...)
-}
-
-// PurchaseScheduledInstances mocks base method.
-func (m *MockEC2API) PurchaseScheduledInstances(arg0 *ec2.PurchaseScheduledInstancesInput) (*ec2.PurchaseScheduledInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PurchaseScheduledInstances", arg0)
-	ret0, _ := ret[0].(*ec2.PurchaseScheduledInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PurchaseScheduledInstances indicates an expected call of PurchaseScheduledInstances.
-func (mr *MockEC2APIMockRecorder) PurchaseScheduledInstances(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseScheduledInstances", reflect.TypeOf((*MockEC2API)(nil).PurchaseScheduledInstances), arg0)
-}
-
-// PurchaseScheduledInstancesRequest mocks base method.
-func (m *MockEC2API) PurchaseScheduledInstancesRequest(arg0 *ec2.PurchaseScheduledInstancesInput) (*request.Request, *ec2.PurchaseScheduledInstancesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PurchaseScheduledInstancesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.PurchaseScheduledInstancesOutput)
-	return ret0, ret1
-}
-
-// PurchaseScheduledInstancesRequest indicates an expected call of PurchaseScheduledInstancesRequest.
-func (mr *MockEC2APIMockRecorder) PurchaseScheduledInstancesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseScheduledInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).PurchaseScheduledInstancesRequest), arg0)
-}
-
-// PurchaseScheduledInstancesWithContext mocks base method.
-func (m *MockEC2API) PurchaseScheduledInstancesWithContext(arg0 context.Context, arg1 *ec2.PurchaseScheduledInstancesInput, arg2 ...request.Option) (*ec2.PurchaseScheduledInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "PurchaseScheduledInstancesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.PurchaseScheduledInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PurchaseScheduledInstancesWithContext indicates an expected call of PurchaseScheduledInstancesWithContext.
-func (mr *MockEC2APIMockRecorder) PurchaseScheduledInstancesWithContext(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, "PurchaseScheduledInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).PurchaseScheduledInstancesWithContext), varargs...)
-}
-
-// RebootInstances mocks base method.
-func (m *MockEC2API) RebootInstances(arg0 *ec2.RebootInstancesInput) (*ec2.RebootInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RebootInstances", arg0)
-	ret0, _ := ret[0].(*ec2.RebootInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RebootInstances indicates an expected call of RebootInstances.
-func (mr *MockEC2APIMockRecorder) RebootInstances(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootInstances", reflect.TypeOf((*MockEC2API)(nil).RebootInstances), arg0)
-}
-
-// RebootInstancesRequest mocks base method.
-func (m *MockEC2API) RebootInstancesRequest(arg0 *ec2.RebootInstancesInput) (*request.Request, *ec2.RebootInstancesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RebootInstancesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.RebootInstancesOutput)
-	return ret0, ret1
-}
-
-// RebootInstancesRequest indicates an expected call of RebootInstancesRequest.
-func (mr *MockEC2APIMockRecorder) RebootInstancesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).RebootInstancesRequest), arg0)
-}
-
-// RebootInstancesWithContext mocks base method.
-func (m *MockEC2API) RebootInstancesWithContext(arg0 context.Context, arg1 *ec2.RebootInstancesInput, arg2 ...request.Option) (*ec2.RebootInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RebootInstancesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.RebootInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RebootInstancesWithContext indicates an expected call of RebootInstancesWithContext.
-func (mr *MockEC2APIMockRecorder) RebootInstancesWithContext(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, "RebootInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).RebootInstancesWithContext), varargs...)
-}
-
-// RegisterImage mocks base method.
-func (m *MockEC2API) RegisterImage(arg0 *ec2.RegisterImageInput) (*ec2.RegisterImageOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RegisterImage", arg0)
-	ret0, _ := ret[0].(*ec2.RegisterImageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RegisterImage indicates an expected call of RegisterImage.
-func (mr *MockEC2APIMockRecorder) RegisterImage(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterImage", reflect.TypeOf((*MockEC2API)(nil).RegisterImage), arg0)
-}
-
-// RegisterImageRequest mocks base method.
-func (m *MockEC2API) RegisterImageRequest(arg0 *ec2.RegisterImageInput) (*request.Request, *ec2.RegisterImageOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RegisterImageRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.RegisterImageOutput)
-	return ret0, ret1
-}
-
-// RegisterImageRequest indicates an expected call of RegisterImageRequest.
-func (mr *MockEC2APIMockRecorder) RegisterImageRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterImageRequest", reflect.TypeOf((*MockEC2API)(nil).RegisterImageRequest), arg0)
-}
-
-// RegisterImageWithContext mocks base method.
-func (m *MockEC2API) RegisterImageWithContext(arg0 context.Context, arg1 *ec2.RegisterImageInput, arg2 ...request.Option) (*ec2.RegisterImageOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RegisterImageWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.RegisterImageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RegisterImageWithContext indicates an expected call of RegisterImageWithContext.
-func (mr *MockEC2APIMockRecorder) RegisterImageWithContext(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, "RegisterImageWithContext", reflect.TypeOf((*MockEC2API)(nil).RegisterImageWithContext), varargs...)
-}
-
-// RegisterInstanceEventNotificationAttributes mocks base method.
-func (m *MockEC2API) RegisterInstanceEventNotificationAttributes(arg0 *ec2.RegisterInstanceEventNotificationAttributesInput) (*ec2.RegisterInstanceEventNotificationAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RegisterInstanceEventNotificationAttributes", arg0)
-	ret0, _ := ret[0].(*ec2.RegisterInstanceEventNotificationAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RegisterInstanceEventNotificationAttributes indicates an expected call of RegisterInstanceEventNotificationAttributes.
-func (mr *MockEC2APIMockRecorder) RegisterInstanceEventNotificationAttributes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInstanceEventNotificationAttributes", reflect.TypeOf((*MockEC2API)(nil).RegisterInstanceEventNotificationAttributes), arg0)
-}
-
-// RegisterInstanceEventNotificationAttributesRequest mocks base method.
-func (m *MockEC2API) RegisterInstanceEventNotificationAttributesRequest(arg0 *ec2.RegisterInstanceEventNotificationAttributesInput) (*request.Request, *ec2.RegisterInstanceEventNotificationAttributesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RegisterInstanceEventNotificationAttributesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.RegisterInstanceEventNotificationAttributesOutput)
-	return ret0, ret1
-}
-
-// RegisterInstanceEventNotificationAttributesRequest indicates an expected call of RegisterInstanceEventNotificationAttributesRequest.
-func (mr *MockEC2APIMockRecorder) RegisterInstanceEventNotificationAttributesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInstanceEventNotificationAttributesRequest", reflect.TypeOf((*MockEC2API)(nil).RegisterInstanceEventNotificationAttributesRequest), arg0)
-}
-
-// RegisterInstanceEventNotificationAttributesWithContext mocks base method.
-func (m *MockEC2API) RegisterInstanceEventNotificationAttributesWithContext(arg0 context.Context, arg1 *ec2.RegisterInstanceEventNotificationAttributesInput, arg2 ...request.Option) (*ec2.RegisterInstanceEventNotificationAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RegisterInstanceEventNotificationAttributesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.RegisterInstanceEventNotificationAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RegisterInstanceEventNotificationAttributesWithContext indicates an expected call of RegisterInstanceEventNotificationAttributesWithContext.
-func (mr *MockEC2APIMockRecorder) RegisterInstanceEventNotificationAttributesWithContext(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, "RegisterInstanceEventNotificationAttributesWithContext", reflect.TypeOf((*MockEC2API)(nil).RegisterInstanceEventNotificationAttributesWithContext), varargs...)
-}
-
-// RegisterTransitGatewayMulticastGroupMembers mocks base method.
-func (m *MockEC2API) RegisterTransitGatewayMulticastGroupMembers(arg0 *ec2.RegisterTransitGatewayMulticastGroupMembersInput) (*ec2.RegisterTransitGatewayMulticastGroupMembersOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupMembers", arg0)
-	ret0, _ := ret[0].(*ec2.RegisterTransitGatewayMulticastGroupMembersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RegisterTransitGatewayMulticastGroupMembers indicates an expected call of RegisterTransitGatewayMulticastGroupMembers.
-func (mr *MockEC2APIMockRecorder) RegisterTransitGatewayMulticastGroupMembers(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTransitGatewayMulticastGroupMembers", reflect.TypeOf((*MockEC2API)(nil).RegisterTransitGatewayMulticastGroupMembers), arg0)
-}
-
-// RegisterTransitGatewayMulticastGroupMembersRequest mocks base method.
-func (m *MockEC2API) RegisterTransitGatewayMulticastGroupMembersRequest(arg0 *ec2.RegisterTransitGatewayMulticastGroupMembersInput) (*request.Request, *ec2.RegisterTransitGatewayMulticastGroupMembersOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupMembersRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.RegisterTransitGatewayMulticastGroupMembersOutput)
-	return ret0, ret1
-}
-
-// RegisterTransitGatewayMulticastGroupMembersRequest indicates an expected call of RegisterTransitGatewayMulticastGroupMembersRequest.
-func (mr *MockEC2APIMockRecorder) RegisterTransitGatewayMulticastGroupMembersRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTransitGatewayMulticastGroupMembersRequest", reflect.TypeOf((*MockEC2API)(nil).RegisterTransitGatewayMulticastGroupMembersRequest), arg0)
-}
-
-// RegisterTransitGatewayMulticastGroupMembersWithContext mocks base method.
-func (m *MockEC2API) RegisterTransitGatewayMulticastGroupMembersWithContext(arg0 context.Context, arg1 *ec2.RegisterTransitGatewayMulticastGroupMembersInput, arg2 ...request.Option) (*ec2.RegisterTransitGatewayMulticastGroupMembersOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupMembersWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.RegisterTransitGatewayMulticastGroupMembersOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RegisterTransitGatewayMulticastGroupMembersWithContext indicates an expected call of RegisterTransitGatewayMulticastGroupMembersWithContext.
-func (mr *MockEC2APIMockRecorder) RegisterTransitGatewayMulticastGroupMembersWithContext(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, "RegisterTransitGatewayMulticastGroupMembersWithContext", reflect.TypeOf((*MockEC2API)(nil).RegisterTransitGatewayMulticastGroupMembersWithContext), varargs...)
-}
-
-// RegisterTransitGatewayMulticastGroupSources mocks base method.
-func (m *MockEC2API) RegisterTransitGatewayMulticastGroupSources(arg0 *ec2.RegisterTransitGatewayMulticastGroupSourcesInput) (*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupSources", arg0)
-	ret0, _ := ret[0].(*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RegisterTransitGatewayMulticastGroupSources indicates an expected call of RegisterTransitGatewayMulticastGroupSources.
-func (mr *MockEC2APIMockRecorder) RegisterTransitGatewayMulticastGroupSources(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTransitGatewayMulticastGroupSources", reflect.TypeOf((*MockEC2API)(nil).RegisterTransitGatewayMulticastGroupSources), arg0)
-}
-
-// RegisterTransitGatewayMulticastGroupSourcesRequest mocks base method.
-func (m *MockEC2API) RegisterTransitGatewayMulticastGroupSourcesRequest(arg0 *ec2.RegisterTransitGatewayMulticastGroupSourcesInput) (*request.Request, *ec2.RegisterTransitGatewayMulticastGroupSourcesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupSourcesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput)
-	return ret0, ret1
-}
-
-// RegisterTransitGatewayMulticastGroupSourcesRequest indicates an expected call of RegisterTransitGatewayMulticastGroupSourcesRequest.
-func (mr *MockEC2APIMockRecorder) RegisterTransitGatewayMulticastGroupSourcesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTransitGatewayMulticastGroupSourcesRequest", reflect.TypeOf((*MockEC2API)(nil).RegisterTransitGatewayMulticastGroupSourcesRequest), arg0)
-}
-
-// RegisterTransitGatewayMulticastGroupSourcesWithContext mocks base method.
-func (m *MockEC2API) RegisterTransitGatewayMulticastGroupSourcesWithContext(arg0 context.Context, arg1 *ec2.RegisterTransitGatewayMulticastGroupSourcesInput, arg2 ...request.Option) (*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupSourcesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RegisterTransitGatewayMulticastGroupSourcesWithContext indicates an expected call of RegisterTransitGatewayMulticastGroupSourcesWithContext.
-func (mr *MockEC2APIMockRecorder) RegisterTransitGatewayMulticastGroupSourcesWithContext(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, "RegisterTransitGatewayMulticastGroupSourcesWithContext", reflect.TypeOf((*MockEC2API)(nil).RegisterTransitGatewayMulticastGroupSourcesWithContext), varargs...)
-}
-
-// RejectTransitGatewayMulticastDomainAssociations mocks base method.
-func (m *MockEC2API) RejectTransitGatewayMulticastDomainAssociations(arg0 *ec2.RejectTransitGatewayMulticastDomainAssociationsInput) (*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RejectTransitGatewayMulticastDomainAssociations", arg0)
-	ret0, _ := ret[0].(*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RejectTransitGatewayMulticastDomainAssociations indicates an expected call of RejectTransitGatewayMulticastDomainAssociations.
-func (mr *MockEC2APIMockRecorder) RejectTransitGatewayMulticastDomainAssociations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayMulticastDomainAssociations", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayMulticastDomainAssociations), arg0)
-}
-
-// RejectTransitGatewayMulticastDomainAssociationsRequest mocks base method.
-func (m *MockEC2API) RejectTransitGatewayMulticastDomainAssociationsRequest(arg0 *ec2.RejectTransitGatewayMulticastDomainAssociationsInput) (*request.Request, *ec2.RejectTransitGatewayMulticastDomainAssociationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RejectTransitGatewayMulticastDomainAssociationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput)
-	return ret0, ret1
-}
-
-// RejectTransitGatewayMulticastDomainAssociationsRequest indicates an expected call of RejectTransitGatewayMulticastDomainAssociationsRequest.
-func (mr *MockEC2APIMockRecorder) RejectTransitGatewayMulticastDomainAssociationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayMulticastDomainAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayMulticastDomainAssociationsRequest), arg0)
-}
-
-// RejectTransitGatewayMulticastDomainAssociationsWithContext mocks base method.
-func (m *MockEC2API) RejectTransitGatewayMulticastDomainAssociationsWithContext(arg0 context.Context, arg1 *ec2.RejectTransitGatewayMulticastDomainAssociationsInput, arg2 ...request.Option) (*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RejectTransitGatewayMulticastDomainAssociationsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RejectTransitGatewayMulticastDomainAssociationsWithContext indicates an expected call of RejectTransitGatewayMulticastDomainAssociationsWithContext.
-func (mr *MockEC2APIMockRecorder) RejectTransitGatewayMulticastDomainAssociationsWithContext(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, "RejectTransitGatewayMulticastDomainAssociationsWithContext", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayMulticastDomainAssociationsWithContext), varargs...)
-}
-
-// RejectTransitGatewayPeeringAttachment mocks base method.
-func (m *MockEC2API) RejectTransitGatewayPeeringAttachment(arg0 *ec2.RejectTransitGatewayPeeringAttachmentInput) (*ec2.RejectTransitGatewayPeeringAttachmentOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RejectTransitGatewayPeeringAttachment", arg0)
-	ret0, _ := ret[0].(*ec2.RejectTransitGatewayPeeringAttachmentOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RejectTransitGatewayPeeringAttachment indicates an expected call of RejectTransitGatewayPeeringAttachment.
-func (mr *MockEC2APIMockRecorder) RejectTransitGatewayPeeringAttachment(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayPeeringAttachment", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayPeeringAttachment), arg0)
-}
-
-// RejectTransitGatewayPeeringAttachmentRequest mocks base method.
-func (m *MockEC2API) RejectTransitGatewayPeeringAttachmentRequest(arg0 *ec2.RejectTransitGatewayPeeringAttachmentInput) (*request.Request, *ec2.RejectTransitGatewayPeeringAttachmentOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RejectTransitGatewayPeeringAttachmentRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.RejectTransitGatewayPeeringAttachmentOutput)
-	return ret0, ret1
-}
-
-// RejectTransitGatewayPeeringAttachmentRequest indicates an expected call of RejectTransitGatewayPeeringAttachmentRequest.
-func (mr *MockEC2APIMockRecorder) RejectTransitGatewayPeeringAttachmentRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayPeeringAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayPeeringAttachmentRequest), arg0)
-}
-
-// RejectTransitGatewayPeeringAttachmentWithContext mocks base method.
-func (m *MockEC2API) RejectTransitGatewayPeeringAttachmentWithContext(arg0 context.Context, arg1 *ec2.RejectTransitGatewayPeeringAttachmentInput, arg2 ...request.Option) (*ec2.RejectTransitGatewayPeeringAttachmentOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RejectTransitGatewayPeeringAttachmentWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.RejectTransitGatewayPeeringAttachmentOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RejectTransitGatewayPeeringAttachmentWithContext indicates an expected call of RejectTransitGatewayPeeringAttachmentWithContext.
-func (mr *MockEC2APIMockRecorder) RejectTransitGatewayPeeringAttachmentWithContext(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, "RejectTransitGatewayPeeringAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayPeeringAttachmentWithContext), varargs...)
-}
-
-// RejectTransitGatewayVpcAttachment mocks base method.
-func (m *MockEC2API) RejectTransitGatewayVpcAttachment(arg0 *ec2.RejectTransitGatewayVpcAttachmentInput) (*ec2.RejectTransitGatewayVpcAttachmentOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RejectTransitGatewayVpcAttachment", arg0)
-	ret0, _ := ret[0].(*ec2.RejectTransitGatewayVpcAttachmentOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RejectTransitGatewayVpcAttachment indicates an expected call of RejectTransitGatewayVpcAttachment.
-func (mr *MockEC2APIMockRecorder) RejectTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayVpcAttachment), arg0)
-}
-
-// RejectTransitGatewayVpcAttachmentRequest mocks base method.
-func (m *MockEC2API) RejectTransitGatewayVpcAttachmentRequest(arg0 *ec2.RejectTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.RejectTransitGatewayVpcAttachmentOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RejectTransitGatewayVpcAttachmentRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.RejectTransitGatewayVpcAttachmentOutput)
-	return ret0, ret1
-}
-
-// RejectTransitGatewayVpcAttachmentRequest indicates an expected call of RejectTransitGatewayVpcAttachmentRequest.
-func (mr *MockEC2APIMockRecorder) RejectTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayVpcAttachmentRequest), arg0)
-}
-
-// RejectTransitGatewayVpcAttachmentWithContext mocks base method.
-func (m *MockEC2API) RejectTransitGatewayVpcAttachmentWithContext(arg0 context.Context, arg1 *ec2.RejectTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.RejectTransitGatewayVpcAttachmentOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RejectTransitGatewayVpcAttachmentWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.RejectTransitGatewayVpcAttachmentOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RejectTransitGatewayVpcAttachmentWithContext indicates an expected call of RejectTransitGatewayVpcAttachmentWithContext.
-func (mr *MockEC2APIMockRecorder) RejectTransitGatewayVpcAttachmentWithContext(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, "RejectTransitGatewayVpcAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayVpcAttachmentWithContext), varargs...)
-}
-
-// RejectVpcEndpointConnections mocks base method.
-func (m *MockEC2API) RejectVpcEndpointConnections(arg0 *ec2.RejectVpcEndpointConnectionsInput) (*ec2.RejectVpcEndpointConnectionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RejectVpcEndpointConnections", arg0)
-	ret0, _ := ret[0].(*ec2.RejectVpcEndpointConnectionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RejectVpcEndpointConnections indicates an expected call of RejectVpcEndpointConnections.
-func (mr *MockEC2APIMockRecorder) RejectVpcEndpointConnections(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcEndpointConnections", reflect.TypeOf((*MockEC2API)(nil).RejectVpcEndpointConnections), arg0)
-}
-
-// RejectVpcEndpointConnectionsRequest mocks base method.
-func (m *MockEC2API) RejectVpcEndpointConnectionsRequest(arg0 *ec2.RejectVpcEndpointConnectionsInput) (*request.Request, *ec2.RejectVpcEndpointConnectionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RejectVpcEndpointConnectionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.RejectVpcEndpointConnectionsOutput)
-	return ret0, ret1
-}
-
-// RejectVpcEndpointConnectionsRequest indicates an expected call of RejectVpcEndpointConnectionsRequest.
-func (mr *MockEC2APIMockRecorder) RejectVpcEndpointConnectionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcEndpointConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).RejectVpcEndpointConnectionsRequest), arg0)
-}
-
-// RejectVpcEndpointConnectionsWithContext mocks base method.
-func (m *MockEC2API) RejectVpcEndpointConnectionsWithContext(arg0 context.Context, arg1 *ec2.RejectVpcEndpointConnectionsInput, arg2 ...request.Option) (*ec2.RejectVpcEndpointConnectionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RejectVpcEndpointConnectionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.RejectVpcEndpointConnectionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RejectVpcEndpointConnectionsWithContext indicates an expected call of RejectVpcEndpointConnectionsWithContext.
-func (mr *MockEC2APIMockRecorder) RejectVpcEndpointConnectionsWithContext(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, "RejectVpcEndpointConnectionsWithContext", reflect.TypeOf((*MockEC2API)(nil).RejectVpcEndpointConnectionsWithContext), varargs...)
-}
-
-// RejectVpcPeeringConnection mocks base method.
-func (m *MockEC2API) RejectVpcPeeringConnection(arg0 *ec2.RejectVpcPeeringConnectionInput) (*ec2.RejectVpcPeeringConnectionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RejectVpcPeeringConnection", arg0)
-	ret0, _ := ret[0].(*ec2.RejectVpcPeeringConnectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RejectVpcPeeringConnection indicates an expected call of RejectVpcPeeringConnection.
-func (mr *MockEC2APIMockRecorder) RejectVpcPeeringConnection(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcPeeringConnection", reflect.TypeOf((*MockEC2API)(nil).RejectVpcPeeringConnection), arg0)
-}
-
-// RejectVpcPeeringConnectionRequest mocks base method.
-func (m *MockEC2API) RejectVpcPeeringConnectionRequest(arg0 *ec2.RejectVpcPeeringConnectionInput) (*request.Request, *ec2.RejectVpcPeeringConnectionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RejectVpcPeeringConnectionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.RejectVpcPeeringConnectionOutput)
-	return ret0, ret1
-}
-
-// RejectVpcPeeringConnectionRequest indicates an expected call of RejectVpcPeeringConnectionRequest.
-func (mr *MockEC2APIMockRecorder) RejectVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).RejectVpcPeeringConnectionRequest), arg0)
-}
-
-// RejectVpcPeeringConnectionWithContext mocks base method.
-func (m *MockEC2API) RejectVpcPeeringConnectionWithContext(arg0 context.Context, arg1 *ec2.RejectVpcPeeringConnectionInput, arg2 ...request.Option) (*ec2.RejectVpcPeeringConnectionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RejectVpcPeeringConnectionWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.RejectVpcPeeringConnectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RejectVpcPeeringConnectionWithContext indicates an expected call of RejectVpcPeeringConnectionWithContext.
-func (mr *MockEC2APIMockRecorder) RejectVpcPeeringConnectionWithContext(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, "RejectVpcPeeringConnectionWithContext", reflect.TypeOf((*MockEC2API)(nil).RejectVpcPeeringConnectionWithContext), varargs...)
-}
-
-// ReleaseAddress mocks base method.
-func (m *MockEC2API) ReleaseAddress(arg0 *ec2.ReleaseAddressInput) (*ec2.ReleaseAddressOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReleaseAddress", arg0)
-	ret0, _ := ret[0].(*ec2.ReleaseAddressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReleaseAddress indicates an expected call of ReleaseAddress.
-func (mr *MockEC2APIMockRecorder) ReleaseAddress(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseAddress", reflect.TypeOf((*MockEC2API)(nil).ReleaseAddress), arg0)
-}
-
-// ReleaseAddressRequest mocks base method.
-func (m *MockEC2API) ReleaseAddressRequest(arg0 *ec2.ReleaseAddressInput) (*request.Request, *ec2.ReleaseAddressOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReleaseAddressRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ReleaseAddressOutput)
-	return ret0, ret1
-}
-
-// ReleaseAddressRequest indicates an expected call of ReleaseAddressRequest.
-func (mr *MockEC2APIMockRecorder) ReleaseAddressRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseAddressRequest", reflect.TypeOf((*MockEC2API)(nil).ReleaseAddressRequest), arg0)
-}
-
-// ReleaseAddressWithContext mocks base method.
-func (m *MockEC2API) ReleaseAddressWithContext(arg0 context.Context, arg1 *ec2.ReleaseAddressInput, arg2 ...request.Option) (*ec2.ReleaseAddressOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ReleaseAddressWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ReleaseAddressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReleaseAddressWithContext indicates an expected call of ReleaseAddressWithContext.
-func (mr *MockEC2APIMockRecorder) ReleaseAddressWithContext(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, "ReleaseAddressWithContext", reflect.TypeOf((*MockEC2API)(nil).ReleaseAddressWithContext), varargs...)
-}
-
-// ReleaseHosts mocks base method.
-func (m *MockEC2API) ReleaseHosts(arg0 *ec2.ReleaseHostsInput) (*ec2.ReleaseHostsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReleaseHosts", arg0)
-	ret0, _ := ret[0].(*ec2.ReleaseHostsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReleaseHosts indicates an expected call of ReleaseHosts.
-func (mr *MockEC2APIMockRecorder) ReleaseHosts(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseHosts", reflect.TypeOf((*MockEC2API)(nil).ReleaseHosts), arg0)
-}
-
-// ReleaseHostsRequest mocks base method.
-func (m *MockEC2API) ReleaseHostsRequest(arg0 *ec2.ReleaseHostsInput) (*request.Request, *ec2.ReleaseHostsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReleaseHostsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ReleaseHostsOutput)
-	return ret0, ret1
-}
-
-// ReleaseHostsRequest indicates an expected call of ReleaseHostsRequest.
-func (mr *MockEC2APIMockRecorder) ReleaseHostsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseHostsRequest", reflect.TypeOf((*MockEC2API)(nil).ReleaseHostsRequest), arg0)
-}
-
-// ReleaseHostsWithContext mocks base method.
-func (m *MockEC2API) ReleaseHostsWithContext(arg0 context.Context, arg1 *ec2.ReleaseHostsInput, arg2 ...request.Option) (*ec2.ReleaseHostsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ReleaseHostsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ReleaseHostsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReleaseHostsWithContext indicates an expected call of ReleaseHostsWithContext.
-func (mr *MockEC2APIMockRecorder) ReleaseHostsWithContext(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, "ReleaseHostsWithContext", reflect.TypeOf((*MockEC2API)(nil).ReleaseHostsWithContext), varargs...)
-}
-
-// ReleaseIpamPoolAllocation mocks base method.
-func (m *MockEC2API) ReleaseIpamPoolAllocation(arg0 *ec2.ReleaseIpamPoolAllocationInput) (*ec2.ReleaseIpamPoolAllocationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReleaseIpamPoolAllocation", arg0)
-	ret0, _ := ret[0].(*ec2.ReleaseIpamPoolAllocationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReleaseIpamPoolAllocation indicates an expected call of ReleaseIpamPoolAllocation.
-func (mr *MockEC2APIMockRecorder) ReleaseIpamPoolAllocation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseIpamPoolAllocation", reflect.TypeOf((*MockEC2API)(nil).ReleaseIpamPoolAllocation), arg0)
-}
-
-// ReleaseIpamPoolAllocationRequest mocks base method.
-func (m *MockEC2API) ReleaseIpamPoolAllocationRequest(arg0 *ec2.ReleaseIpamPoolAllocationInput) (*request.Request, *ec2.ReleaseIpamPoolAllocationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReleaseIpamPoolAllocationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ReleaseIpamPoolAllocationOutput)
-	return ret0, ret1
-}
-
-// ReleaseIpamPoolAllocationRequest indicates an expected call of ReleaseIpamPoolAllocationRequest.
-func (mr *MockEC2APIMockRecorder) ReleaseIpamPoolAllocationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseIpamPoolAllocationRequest", reflect.TypeOf((*MockEC2API)(nil).ReleaseIpamPoolAllocationRequest), arg0)
-}
-
-// ReleaseIpamPoolAllocationWithContext mocks base method.
-func (m *MockEC2API) ReleaseIpamPoolAllocationWithContext(arg0 context.Context, arg1 *ec2.ReleaseIpamPoolAllocationInput, arg2 ...request.Option) (*ec2.ReleaseIpamPoolAllocationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ReleaseIpamPoolAllocationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ReleaseIpamPoolAllocationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReleaseIpamPoolAllocationWithContext indicates an expected call of ReleaseIpamPoolAllocationWithContext.
-func (mr *MockEC2APIMockRecorder) ReleaseIpamPoolAllocationWithContext(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, "ReleaseIpamPoolAllocationWithContext", reflect.TypeOf((*MockEC2API)(nil).ReleaseIpamPoolAllocationWithContext), varargs...)
-}
-
-// ReplaceIamInstanceProfileAssociation mocks base method.
-func (m *MockEC2API) ReplaceIamInstanceProfileAssociation(arg0 *ec2.ReplaceIamInstanceProfileAssociationInput) (*ec2.ReplaceIamInstanceProfileAssociationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReplaceIamInstanceProfileAssociation", arg0)
-	ret0, _ := ret[0].(*ec2.ReplaceIamInstanceProfileAssociationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReplaceIamInstanceProfileAssociation indicates an expected call of ReplaceIamInstanceProfileAssociation.
-func (mr *MockEC2APIMockRecorder) ReplaceIamInstanceProfileAssociation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceIamInstanceProfileAssociation", reflect.TypeOf((*MockEC2API)(nil).ReplaceIamInstanceProfileAssociation), arg0)
-}
-
-// ReplaceIamInstanceProfileAssociationRequest mocks base method.
-func (m *MockEC2API) ReplaceIamInstanceProfileAssociationRequest(arg0 *ec2.ReplaceIamInstanceProfileAssociationInput) (*request.Request, *ec2.ReplaceIamInstanceProfileAssociationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReplaceIamInstanceProfileAssociationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ReplaceIamInstanceProfileAssociationOutput)
-	return ret0, ret1
-}
-
-// ReplaceIamInstanceProfileAssociationRequest indicates an expected call of ReplaceIamInstanceProfileAssociationRequest.
-func (mr *MockEC2APIMockRecorder) ReplaceIamInstanceProfileAssociationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceIamInstanceProfileAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceIamInstanceProfileAssociationRequest), arg0)
-}
-
-// ReplaceIamInstanceProfileAssociationWithContext mocks base method.
-func (m *MockEC2API) ReplaceIamInstanceProfileAssociationWithContext(arg0 context.Context, arg1 *ec2.ReplaceIamInstanceProfileAssociationInput, arg2 ...request.Option) (*ec2.ReplaceIamInstanceProfileAssociationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ReplaceIamInstanceProfileAssociationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ReplaceIamInstanceProfileAssociationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReplaceIamInstanceProfileAssociationWithContext indicates an expected call of ReplaceIamInstanceProfileAssociationWithContext.
-func (mr *MockEC2APIMockRecorder) ReplaceIamInstanceProfileAssociationWithContext(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, "ReplaceIamInstanceProfileAssociationWithContext", reflect.TypeOf((*MockEC2API)(nil).ReplaceIamInstanceProfileAssociationWithContext), varargs...)
-}
-
-// ReplaceNetworkAclAssociation mocks base method.
-func (m *MockEC2API) ReplaceNetworkAclAssociation(arg0 *ec2.ReplaceNetworkAclAssociationInput) (*ec2.ReplaceNetworkAclAssociationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReplaceNetworkAclAssociation", arg0)
-	ret0, _ := ret[0].(*ec2.ReplaceNetworkAclAssociationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReplaceNetworkAclAssociation indicates an expected call of ReplaceNetworkAclAssociation.
-func (mr *MockEC2APIMockRecorder) ReplaceNetworkAclAssociation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclAssociation", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclAssociation), arg0)
-}
-
-// ReplaceNetworkAclAssociationRequest mocks base method.
-func (m *MockEC2API) ReplaceNetworkAclAssociationRequest(arg0 *ec2.ReplaceNetworkAclAssociationInput) (*request.Request, *ec2.ReplaceNetworkAclAssociationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReplaceNetworkAclAssociationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ReplaceNetworkAclAssociationOutput)
-	return ret0, ret1
-}
-
-// ReplaceNetworkAclAssociationRequest indicates an expected call of ReplaceNetworkAclAssociationRequest.
-func (mr *MockEC2APIMockRecorder) ReplaceNetworkAclAssociationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclAssociationRequest), arg0)
-}
-
-// ReplaceNetworkAclAssociationWithContext mocks base method.
-func (m *MockEC2API) ReplaceNetworkAclAssociationWithContext(arg0 context.Context, arg1 *ec2.ReplaceNetworkAclAssociationInput, arg2 ...request.Option) (*ec2.ReplaceNetworkAclAssociationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ReplaceNetworkAclAssociationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ReplaceNetworkAclAssociationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReplaceNetworkAclAssociationWithContext indicates an expected call of ReplaceNetworkAclAssociationWithContext.
-func (mr *MockEC2APIMockRecorder) ReplaceNetworkAclAssociationWithContext(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, "ReplaceNetworkAclAssociationWithContext", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclAssociationWithContext), varargs...)
-}
-
-// ReplaceNetworkAclEntry mocks base method.
-func (m *MockEC2API) ReplaceNetworkAclEntry(arg0 *ec2.ReplaceNetworkAclEntryInput) (*ec2.ReplaceNetworkAclEntryOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReplaceNetworkAclEntry", arg0)
-	ret0, _ := ret[0].(*ec2.ReplaceNetworkAclEntryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReplaceNetworkAclEntry indicates an expected call of ReplaceNetworkAclEntry.
-func (mr *MockEC2APIMockRecorder) ReplaceNetworkAclEntry(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclEntry", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclEntry), arg0)
-}
-
-// ReplaceNetworkAclEntryRequest mocks base method.
-func (m *MockEC2API) ReplaceNetworkAclEntryRequest(arg0 *ec2.ReplaceNetworkAclEntryInput) (*request.Request, *ec2.ReplaceNetworkAclEntryOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReplaceNetworkAclEntryRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ReplaceNetworkAclEntryOutput)
-	return ret0, ret1
-}
-
-// ReplaceNetworkAclEntryRequest indicates an expected call of ReplaceNetworkAclEntryRequest.
-func (mr *MockEC2APIMockRecorder) ReplaceNetworkAclEntryRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclEntryRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclEntryRequest), arg0)
-}
-
-// ReplaceNetworkAclEntryWithContext mocks base method.
-func (m *MockEC2API) ReplaceNetworkAclEntryWithContext(arg0 context.Context, arg1 *ec2.ReplaceNetworkAclEntryInput, arg2 ...request.Option) (*ec2.ReplaceNetworkAclEntryOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ReplaceNetworkAclEntryWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ReplaceNetworkAclEntryOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReplaceNetworkAclEntryWithContext indicates an expected call of ReplaceNetworkAclEntryWithContext.
-func (mr *MockEC2APIMockRecorder) ReplaceNetworkAclEntryWithContext(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, "ReplaceNetworkAclEntryWithContext", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclEntryWithContext), varargs...)
-}
-
-// ReplaceRoute mocks base method.
-func (m *MockEC2API) ReplaceRoute(arg0 *ec2.ReplaceRouteInput) (*ec2.ReplaceRouteOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReplaceRoute", arg0)
-	ret0, _ := ret[0].(*ec2.ReplaceRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReplaceRoute indicates an expected call of ReplaceRoute.
-func (mr *MockEC2APIMockRecorder) ReplaceRoute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRoute", reflect.TypeOf((*MockEC2API)(nil).ReplaceRoute), arg0)
-}
-
-// ReplaceRouteRequest mocks base method.
-func (m *MockEC2API) ReplaceRouteRequest(arg0 *ec2.ReplaceRouteInput) (*request.Request, *ec2.ReplaceRouteOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReplaceRouteRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ReplaceRouteOutput)
-	return ret0, ret1
-}
-
-// ReplaceRouteRequest indicates an expected call of ReplaceRouteRequest.
-func (mr *MockEC2APIMockRecorder) ReplaceRouteRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRouteRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceRouteRequest), arg0)
-}
-
-// ReplaceRouteTableAssociation mocks base method.
-func (m *MockEC2API) ReplaceRouteTableAssociation(arg0 *ec2.ReplaceRouteTableAssociationInput) (*ec2.ReplaceRouteTableAssociationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReplaceRouteTableAssociation", arg0)
-	ret0, _ := ret[0].(*ec2.ReplaceRouteTableAssociationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReplaceRouteTableAssociation indicates an expected call of ReplaceRouteTableAssociation.
-func (mr *MockEC2APIMockRecorder) ReplaceRouteTableAssociation(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRouteTableAssociation", reflect.TypeOf((*MockEC2API)(nil).ReplaceRouteTableAssociation), arg0)
-}
-
-// ReplaceRouteTableAssociationRequest mocks base method.
-func (m *MockEC2API) ReplaceRouteTableAssociationRequest(arg0 *ec2.ReplaceRouteTableAssociationInput) (*request.Request, *ec2.ReplaceRouteTableAssociationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReplaceRouteTableAssociationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ReplaceRouteTableAssociationOutput)
-	return ret0, ret1
-}
-
-// ReplaceRouteTableAssociationRequest indicates an expected call of ReplaceRouteTableAssociationRequest.
-func (mr *MockEC2APIMockRecorder) ReplaceRouteTableAssociationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRouteTableAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceRouteTableAssociationRequest), arg0)
-}
-
-// ReplaceRouteTableAssociationWithContext mocks base method.
-func (m *MockEC2API) ReplaceRouteTableAssociationWithContext(arg0 context.Context, arg1 *ec2.ReplaceRouteTableAssociationInput, arg2 ...request.Option) (*ec2.ReplaceRouteTableAssociationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ReplaceRouteTableAssociationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ReplaceRouteTableAssociationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReplaceRouteTableAssociationWithContext indicates an expected call of ReplaceRouteTableAssociationWithContext.
-func (mr *MockEC2APIMockRecorder) ReplaceRouteTableAssociationWithContext(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, "ReplaceRouteTableAssociationWithContext", reflect.TypeOf((*MockEC2API)(nil).ReplaceRouteTableAssociationWithContext), varargs...)
-}
-
-// ReplaceRouteWithContext mocks base method.
-func (m *MockEC2API) ReplaceRouteWithContext(arg0 context.Context, arg1 *ec2.ReplaceRouteInput, arg2 ...request.Option) (*ec2.ReplaceRouteOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ReplaceRouteWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ReplaceRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReplaceRouteWithContext indicates an expected call of ReplaceRouteWithContext.
-func (mr *MockEC2APIMockRecorder) ReplaceRouteWithContext(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, "ReplaceRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).ReplaceRouteWithContext), varargs...)
-}
-
-// ReplaceTransitGatewayRoute mocks base method.
-func (m *MockEC2API) ReplaceTransitGatewayRoute(arg0 *ec2.ReplaceTransitGatewayRouteInput) (*ec2.ReplaceTransitGatewayRouteOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReplaceTransitGatewayRoute", arg0)
-	ret0, _ := ret[0].(*ec2.ReplaceTransitGatewayRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReplaceTransitGatewayRoute indicates an expected call of ReplaceTransitGatewayRoute.
-func (mr *MockEC2APIMockRecorder) ReplaceTransitGatewayRoute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceTransitGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).ReplaceTransitGatewayRoute), arg0)
-}
-
-// ReplaceTransitGatewayRouteRequest mocks base method.
-func (m *MockEC2API) ReplaceTransitGatewayRouteRequest(arg0 *ec2.ReplaceTransitGatewayRouteInput) (*request.Request, *ec2.ReplaceTransitGatewayRouteOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReplaceTransitGatewayRouteRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ReplaceTransitGatewayRouteOutput)
-	return ret0, ret1
-}
-
-// ReplaceTransitGatewayRouteRequest indicates an expected call of ReplaceTransitGatewayRouteRequest.
-func (mr *MockEC2APIMockRecorder) ReplaceTransitGatewayRouteRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceTransitGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceTransitGatewayRouteRequest), arg0)
-}
-
-// ReplaceTransitGatewayRouteWithContext mocks base method.
-func (m *MockEC2API) ReplaceTransitGatewayRouteWithContext(arg0 context.Context, arg1 *ec2.ReplaceTransitGatewayRouteInput, arg2 ...request.Option) (*ec2.ReplaceTransitGatewayRouteOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ReplaceTransitGatewayRouteWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ReplaceTransitGatewayRouteOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReplaceTransitGatewayRouteWithContext indicates an expected call of ReplaceTransitGatewayRouteWithContext.
-func (mr *MockEC2APIMockRecorder) ReplaceTransitGatewayRouteWithContext(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, "ReplaceTransitGatewayRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).ReplaceTransitGatewayRouteWithContext), varargs...)
-}
-
-// ReplaceVpnTunnel mocks base method.
-func (m *MockEC2API) ReplaceVpnTunnel(arg0 *ec2.ReplaceVpnTunnelInput) (*ec2.ReplaceVpnTunnelOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReplaceVpnTunnel", arg0)
-	ret0, _ := ret[0].(*ec2.ReplaceVpnTunnelOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReplaceVpnTunnel indicates an expected call of ReplaceVpnTunnel.
-func (mr *MockEC2APIMockRecorder) ReplaceVpnTunnel(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceVpnTunnel", reflect.TypeOf((*MockEC2API)(nil).ReplaceVpnTunnel), arg0)
-}
-
-// ReplaceVpnTunnelRequest mocks base method.
-func (m *MockEC2API) ReplaceVpnTunnelRequest(arg0 *ec2.ReplaceVpnTunnelInput) (*request.Request, *ec2.ReplaceVpnTunnelOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReplaceVpnTunnelRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ReplaceVpnTunnelOutput)
-	return ret0, ret1
-}
-
-// ReplaceVpnTunnelRequest indicates an expected call of ReplaceVpnTunnelRequest.
-func (mr *MockEC2APIMockRecorder) ReplaceVpnTunnelRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceVpnTunnelRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceVpnTunnelRequest), arg0)
-}
-
-// ReplaceVpnTunnelWithContext mocks base method.
-func (m *MockEC2API) ReplaceVpnTunnelWithContext(arg0 context.Context, arg1 *ec2.ReplaceVpnTunnelInput, arg2 ...request.Option) (*ec2.ReplaceVpnTunnelOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ReplaceVpnTunnelWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ReplaceVpnTunnelOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReplaceVpnTunnelWithContext indicates an expected call of ReplaceVpnTunnelWithContext.
-func (mr *MockEC2APIMockRecorder) ReplaceVpnTunnelWithContext(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, "ReplaceVpnTunnelWithContext", reflect.TypeOf((*MockEC2API)(nil).ReplaceVpnTunnelWithContext), varargs...)
-}
-
-// ReportInstanceStatus mocks base method.
-func (m *MockEC2API) ReportInstanceStatus(arg0 *ec2.ReportInstanceStatusInput) (*ec2.ReportInstanceStatusOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReportInstanceStatus", arg0)
-	ret0, _ := ret[0].(*ec2.ReportInstanceStatusOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReportInstanceStatus indicates an expected call of ReportInstanceStatus.
-func (mr *MockEC2APIMockRecorder) ReportInstanceStatus(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportInstanceStatus", reflect.TypeOf((*MockEC2API)(nil).ReportInstanceStatus), arg0)
-}
-
-// ReportInstanceStatusRequest mocks base method.
-func (m *MockEC2API) ReportInstanceStatusRequest(arg0 *ec2.ReportInstanceStatusInput) (*request.Request, *ec2.ReportInstanceStatusOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReportInstanceStatusRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ReportInstanceStatusOutput)
-	return ret0, ret1
-}
-
-// ReportInstanceStatusRequest indicates an expected call of ReportInstanceStatusRequest.
-func (mr *MockEC2APIMockRecorder) ReportInstanceStatusRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportInstanceStatusRequest", reflect.TypeOf((*MockEC2API)(nil).ReportInstanceStatusRequest), arg0)
-}
-
-// ReportInstanceStatusWithContext mocks base method.
-func (m *MockEC2API) ReportInstanceStatusWithContext(arg0 context.Context, arg1 *ec2.ReportInstanceStatusInput, arg2 ...request.Option) (*ec2.ReportInstanceStatusOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ReportInstanceStatusWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ReportInstanceStatusOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReportInstanceStatusWithContext indicates an expected call of ReportInstanceStatusWithContext.
-func (mr *MockEC2APIMockRecorder) ReportInstanceStatusWithContext(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, "ReportInstanceStatusWithContext", reflect.TypeOf((*MockEC2API)(nil).ReportInstanceStatusWithContext), varargs...)
-}
-
-// RequestSpotFleet mocks base method.
-func (m *MockEC2API) RequestSpotFleet(arg0 *ec2.RequestSpotFleetInput) (*ec2.RequestSpotFleetOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RequestSpotFleet", arg0)
-	ret0, _ := ret[0].(*ec2.RequestSpotFleetOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RequestSpotFleet indicates an expected call of RequestSpotFleet.
-func (mr *MockEC2APIMockRecorder) RequestSpotFleet(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotFleet", reflect.TypeOf((*MockEC2API)(nil).RequestSpotFleet), arg0)
-}
-
-// RequestSpotFleetRequest mocks base method.
-func (m *MockEC2API) RequestSpotFleetRequest(arg0 *ec2.RequestSpotFleetInput) (*request.Request, *ec2.RequestSpotFleetOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RequestSpotFleetRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.RequestSpotFleetOutput)
-	return ret0, ret1
-}
-
-// RequestSpotFleetRequest indicates an expected call of RequestSpotFleetRequest.
-func (mr *MockEC2APIMockRecorder) RequestSpotFleetRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotFleetRequest", reflect.TypeOf((*MockEC2API)(nil).RequestSpotFleetRequest), arg0)
-}
-
-// RequestSpotFleetWithContext mocks base method.
-func (m *MockEC2API) RequestSpotFleetWithContext(arg0 context.Context, arg1 *ec2.RequestSpotFleetInput, arg2 ...request.Option) (*ec2.RequestSpotFleetOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RequestSpotFleetWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.RequestSpotFleetOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RequestSpotFleetWithContext indicates an expected call of RequestSpotFleetWithContext.
-func (mr *MockEC2APIMockRecorder) RequestSpotFleetWithContext(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, "RequestSpotFleetWithContext", reflect.TypeOf((*MockEC2API)(nil).RequestSpotFleetWithContext), varargs...)
-}
-
-// RequestSpotInstances mocks base method.
-func (m *MockEC2API) RequestSpotInstances(arg0 *ec2.RequestSpotInstancesInput) (*ec2.RequestSpotInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RequestSpotInstances", arg0)
-	ret0, _ := ret[0].(*ec2.RequestSpotInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RequestSpotInstances indicates an expected call of RequestSpotInstances.
-func (mr *MockEC2APIMockRecorder) RequestSpotInstances(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotInstances", reflect.TypeOf((*MockEC2API)(nil).RequestSpotInstances), arg0)
-}
-
-// RequestSpotInstancesRequest mocks base method.
-func (m *MockEC2API) RequestSpotInstancesRequest(arg0 *ec2.RequestSpotInstancesInput) (*request.Request, *ec2.RequestSpotInstancesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RequestSpotInstancesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.RequestSpotInstancesOutput)
-	return ret0, ret1
-}
-
-// RequestSpotInstancesRequest indicates an expected call of RequestSpotInstancesRequest.
-func (mr *MockEC2APIMockRecorder) RequestSpotInstancesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).RequestSpotInstancesRequest), arg0)
-}
-
-// RequestSpotInstancesWithContext mocks base method.
-func (m *MockEC2API) RequestSpotInstancesWithContext(arg0 context.Context, arg1 *ec2.RequestSpotInstancesInput, arg2 ...request.Option) (*ec2.RequestSpotInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RequestSpotInstancesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.RequestSpotInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RequestSpotInstancesWithContext indicates an expected call of RequestSpotInstancesWithContext.
-func (mr *MockEC2APIMockRecorder) RequestSpotInstancesWithContext(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, "RequestSpotInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).RequestSpotInstancesWithContext), varargs...)
-}
-
-// ResetAddressAttribute mocks base method.
-func (m *MockEC2API) ResetAddressAttribute(arg0 *ec2.ResetAddressAttributeInput) (*ec2.ResetAddressAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResetAddressAttribute", arg0)
-	ret0, _ := ret[0].(*ec2.ResetAddressAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ResetAddressAttribute indicates an expected call of ResetAddressAttribute.
-func (mr *MockEC2APIMockRecorder) ResetAddressAttribute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetAddressAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetAddressAttribute), arg0)
-}
-
-// ResetAddressAttributeRequest mocks base method.
-func (m *MockEC2API) ResetAddressAttributeRequest(arg0 *ec2.ResetAddressAttributeInput) (*request.Request, *ec2.ResetAddressAttributeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResetAddressAttributeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ResetAddressAttributeOutput)
-	return ret0, ret1
-}
-
-// ResetAddressAttributeRequest indicates an expected call of ResetAddressAttributeRequest.
-func (mr *MockEC2APIMockRecorder) ResetAddressAttributeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetAddressAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetAddressAttributeRequest), arg0)
-}
-
-// ResetAddressAttributeWithContext mocks base method.
-func (m *MockEC2API) ResetAddressAttributeWithContext(arg0 context.Context, arg1 *ec2.ResetAddressAttributeInput, arg2 ...request.Option) (*ec2.ResetAddressAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ResetAddressAttributeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ResetAddressAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ResetAddressAttributeWithContext indicates an expected call of ResetAddressAttributeWithContext.
-func (mr *MockEC2APIMockRecorder) ResetAddressAttributeWithContext(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, "ResetAddressAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ResetAddressAttributeWithContext), varargs...)
-}
-
-// ResetEbsDefaultKmsKeyId mocks base method.
-func (m *MockEC2API) ResetEbsDefaultKmsKeyId(arg0 *ec2.ResetEbsDefaultKmsKeyIdInput) (*ec2.ResetEbsDefaultKmsKeyIdOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResetEbsDefaultKmsKeyId", arg0)
-	ret0, _ := ret[0].(*ec2.ResetEbsDefaultKmsKeyIdOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ResetEbsDefaultKmsKeyId indicates an expected call of ResetEbsDefaultKmsKeyId.
-func (mr *MockEC2APIMockRecorder) ResetEbsDefaultKmsKeyId(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetEbsDefaultKmsKeyId", reflect.TypeOf((*MockEC2API)(nil).ResetEbsDefaultKmsKeyId), arg0)
-}
-
-// ResetEbsDefaultKmsKeyIdRequest mocks base method.
-func (m *MockEC2API) ResetEbsDefaultKmsKeyIdRequest(arg0 *ec2.ResetEbsDefaultKmsKeyIdInput) (*request.Request, *ec2.ResetEbsDefaultKmsKeyIdOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResetEbsDefaultKmsKeyIdRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ResetEbsDefaultKmsKeyIdOutput)
-	return ret0, ret1
-}
-
-// ResetEbsDefaultKmsKeyIdRequest indicates an expected call of ResetEbsDefaultKmsKeyIdRequest.
-func (mr *MockEC2APIMockRecorder) ResetEbsDefaultKmsKeyIdRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetEbsDefaultKmsKeyIdRequest", reflect.TypeOf((*MockEC2API)(nil).ResetEbsDefaultKmsKeyIdRequest), arg0)
-}
-
-// ResetEbsDefaultKmsKeyIdWithContext mocks base method.
-func (m *MockEC2API) ResetEbsDefaultKmsKeyIdWithContext(arg0 context.Context, arg1 *ec2.ResetEbsDefaultKmsKeyIdInput, arg2 ...request.Option) (*ec2.ResetEbsDefaultKmsKeyIdOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ResetEbsDefaultKmsKeyIdWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ResetEbsDefaultKmsKeyIdOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ResetEbsDefaultKmsKeyIdWithContext indicates an expected call of ResetEbsDefaultKmsKeyIdWithContext.
-func (mr *MockEC2APIMockRecorder) ResetEbsDefaultKmsKeyIdWithContext(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, "ResetEbsDefaultKmsKeyIdWithContext", reflect.TypeOf((*MockEC2API)(nil).ResetEbsDefaultKmsKeyIdWithContext), varargs...)
-}
-
-// ResetFpgaImageAttribute mocks base method.
-func (m *MockEC2API) ResetFpgaImageAttribute(arg0 *ec2.ResetFpgaImageAttributeInput) (*ec2.ResetFpgaImageAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResetFpgaImageAttribute", arg0)
-	ret0, _ := ret[0].(*ec2.ResetFpgaImageAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ResetFpgaImageAttribute indicates an expected call of ResetFpgaImageAttribute.
-func (mr *MockEC2APIMockRecorder) ResetFpgaImageAttribute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetFpgaImageAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetFpgaImageAttribute), arg0)
-}
-
-// ResetFpgaImageAttributeRequest mocks base method.
-func (m *MockEC2API) ResetFpgaImageAttributeRequest(arg0 *ec2.ResetFpgaImageAttributeInput) (*request.Request, *ec2.ResetFpgaImageAttributeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResetFpgaImageAttributeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ResetFpgaImageAttributeOutput)
-	return ret0, ret1
-}
-
-// ResetFpgaImageAttributeRequest indicates an expected call of ResetFpgaImageAttributeRequest.
-func (mr *MockEC2APIMockRecorder) ResetFpgaImageAttributeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetFpgaImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetFpgaImageAttributeRequest), arg0)
-}
-
-// ResetFpgaImageAttributeWithContext mocks base method.
-func (m *MockEC2API) ResetFpgaImageAttributeWithContext(arg0 context.Context, arg1 *ec2.ResetFpgaImageAttributeInput, arg2 ...request.Option) (*ec2.ResetFpgaImageAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ResetFpgaImageAttributeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ResetFpgaImageAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ResetFpgaImageAttributeWithContext indicates an expected call of ResetFpgaImageAttributeWithContext.
-func (mr *MockEC2APIMockRecorder) ResetFpgaImageAttributeWithContext(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, "ResetFpgaImageAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ResetFpgaImageAttributeWithContext), varargs...)
-}
-
-// ResetImageAttribute mocks base method.
-func (m *MockEC2API) ResetImageAttribute(arg0 *ec2.ResetImageAttributeInput) (*ec2.ResetImageAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResetImageAttribute", arg0)
-	ret0, _ := ret[0].(*ec2.ResetImageAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ResetImageAttribute indicates an expected call of ResetImageAttribute.
-func (mr *MockEC2APIMockRecorder) ResetImageAttribute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetImageAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetImageAttribute), arg0)
-}
-
-// ResetImageAttributeRequest mocks base method.
-func (m *MockEC2API) ResetImageAttributeRequest(arg0 *ec2.ResetImageAttributeInput) (*request.Request, *ec2.ResetImageAttributeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResetImageAttributeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ResetImageAttributeOutput)
-	return ret0, ret1
-}
-
-// ResetImageAttributeRequest indicates an expected call of ResetImageAttributeRequest.
-func (mr *MockEC2APIMockRecorder) ResetImageAttributeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetImageAttributeRequest), arg0)
-}
-
-// ResetImageAttributeWithContext mocks base method.
-func (m *MockEC2API) ResetImageAttributeWithContext(arg0 context.Context, arg1 *ec2.ResetImageAttributeInput, arg2 ...request.Option) (*ec2.ResetImageAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ResetImageAttributeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ResetImageAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ResetImageAttributeWithContext indicates an expected call of ResetImageAttributeWithContext.
-func (mr *MockEC2APIMockRecorder) ResetImageAttributeWithContext(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, "ResetImageAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ResetImageAttributeWithContext), varargs...)
-}
-
-// ResetInstanceAttribute mocks base method.
-func (m *MockEC2API) ResetInstanceAttribute(arg0 *ec2.ResetInstanceAttributeInput) (*ec2.ResetInstanceAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResetInstanceAttribute", arg0)
-	ret0, _ := ret[0].(*ec2.ResetInstanceAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ResetInstanceAttribute indicates an expected call of ResetInstanceAttribute.
-func (mr *MockEC2APIMockRecorder) ResetInstanceAttribute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetInstanceAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetInstanceAttribute), arg0)
-}
-
-// ResetInstanceAttributeRequest mocks base method.
-func (m *MockEC2API) ResetInstanceAttributeRequest(arg0 *ec2.ResetInstanceAttributeInput) (*request.Request, *ec2.ResetInstanceAttributeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResetInstanceAttributeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ResetInstanceAttributeOutput)
-	return ret0, ret1
-}
-
-// ResetInstanceAttributeRequest indicates an expected call of ResetInstanceAttributeRequest.
-func (mr *MockEC2APIMockRecorder) ResetInstanceAttributeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetInstanceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetInstanceAttributeRequest), arg0)
-}
-
-// ResetInstanceAttributeWithContext mocks base method.
-func (m *MockEC2API) ResetInstanceAttributeWithContext(arg0 context.Context, arg1 *ec2.ResetInstanceAttributeInput, arg2 ...request.Option) (*ec2.ResetInstanceAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ResetInstanceAttributeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ResetInstanceAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ResetInstanceAttributeWithContext indicates an expected call of ResetInstanceAttributeWithContext.
-func (mr *MockEC2APIMockRecorder) ResetInstanceAttributeWithContext(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, "ResetInstanceAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ResetInstanceAttributeWithContext), varargs...)
-}
-
-// ResetNetworkInterfaceAttribute mocks base method.
-func (m *MockEC2API) ResetNetworkInterfaceAttribute(arg0 *ec2.ResetNetworkInterfaceAttributeInput) (*ec2.ResetNetworkInterfaceAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResetNetworkInterfaceAttribute", arg0)
-	ret0, _ := ret[0].(*ec2.ResetNetworkInterfaceAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ResetNetworkInterfaceAttribute indicates an expected call of ResetNetworkInterfaceAttribute.
-func (mr *MockEC2APIMockRecorder) ResetNetworkInterfaceAttribute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetNetworkInterfaceAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetNetworkInterfaceAttribute), arg0)
-}
-
-// ResetNetworkInterfaceAttributeRequest mocks base method.
-func (m *MockEC2API) ResetNetworkInterfaceAttributeRequest(arg0 *ec2.ResetNetworkInterfaceAttributeInput) (*request.Request, *ec2.ResetNetworkInterfaceAttributeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResetNetworkInterfaceAttributeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ResetNetworkInterfaceAttributeOutput)
-	return ret0, ret1
-}
-
-// ResetNetworkInterfaceAttributeRequest indicates an expected call of ResetNetworkInterfaceAttributeRequest.
-func (mr *MockEC2APIMockRecorder) ResetNetworkInterfaceAttributeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetNetworkInterfaceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetNetworkInterfaceAttributeRequest), arg0)
-}
-
-// ResetNetworkInterfaceAttributeWithContext mocks base method.
-func (m *MockEC2API) ResetNetworkInterfaceAttributeWithContext(arg0 context.Context, arg1 *ec2.ResetNetworkInterfaceAttributeInput, arg2 ...request.Option) (*ec2.ResetNetworkInterfaceAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ResetNetworkInterfaceAttributeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ResetNetworkInterfaceAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ResetNetworkInterfaceAttributeWithContext indicates an expected call of ResetNetworkInterfaceAttributeWithContext.
-func (mr *MockEC2APIMockRecorder) ResetNetworkInterfaceAttributeWithContext(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, "ResetNetworkInterfaceAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ResetNetworkInterfaceAttributeWithContext), varargs...)
-}
-
-// ResetSnapshotAttribute mocks base method.
-func (m *MockEC2API) ResetSnapshotAttribute(arg0 *ec2.ResetSnapshotAttributeInput) (*ec2.ResetSnapshotAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResetSnapshotAttribute", arg0)
-	ret0, _ := ret[0].(*ec2.ResetSnapshotAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ResetSnapshotAttribute indicates an expected call of ResetSnapshotAttribute.
-func (mr *MockEC2APIMockRecorder) ResetSnapshotAttribute(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetSnapshotAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetSnapshotAttribute), arg0)
-}
-
-// ResetSnapshotAttributeRequest mocks base method.
-func (m *MockEC2API) ResetSnapshotAttributeRequest(arg0 *ec2.ResetSnapshotAttributeInput) (*request.Request, *ec2.ResetSnapshotAttributeOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResetSnapshotAttributeRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.ResetSnapshotAttributeOutput)
-	return ret0, ret1
-}
-
-// ResetSnapshotAttributeRequest indicates an expected call of ResetSnapshotAttributeRequest.
-func (mr *MockEC2APIMockRecorder) ResetSnapshotAttributeRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetSnapshotAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetSnapshotAttributeRequest), arg0)
-}
-
-// ResetSnapshotAttributeWithContext mocks base method.
-func (m *MockEC2API) ResetSnapshotAttributeWithContext(arg0 context.Context, arg1 *ec2.ResetSnapshotAttributeInput, arg2 ...request.Option) (*ec2.ResetSnapshotAttributeOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ResetSnapshotAttributeWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.ResetSnapshotAttributeOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ResetSnapshotAttributeWithContext indicates an expected call of ResetSnapshotAttributeWithContext.
-func (mr *MockEC2APIMockRecorder) ResetSnapshotAttributeWithContext(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, "ResetSnapshotAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ResetSnapshotAttributeWithContext), varargs...)
-}
-
-// RestoreAddressToClassic mocks base method.
-func (m *MockEC2API) RestoreAddressToClassic(arg0 *ec2.RestoreAddressToClassicInput) (*ec2.RestoreAddressToClassicOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RestoreAddressToClassic", arg0)
-	ret0, _ := ret[0].(*ec2.RestoreAddressToClassicOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RestoreAddressToClassic indicates an expected call of RestoreAddressToClassic.
-func (mr *MockEC2APIMockRecorder) RestoreAddressToClassic(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreAddressToClassic", reflect.TypeOf((*MockEC2API)(nil).RestoreAddressToClassic), arg0)
-}
-
-// RestoreAddressToClassicRequest mocks base method.
-func (m *MockEC2API) RestoreAddressToClassicRequest(arg0 *ec2.RestoreAddressToClassicInput) (*request.Request, *ec2.RestoreAddressToClassicOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RestoreAddressToClassicRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.RestoreAddressToClassicOutput)
-	return ret0, ret1
-}
-
-// RestoreAddressToClassicRequest indicates an expected call of RestoreAddressToClassicRequest.
-func (mr *MockEC2APIMockRecorder) RestoreAddressToClassicRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreAddressToClassicRequest", reflect.TypeOf((*MockEC2API)(nil).RestoreAddressToClassicRequest), arg0)
-}
-
-// RestoreAddressToClassicWithContext mocks base method.
-func (m *MockEC2API) RestoreAddressToClassicWithContext(arg0 context.Context, arg1 *ec2.RestoreAddressToClassicInput, arg2 ...request.Option) (*ec2.RestoreAddressToClassicOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RestoreAddressToClassicWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.RestoreAddressToClassicOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RestoreAddressToClassicWithContext indicates an expected call of RestoreAddressToClassicWithContext.
-func (mr *MockEC2APIMockRecorder) RestoreAddressToClassicWithContext(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, "RestoreAddressToClassicWithContext", reflect.TypeOf((*MockEC2API)(nil).RestoreAddressToClassicWithContext), varargs...)
-}
-
-// RestoreImageFromRecycleBin mocks base method.
-func (m *MockEC2API) RestoreImageFromRecycleBin(arg0 *ec2.RestoreImageFromRecycleBinInput) (*ec2.RestoreImageFromRecycleBinOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RestoreImageFromRecycleBin", arg0)
-	ret0, _ := ret[0].(*ec2.RestoreImageFromRecycleBinOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RestoreImageFromRecycleBin indicates an expected call of RestoreImageFromRecycleBin.
-func (mr *MockEC2APIMockRecorder) RestoreImageFromRecycleBin(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreImageFromRecycleBin", reflect.TypeOf((*MockEC2API)(nil).RestoreImageFromRecycleBin), arg0)
-}
-
-// RestoreImageFromRecycleBinRequest mocks base method.
-func (m *MockEC2API) RestoreImageFromRecycleBinRequest(arg0 *ec2.RestoreImageFromRecycleBinInput) (*request.Request, *ec2.RestoreImageFromRecycleBinOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RestoreImageFromRecycleBinRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.RestoreImageFromRecycleBinOutput)
-	return ret0, ret1
-}
-
-// RestoreImageFromRecycleBinRequest indicates an expected call of RestoreImageFromRecycleBinRequest.
-func (mr *MockEC2APIMockRecorder) RestoreImageFromRecycleBinRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreImageFromRecycleBinRequest", reflect.TypeOf((*MockEC2API)(nil).RestoreImageFromRecycleBinRequest), arg0)
-}
-
-// RestoreImageFromRecycleBinWithContext mocks base method.
-func (m *MockEC2API) RestoreImageFromRecycleBinWithContext(arg0 context.Context, arg1 *ec2.RestoreImageFromRecycleBinInput, arg2 ...request.Option) (*ec2.RestoreImageFromRecycleBinOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RestoreImageFromRecycleBinWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.RestoreImageFromRecycleBinOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RestoreImageFromRecycleBinWithContext indicates an expected call of RestoreImageFromRecycleBinWithContext.
-func (mr *MockEC2APIMockRecorder) RestoreImageFromRecycleBinWithContext(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, "RestoreImageFromRecycleBinWithContext", reflect.TypeOf((*MockEC2API)(nil).RestoreImageFromRecycleBinWithContext), varargs...)
-}
-
-// RestoreManagedPrefixListVersion mocks base method.
-func (m *MockEC2API) RestoreManagedPrefixListVersion(arg0 *ec2.RestoreManagedPrefixListVersionInput) (*ec2.RestoreManagedPrefixListVersionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RestoreManagedPrefixListVersion", arg0)
-	ret0, _ := ret[0].(*ec2.RestoreManagedPrefixListVersionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RestoreManagedPrefixListVersion indicates an expected call of RestoreManagedPrefixListVersion.
-func (mr *MockEC2APIMockRecorder) RestoreManagedPrefixListVersion(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreManagedPrefixListVersion", reflect.TypeOf((*MockEC2API)(nil).RestoreManagedPrefixListVersion), arg0)
-}
-
-// RestoreManagedPrefixListVersionRequest mocks base method.
-func (m *MockEC2API) RestoreManagedPrefixListVersionRequest(arg0 *ec2.RestoreManagedPrefixListVersionInput) (*request.Request, *ec2.RestoreManagedPrefixListVersionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RestoreManagedPrefixListVersionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.RestoreManagedPrefixListVersionOutput)
-	return ret0, ret1
-}
-
-// RestoreManagedPrefixListVersionRequest indicates an expected call of RestoreManagedPrefixListVersionRequest.
-func (mr *MockEC2APIMockRecorder) RestoreManagedPrefixListVersionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreManagedPrefixListVersionRequest", reflect.TypeOf((*MockEC2API)(nil).RestoreManagedPrefixListVersionRequest), arg0)
-}
-
-// RestoreManagedPrefixListVersionWithContext mocks base method.
-func (m *MockEC2API) RestoreManagedPrefixListVersionWithContext(arg0 context.Context, arg1 *ec2.RestoreManagedPrefixListVersionInput, arg2 ...request.Option) (*ec2.RestoreManagedPrefixListVersionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RestoreManagedPrefixListVersionWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.RestoreManagedPrefixListVersionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RestoreManagedPrefixListVersionWithContext indicates an expected call of RestoreManagedPrefixListVersionWithContext.
-func (mr *MockEC2APIMockRecorder) RestoreManagedPrefixListVersionWithContext(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, "RestoreManagedPrefixListVersionWithContext", reflect.TypeOf((*MockEC2API)(nil).RestoreManagedPrefixListVersionWithContext), varargs...)
-}
-
-// RestoreSnapshotFromRecycleBin mocks base method.
-func (m *MockEC2API) RestoreSnapshotFromRecycleBin(arg0 *ec2.RestoreSnapshotFromRecycleBinInput) (*ec2.RestoreSnapshotFromRecycleBinOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RestoreSnapshotFromRecycleBin", arg0)
-	ret0, _ := ret[0].(*ec2.RestoreSnapshotFromRecycleBinOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RestoreSnapshotFromRecycleBin indicates an expected call of RestoreSnapshotFromRecycleBin.
-func (mr *MockEC2APIMockRecorder) RestoreSnapshotFromRecycleBin(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreSnapshotFromRecycleBin", reflect.TypeOf((*MockEC2API)(nil).RestoreSnapshotFromRecycleBin), arg0)
-}
-
-// RestoreSnapshotFromRecycleBinRequest mocks base method.
-func (m *MockEC2API) RestoreSnapshotFromRecycleBinRequest(arg0 *ec2.RestoreSnapshotFromRecycleBinInput) (*request.Request, *ec2.RestoreSnapshotFromRecycleBinOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RestoreSnapshotFromRecycleBinRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.RestoreSnapshotFromRecycleBinOutput)
-	return ret0, ret1
-}
-
-// RestoreSnapshotFromRecycleBinRequest indicates an expected call of RestoreSnapshotFromRecycleBinRequest.
-func (mr *MockEC2APIMockRecorder) RestoreSnapshotFromRecycleBinRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreSnapshotFromRecycleBinRequest", reflect.TypeOf((*MockEC2API)(nil).RestoreSnapshotFromRecycleBinRequest), arg0)
-}
-
-// RestoreSnapshotFromRecycleBinWithContext mocks base method.
-func (m *MockEC2API) RestoreSnapshotFromRecycleBinWithContext(arg0 context.Context, arg1 *ec2.RestoreSnapshotFromRecycleBinInput, arg2 ...request.Option) (*ec2.RestoreSnapshotFromRecycleBinOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RestoreSnapshotFromRecycleBinWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.RestoreSnapshotFromRecycleBinOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RestoreSnapshotFromRecycleBinWithContext indicates an expected call of RestoreSnapshotFromRecycleBinWithContext.
-func (mr *MockEC2APIMockRecorder) RestoreSnapshotFromRecycleBinWithContext(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, "RestoreSnapshotFromRecycleBinWithContext", reflect.TypeOf((*MockEC2API)(nil).RestoreSnapshotFromRecycleBinWithContext), varargs...)
-}
-
-// RestoreSnapshotTier mocks base method.
-func (m *MockEC2API) RestoreSnapshotTier(arg0 *ec2.RestoreSnapshotTierInput) (*ec2.RestoreSnapshotTierOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RestoreSnapshotTier", arg0)
-	ret0, _ := ret[0].(*ec2.RestoreSnapshotTierOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RestoreSnapshotTier indicates an expected call of RestoreSnapshotTier.
-func (mr *MockEC2APIMockRecorder) RestoreSnapshotTier(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreSnapshotTier", reflect.TypeOf((*MockEC2API)(nil).RestoreSnapshotTier), arg0)
-}
-
-// RestoreSnapshotTierRequest mocks base method.
-func (m *MockEC2API) RestoreSnapshotTierRequest(arg0 *ec2.RestoreSnapshotTierInput) (*request.Request, *ec2.RestoreSnapshotTierOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RestoreSnapshotTierRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.RestoreSnapshotTierOutput)
-	return ret0, ret1
-}
-
-// RestoreSnapshotTierRequest indicates an expected call of RestoreSnapshotTierRequest.
-func (mr *MockEC2APIMockRecorder) RestoreSnapshotTierRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreSnapshotTierRequest", reflect.TypeOf((*MockEC2API)(nil).RestoreSnapshotTierRequest), arg0)
-}
-
-// RestoreSnapshotTierWithContext mocks base method.
-func (m *MockEC2API) RestoreSnapshotTierWithContext(arg0 context.Context, arg1 *ec2.RestoreSnapshotTierInput, arg2 ...request.Option) (*ec2.RestoreSnapshotTierOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RestoreSnapshotTierWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.RestoreSnapshotTierOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RestoreSnapshotTierWithContext indicates an expected call of RestoreSnapshotTierWithContext.
-func (mr *MockEC2APIMockRecorder) RestoreSnapshotTierWithContext(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, "RestoreSnapshotTierWithContext", reflect.TypeOf((*MockEC2API)(nil).RestoreSnapshotTierWithContext), varargs...)
-}
-
-// RevokeClientVpnIngress mocks base method.
-func (m *MockEC2API) RevokeClientVpnIngress(arg0 *ec2.RevokeClientVpnIngressInput) (*ec2.RevokeClientVpnIngressOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RevokeClientVpnIngress", arg0)
-	ret0, _ := ret[0].(*ec2.RevokeClientVpnIngressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RevokeClientVpnIngress indicates an expected call of RevokeClientVpnIngress.
-func (mr *MockEC2APIMockRecorder) RevokeClientVpnIngress(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeClientVpnIngress", reflect.TypeOf((*MockEC2API)(nil).RevokeClientVpnIngress), arg0)
-}
-
-// RevokeClientVpnIngressRequest mocks base method.
-func (m *MockEC2API) RevokeClientVpnIngressRequest(arg0 *ec2.RevokeClientVpnIngressInput) (*request.Request, *ec2.RevokeClientVpnIngressOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RevokeClientVpnIngressRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.RevokeClientVpnIngressOutput)
-	return ret0, ret1
-}
-
-// RevokeClientVpnIngressRequest indicates an expected call of RevokeClientVpnIngressRequest.
-func (mr *MockEC2APIMockRecorder) RevokeClientVpnIngressRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeClientVpnIngressRequest", reflect.TypeOf((*MockEC2API)(nil).RevokeClientVpnIngressRequest), arg0)
-}
-
-// RevokeClientVpnIngressWithContext mocks base method.
-func (m *MockEC2API) RevokeClientVpnIngressWithContext(arg0 context.Context, arg1 *ec2.RevokeClientVpnIngressInput, arg2 ...request.Option) (*ec2.RevokeClientVpnIngressOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RevokeClientVpnIngressWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.RevokeClientVpnIngressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RevokeClientVpnIngressWithContext indicates an expected call of RevokeClientVpnIngressWithContext.
-func (mr *MockEC2APIMockRecorder) RevokeClientVpnIngressWithContext(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, "RevokeClientVpnIngressWithContext", reflect.TypeOf((*MockEC2API)(nil).RevokeClientVpnIngressWithContext), varargs...)
-}
-
-// RevokeSecurityGroupEgress mocks base method.
-func (m *MockEC2API) RevokeSecurityGroupEgress(arg0 *ec2.RevokeSecurityGroupEgressInput) (*ec2.RevokeSecurityGroupEgressOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RevokeSecurityGroupEgress", arg0)
-	ret0, _ := ret[0].(*ec2.RevokeSecurityGroupEgressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RevokeSecurityGroupEgress indicates an expected call of RevokeSecurityGroupEgress.
-func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupEgress(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupEgress", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupEgress), arg0)
-}
-
-// RevokeSecurityGroupEgressRequest mocks base method.
-func (m *MockEC2API) RevokeSecurityGroupEgressRequest(arg0 *ec2.RevokeSecurityGroupEgressInput) (*request.Request, *ec2.RevokeSecurityGroupEgressOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RevokeSecurityGroupEgressRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.RevokeSecurityGroupEgressOutput)
-	return ret0, ret1
-}
-
-// RevokeSecurityGroupEgressRequest indicates an expected call of RevokeSecurityGroupEgressRequest.
-func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupEgressRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupEgressRequest", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupEgressRequest), arg0)
-}
-
-// RevokeSecurityGroupEgressWithContext mocks base method.
-func (m *MockEC2API) RevokeSecurityGroupEgressWithContext(arg0 context.Context, arg1 *ec2.RevokeSecurityGroupEgressInput, arg2 ...request.Option) (*ec2.RevokeSecurityGroupEgressOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RevokeSecurityGroupEgressWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.RevokeSecurityGroupEgressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RevokeSecurityGroupEgressWithContext indicates an expected call of RevokeSecurityGroupEgressWithContext.
-func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupEgressWithContext(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, "RevokeSecurityGroupEgressWithContext", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupEgressWithContext), varargs...)
-}
-
-// RevokeSecurityGroupIngress mocks base method.
-func (m *MockEC2API) RevokeSecurityGroupIngress(arg0 *ec2.RevokeSecurityGroupIngressInput) (*ec2.RevokeSecurityGroupIngressOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RevokeSecurityGroupIngress", arg0)
-	ret0, _ := ret[0].(*ec2.RevokeSecurityGroupIngressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RevokeSecurityGroupIngress indicates an expected call of RevokeSecurityGroupIngress.
-func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupIngress(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupIngress", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupIngress), arg0)
-}
-
-// RevokeSecurityGroupIngressRequest mocks base method.
-func (m *MockEC2API) RevokeSecurityGroupIngressRequest(arg0 *ec2.RevokeSecurityGroupIngressInput) (*request.Request, *ec2.RevokeSecurityGroupIngressOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RevokeSecurityGroupIngressRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.RevokeSecurityGroupIngressOutput)
-	return ret0, ret1
-}
-
-// RevokeSecurityGroupIngressRequest indicates an expected call of RevokeSecurityGroupIngressRequest.
-func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupIngressRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupIngressRequest", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupIngressRequest), arg0)
-}
-
-// RevokeSecurityGroupIngressWithContext mocks base method.
-func (m *MockEC2API) RevokeSecurityGroupIngressWithContext(arg0 context.Context, arg1 *ec2.RevokeSecurityGroupIngressInput, arg2 ...request.Option) (*ec2.RevokeSecurityGroupIngressOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RevokeSecurityGroupIngressWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.RevokeSecurityGroupIngressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RevokeSecurityGroupIngressWithContext indicates an expected call of RevokeSecurityGroupIngressWithContext.
-func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupIngressWithContext(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, "RevokeSecurityGroupIngressWithContext", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupIngressWithContext), varargs...)
-}
-
-// RunInstances mocks base method.
-func (m *MockEC2API) RunInstances(arg0 *ec2.RunInstancesInput) (*ec2.Reservation, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RunInstances", arg0)
-	ret0, _ := ret[0].(*ec2.Reservation)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RunInstances indicates an expected call of RunInstances.
-func (mr *MockEC2APIMockRecorder) RunInstances(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunInstances", reflect.TypeOf((*MockEC2API)(nil).RunInstances), arg0)
-}
-
-// RunInstancesRequest mocks base method.
-func (m *MockEC2API) RunInstancesRequest(arg0 *ec2.RunInstancesInput) (*request.Request, *ec2.Reservation) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RunInstancesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.Reservation)
-	return ret0, ret1
-}
-
-// RunInstancesRequest indicates an expected call of RunInstancesRequest.
-func (mr *MockEC2APIMockRecorder) RunInstancesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).RunInstancesRequest), arg0)
-}
-
-// RunInstancesWithContext mocks base method.
-func (m *MockEC2API) RunInstancesWithContext(arg0 context.Context, arg1 *ec2.RunInstancesInput, arg2 ...request.Option) (*ec2.Reservation, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RunInstancesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.Reservation)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RunInstancesWithContext indicates an expected call of RunInstancesWithContext.
-func (mr *MockEC2APIMockRecorder) RunInstancesWithContext(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, "RunInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).RunInstancesWithContext), varargs...)
-}
-
-// RunScheduledInstances mocks base method.
-func (m *MockEC2API) RunScheduledInstances(arg0 *ec2.RunScheduledInstancesInput) (*ec2.RunScheduledInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RunScheduledInstances", arg0)
-	ret0, _ := ret[0].(*ec2.RunScheduledInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RunScheduledInstances indicates an expected call of RunScheduledInstances.
-func (mr *MockEC2APIMockRecorder) RunScheduledInstances(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunScheduledInstances", reflect.TypeOf((*MockEC2API)(nil).RunScheduledInstances), arg0)
-}
-
-// RunScheduledInstancesRequest mocks base method.
-func (m *MockEC2API) RunScheduledInstancesRequest(arg0 *ec2.RunScheduledInstancesInput) (*request.Request, *ec2.RunScheduledInstancesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RunScheduledInstancesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.RunScheduledInstancesOutput)
-	return ret0, ret1
-}
-
-// RunScheduledInstancesRequest indicates an expected call of RunScheduledInstancesRequest.
-func (mr *MockEC2APIMockRecorder) RunScheduledInstancesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunScheduledInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).RunScheduledInstancesRequest), arg0)
-}
-
-// RunScheduledInstancesWithContext mocks base method.
-func (m *MockEC2API) RunScheduledInstancesWithContext(arg0 context.Context, arg1 *ec2.RunScheduledInstancesInput, arg2 ...request.Option) (*ec2.RunScheduledInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RunScheduledInstancesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.RunScheduledInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RunScheduledInstancesWithContext indicates an expected call of RunScheduledInstancesWithContext.
-func (mr *MockEC2APIMockRecorder) RunScheduledInstancesWithContext(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, "RunScheduledInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).RunScheduledInstancesWithContext), varargs...)
-}
-
-// SearchLocalGatewayRoutes mocks base method.
-func (m *MockEC2API) SearchLocalGatewayRoutes(arg0 *ec2.SearchLocalGatewayRoutesInput) (*ec2.SearchLocalGatewayRoutesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SearchLocalGatewayRoutes", arg0)
-	ret0, _ := ret[0].(*ec2.SearchLocalGatewayRoutesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SearchLocalGatewayRoutes indicates an expected call of SearchLocalGatewayRoutes.
-func (mr *MockEC2APIMockRecorder) SearchLocalGatewayRoutes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchLocalGatewayRoutes", reflect.TypeOf((*MockEC2API)(nil).SearchLocalGatewayRoutes), arg0)
-}
-
-// SearchLocalGatewayRoutesPages mocks base method.
-func (m *MockEC2API) SearchLocalGatewayRoutesPages(arg0 *ec2.SearchLocalGatewayRoutesInput, arg1 func(*ec2.SearchLocalGatewayRoutesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SearchLocalGatewayRoutesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// SearchLocalGatewayRoutesPages indicates an expected call of SearchLocalGatewayRoutesPages.
-func (mr *MockEC2APIMockRecorder) SearchLocalGatewayRoutesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchLocalGatewayRoutesPages", reflect.TypeOf((*MockEC2API)(nil).SearchLocalGatewayRoutesPages), arg0, arg1)
-}
-
-// SearchLocalGatewayRoutesPagesWithContext mocks base method.
-func (m *MockEC2API) SearchLocalGatewayRoutesPagesWithContext(arg0 context.Context, arg1 *ec2.SearchLocalGatewayRoutesInput, arg2 func(*ec2.SearchLocalGatewayRoutesOutput, 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, "SearchLocalGatewayRoutesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// SearchLocalGatewayRoutesPagesWithContext indicates an expected call of SearchLocalGatewayRoutesPagesWithContext.
-func (mr *MockEC2APIMockRecorder) SearchLocalGatewayRoutesPagesWithContext(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, "SearchLocalGatewayRoutesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).SearchLocalGatewayRoutesPagesWithContext), varargs...)
-}
-
-// SearchLocalGatewayRoutesRequest mocks base method.
-func (m *MockEC2API) SearchLocalGatewayRoutesRequest(arg0 *ec2.SearchLocalGatewayRoutesInput) (*request.Request, *ec2.SearchLocalGatewayRoutesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SearchLocalGatewayRoutesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.SearchLocalGatewayRoutesOutput)
-	return ret0, ret1
-}
-
-// SearchLocalGatewayRoutesRequest indicates an expected call of SearchLocalGatewayRoutesRequest.
-func (mr *MockEC2APIMockRecorder) SearchLocalGatewayRoutesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchLocalGatewayRoutesRequest", reflect.TypeOf((*MockEC2API)(nil).SearchLocalGatewayRoutesRequest), arg0)
-}
-
-// SearchLocalGatewayRoutesWithContext mocks base method.
-func (m *MockEC2API) SearchLocalGatewayRoutesWithContext(arg0 context.Context, arg1 *ec2.SearchLocalGatewayRoutesInput, arg2 ...request.Option) (*ec2.SearchLocalGatewayRoutesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SearchLocalGatewayRoutesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.SearchLocalGatewayRoutesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SearchLocalGatewayRoutesWithContext indicates an expected call of SearchLocalGatewayRoutesWithContext.
-func (mr *MockEC2APIMockRecorder) SearchLocalGatewayRoutesWithContext(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, "SearchLocalGatewayRoutesWithContext", reflect.TypeOf((*MockEC2API)(nil).SearchLocalGatewayRoutesWithContext), varargs...)
-}
-
-// SearchTransitGatewayMulticastGroups mocks base method.
-func (m *MockEC2API) SearchTransitGatewayMulticastGroups(arg0 *ec2.SearchTransitGatewayMulticastGroupsInput) (*ec2.SearchTransitGatewayMulticastGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SearchTransitGatewayMulticastGroups", arg0)
-	ret0, _ := ret[0].(*ec2.SearchTransitGatewayMulticastGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SearchTransitGatewayMulticastGroups indicates an expected call of SearchTransitGatewayMulticastGroups.
-func (mr *MockEC2APIMockRecorder) SearchTransitGatewayMulticastGroups(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayMulticastGroups", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayMulticastGroups), arg0)
-}
-
-// SearchTransitGatewayMulticastGroupsPages mocks base method.
-func (m *MockEC2API) SearchTransitGatewayMulticastGroupsPages(arg0 *ec2.SearchTransitGatewayMulticastGroupsInput, arg1 func(*ec2.SearchTransitGatewayMulticastGroupsOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SearchTransitGatewayMulticastGroupsPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// SearchTransitGatewayMulticastGroupsPages indicates an expected call of SearchTransitGatewayMulticastGroupsPages.
-func (mr *MockEC2APIMockRecorder) SearchTransitGatewayMulticastGroupsPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayMulticastGroupsPages", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayMulticastGroupsPages), arg0, arg1)
-}
-
-// SearchTransitGatewayMulticastGroupsPagesWithContext mocks base method.
-func (m *MockEC2API) SearchTransitGatewayMulticastGroupsPagesWithContext(arg0 context.Context, arg1 *ec2.SearchTransitGatewayMulticastGroupsInput, arg2 func(*ec2.SearchTransitGatewayMulticastGroupsOutput, 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, "SearchTransitGatewayMulticastGroupsPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// SearchTransitGatewayMulticastGroupsPagesWithContext indicates an expected call of SearchTransitGatewayMulticastGroupsPagesWithContext.
-func (mr *MockEC2APIMockRecorder) SearchTransitGatewayMulticastGroupsPagesWithContext(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, "SearchTransitGatewayMulticastGroupsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayMulticastGroupsPagesWithContext), varargs...)
-}
-
-// SearchTransitGatewayMulticastGroupsRequest mocks base method.
-func (m *MockEC2API) SearchTransitGatewayMulticastGroupsRequest(arg0 *ec2.SearchTransitGatewayMulticastGroupsInput) (*request.Request, *ec2.SearchTransitGatewayMulticastGroupsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SearchTransitGatewayMulticastGroupsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.SearchTransitGatewayMulticastGroupsOutput)
-	return ret0, ret1
-}
-
-// SearchTransitGatewayMulticastGroupsRequest indicates an expected call of SearchTransitGatewayMulticastGroupsRequest.
-func (mr *MockEC2APIMockRecorder) SearchTransitGatewayMulticastGroupsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayMulticastGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayMulticastGroupsRequest), arg0)
-}
-
-// SearchTransitGatewayMulticastGroupsWithContext mocks base method.
-func (m *MockEC2API) SearchTransitGatewayMulticastGroupsWithContext(arg0 context.Context, arg1 *ec2.SearchTransitGatewayMulticastGroupsInput, arg2 ...request.Option) (*ec2.SearchTransitGatewayMulticastGroupsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SearchTransitGatewayMulticastGroupsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.SearchTransitGatewayMulticastGroupsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SearchTransitGatewayMulticastGroupsWithContext indicates an expected call of SearchTransitGatewayMulticastGroupsWithContext.
-func (mr *MockEC2APIMockRecorder) SearchTransitGatewayMulticastGroupsWithContext(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, "SearchTransitGatewayMulticastGroupsWithContext", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayMulticastGroupsWithContext), varargs...)
-}
-
-// SearchTransitGatewayRoutes mocks base method.
-func (m *MockEC2API) SearchTransitGatewayRoutes(arg0 *ec2.SearchTransitGatewayRoutesInput) (*ec2.SearchTransitGatewayRoutesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SearchTransitGatewayRoutes", arg0)
-	ret0, _ := ret[0].(*ec2.SearchTransitGatewayRoutesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SearchTransitGatewayRoutes indicates an expected call of SearchTransitGatewayRoutes.
-func (mr *MockEC2APIMockRecorder) SearchTransitGatewayRoutes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayRoutes", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayRoutes), arg0)
-}
-
-// SearchTransitGatewayRoutesRequest mocks base method.
-func (m *MockEC2API) SearchTransitGatewayRoutesRequest(arg0 *ec2.SearchTransitGatewayRoutesInput) (*request.Request, *ec2.SearchTransitGatewayRoutesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SearchTransitGatewayRoutesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.SearchTransitGatewayRoutesOutput)
-	return ret0, ret1
-}
-
-// SearchTransitGatewayRoutesRequest indicates an expected call of SearchTransitGatewayRoutesRequest.
-func (mr *MockEC2APIMockRecorder) SearchTransitGatewayRoutesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayRoutesRequest", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayRoutesRequest), arg0)
-}
-
-// SearchTransitGatewayRoutesWithContext mocks base method.
-func (m *MockEC2API) SearchTransitGatewayRoutesWithContext(arg0 context.Context, arg1 *ec2.SearchTransitGatewayRoutesInput, arg2 ...request.Option) (*ec2.SearchTransitGatewayRoutesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SearchTransitGatewayRoutesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.SearchTransitGatewayRoutesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SearchTransitGatewayRoutesWithContext indicates an expected call of SearchTransitGatewayRoutesWithContext.
-func (mr *MockEC2APIMockRecorder) SearchTransitGatewayRoutesWithContext(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, "SearchTransitGatewayRoutesWithContext", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayRoutesWithContext), varargs...)
-}
-
-// SendDiagnosticInterrupt mocks base method.
-func (m *MockEC2API) SendDiagnosticInterrupt(arg0 *ec2.SendDiagnosticInterruptInput) (*ec2.SendDiagnosticInterruptOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SendDiagnosticInterrupt", arg0)
-	ret0, _ := ret[0].(*ec2.SendDiagnosticInterruptOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SendDiagnosticInterrupt indicates an expected call of SendDiagnosticInterrupt.
-func (mr *MockEC2APIMockRecorder) SendDiagnosticInterrupt(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendDiagnosticInterrupt", reflect.TypeOf((*MockEC2API)(nil).SendDiagnosticInterrupt), arg0)
-}
-
-// SendDiagnosticInterruptRequest mocks base method.
-func (m *MockEC2API) SendDiagnosticInterruptRequest(arg0 *ec2.SendDiagnosticInterruptInput) (*request.Request, *ec2.SendDiagnosticInterruptOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SendDiagnosticInterruptRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.SendDiagnosticInterruptOutput)
-	return ret0, ret1
-}
-
-// SendDiagnosticInterruptRequest indicates an expected call of SendDiagnosticInterruptRequest.
-func (mr *MockEC2APIMockRecorder) SendDiagnosticInterruptRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendDiagnosticInterruptRequest", reflect.TypeOf((*MockEC2API)(nil).SendDiagnosticInterruptRequest), arg0)
-}
-
-// SendDiagnosticInterruptWithContext mocks base method.
-func (m *MockEC2API) SendDiagnosticInterruptWithContext(arg0 context.Context, arg1 *ec2.SendDiagnosticInterruptInput, arg2 ...request.Option) (*ec2.SendDiagnosticInterruptOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SendDiagnosticInterruptWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.SendDiagnosticInterruptOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SendDiagnosticInterruptWithContext indicates an expected call of SendDiagnosticInterruptWithContext.
-func (mr *MockEC2APIMockRecorder) SendDiagnosticInterruptWithContext(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, "SendDiagnosticInterruptWithContext", reflect.TypeOf((*MockEC2API)(nil).SendDiagnosticInterruptWithContext), varargs...)
-}
-
-// StartInstances mocks base method.
-func (m *MockEC2API) StartInstances(arg0 *ec2.StartInstancesInput) (*ec2.StartInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StartInstances", arg0)
-	ret0, _ := ret[0].(*ec2.StartInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StartInstances indicates an expected call of StartInstances.
-func (mr *MockEC2APIMockRecorder) StartInstances(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstances", reflect.TypeOf((*MockEC2API)(nil).StartInstances), arg0)
-}
-
-// StartInstancesRequest mocks base method.
-func (m *MockEC2API) StartInstancesRequest(arg0 *ec2.StartInstancesInput) (*request.Request, *ec2.StartInstancesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StartInstancesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.StartInstancesOutput)
-	return ret0, ret1
-}
-
-// StartInstancesRequest indicates an expected call of StartInstancesRequest.
-func (mr *MockEC2APIMockRecorder) StartInstancesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).StartInstancesRequest), arg0)
-}
-
-// StartInstancesWithContext mocks base method.
-func (m *MockEC2API) StartInstancesWithContext(arg0 context.Context, arg1 *ec2.StartInstancesInput, arg2 ...request.Option) (*ec2.StartInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "StartInstancesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.StartInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StartInstancesWithContext indicates an expected call of StartInstancesWithContext.
-func (mr *MockEC2APIMockRecorder) StartInstancesWithContext(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, "StartInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).StartInstancesWithContext), varargs...)
-}
-
-// StartNetworkInsightsAccessScopeAnalysis mocks base method.
-func (m *MockEC2API) StartNetworkInsightsAccessScopeAnalysis(arg0 *ec2.StartNetworkInsightsAccessScopeAnalysisInput) (*ec2.StartNetworkInsightsAccessScopeAnalysisOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StartNetworkInsightsAccessScopeAnalysis", arg0)
-	ret0, _ := ret[0].(*ec2.StartNetworkInsightsAccessScopeAnalysisOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StartNetworkInsightsAccessScopeAnalysis indicates an expected call of StartNetworkInsightsAccessScopeAnalysis.
-func (mr *MockEC2APIMockRecorder) StartNetworkInsightsAccessScopeAnalysis(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartNetworkInsightsAccessScopeAnalysis", reflect.TypeOf((*MockEC2API)(nil).StartNetworkInsightsAccessScopeAnalysis), arg0)
-}
-
-// StartNetworkInsightsAccessScopeAnalysisRequest mocks base method.
-func (m *MockEC2API) StartNetworkInsightsAccessScopeAnalysisRequest(arg0 *ec2.StartNetworkInsightsAccessScopeAnalysisInput) (*request.Request, *ec2.StartNetworkInsightsAccessScopeAnalysisOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StartNetworkInsightsAccessScopeAnalysisRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.StartNetworkInsightsAccessScopeAnalysisOutput)
-	return ret0, ret1
-}
-
-// StartNetworkInsightsAccessScopeAnalysisRequest indicates an expected call of StartNetworkInsightsAccessScopeAnalysisRequest.
-func (mr *MockEC2APIMockRecorder) StartNetworkInsightsAccessScopeAnalysisRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartNetworkInsightsAccessScopeAnalysisRequest", reflect.TypeOf((*MockEC2API)(nil).StartNetworkInsightsAccessScopeAnalysisRequest), arg0)
-}
-
-// StartNetworkInsightsAccessScopeAnalysisWithContext mocks base method.
-func (m *MockEC2API) StartNetworkInsightsAccessScopeAnalysisWithContext(arg0 context.Context, arg1 *ec2.StartNetworkInsightsAccessScopeAnalysisInput, arg2 ...request.Option) (*ec2.StartNetworkInsightsAccessScopeAnalysisOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "StartNetworkInsightsAccessScopeAnalysisWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.StartNetworkInsightsAccessScopeAnalysisOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StartNetworkInsightsAccessScopeAnalysisWithContext indicates an expected call of StartNetworkInsightsAccessScopeAnalysisWithContext.
-func (mr *MockEC2APIMockRecorder) StartNetworkInsightsAccessScopeAnalysisWithContext(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, "StartNetworkInsightsAccessScopeAnalysisWithContext", reflect.TypeOf((*MockEC2API)(nil).StartNetworkInsightsAccessScopeAnalysisWithContext), varargs...)
-}
-
-// StartNetworkInsightsAnalysis mocks base method.
-func (m *MockEC2API) StartNetworkInsightsAnalysis(arg0 *ec2.StartNetworkInsightsAnalysisInput) (*ec2.StartNetworkInsightsAnalysisOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StartNetworkInsightsAnalysis", arg0)
-	ret0, _ := ret[0].(*ec2.StartNetworkInsightsAnalysisOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StartNetworkInsightsAnalysis indicates an expected call of StartNetworkInsightsAnalysis.
-func (mr *MockEC2APIMockRecorder) StartNetworkInsightsAnalysis(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartNetworkInsightsAnalysis", reflect.TypeOf((*MockEC2API)(nil).StartNetworkInsightsAnalysis), arg0)
-}
-
-// StartNetworkInsightsAnalysisRequest mocks base method.
-func (m *MockEC2API) StartNetworkInsightsAnalysisRequest(arg0 *ec2.StartNetworkInsightsAnalysisInput) (*request.Request, *ec2.StartNetworkInsightsAnalysisOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StartNetworkInsightsAnalysisRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.StartNetworkInsightsAnalysisOutput)
-	return ret0, ret1
-}
-
-// StartNetworkInsightsAnalysisRequest indicates an expected call of StartNetworkInsightsAnalysisRequest.
-func (mr *MockEC2APIMockRecorder) StartNetworkInsightsAnalysisRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartNetworkInsightsAnalysisRequest", reflect.TypeOf((*MockEC2API)(nil).StartNetworkInsightsAnalysisRequest), arg0)
-}
-
-// StartNetworkInsightsAnalysisWithContext mocks base method.
-func (m *MockEC2API) StartNetworkInsightsAnalysisWithContext(arg0 context.Context, arg1 *ec2.StartNetworkInsightsAnalysisInput, arg2 ...request.Option) (*ec2.StartNetworkInsightsAnalysisOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "StartNetworkInsightsAnalysisWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.StartNetworkInsightsAnalysisOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StartNetworkInsightsAnalysisWithContext indicates an expected call of StartNetworkInsightsAnalysisWithContext.
-func (mr *MockEC2APIMockRecorder) StartNetworkInsightsAnalysisWithContext(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, "StartNetworkInsightsAnalysisWithContext", reflect.TypeOf((*MockEC2API)(nil).StartNetworkInsightsAnalysisWithContext), varargs...)
-}
-
-// StartVpcEndpointServicePrivateDnsVerification mocks base method.
-func (m *MockEC2API) StartVpcEndpointServicePrivateDnsVerification(arg0 *ec2.StartVpcEndpointServicePrivateDnsVerificationInput) (*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StartVpcEndpointServicePrivateDnsVerification", arg0)
-	ret0, _ := ret[0].(*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StartVpcEndpointServicePrivateDnsVerification indicates an expected call of StartVpcEndpointServicePrivateDnsVerification.
-func (mr *MockEC2APIMockRecorder) StartVpcEndpointServicePrivateDnsVerification(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartVpcEndpointServicePrivateDnsVerification", reflect.TypeOf((*MockEC2API)(nil).StartVpcEndpointServicePrivateDnsVerification), arg0)
-}
-
-// StartVpcEndpointServicePrivateDnsVerificationRequest mocks base method.
-func (m *MockEC2API) StartVpcEndpointServicePrivateDnsVerificationRequest(arg0 *ec2.StartVpcEndpointServicePrivateDnsVerificationInput) (*request.Request, *ec2.StartVpcEndpointServicePrivateDnsVerificationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StartVpcEndpointServicePrivateDnsVerificationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput)
-	return ret0, ret1
-}
-
-// StartVpcEndpointServicePrivateDnsVerificationRequest indicates an expected call of StartVpcEndpointServicePrivateDnsVerificationRequest.
-func (mr *MockEC2APIMockRecorder) StartVpcEndpointServicePrivateDnsVerificationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartVpcEndpointServicePrivateDnsVerificationRequest", reflect.TypeOf((*MockEC2API)(nil).StartVpcEndpointServicePrivateDnsVerificationRequest), arg0)
-}
-
-// StartVpcEndpointServicePrivateDnsVerificationWithContext mocks base method.
-func (m *MockEC2API) StartVpcEndpointServicePrivateDnsVerificationWithContext(arg0 context.Context, arg1 *ec2.StartVpcEndpointServicePrivateDnsVerificationInput, arg2 ...request.Option) (*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "StartVpcEndpointServicePrivateDnsVerificationWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StartVpcEndpointServicePrivateDnsVerificationWithContext indicates an expected call of StartVpcEndpointServicePrivateDnsVerificationWithContext.
-func (mr *MockEC2APIMockRecorder) StartVpcEndpointServicePrivateDnsVerificationWithContext(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, "StartVpcEndpointServicePrivateDnsVerificationWithContext", reflect.TypeOf((*MockEC2API)(nil).StartVpcEndpointServicePrivateDnsVerificationWithContext), varargs...)
-}
-
-// StopInstances mocks base method.
-func (m *MockEC2API) StopInstances(arg0 *ec2.StopInstancesInput) (*ec2.StopInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StopInstances", arg0)
-	ret0, _ := ret[0].(*ec2.StopInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StopInstances indicates an expected call of StopInstances.
-func (mr *MockEC2APIMockRecorder) StopInstances(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopInstances", reflect.TypeOf((*MockEC2API)(nil).StopInstances), arg0)
-}
-
-// StopInstancesRequest mocks base method.
-func (m *MockEC2API) StopInstancesRequest(arg0 *ec2.StopInstancesInput) (*request.Request, *ec2.StopInstancesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StopInstancesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.StopInstancesOutput)
-	return ret0, ret1
-}
-
-// StopInstancesRequest indicates an expected call of StopInstancesRequest.
-func (mr *MockEC2APIMockRecorder) StopInstancesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).StopInstancesRequest), arg0)
-}
-
-// StopInstancesWithContext mocks base method.
-func (m *MockEC2API) StopInstancesWithContext(arg0 context.Context, arg1 *ec2.StopInstancesInput, arg2 ...request.Option) (*ec2.StopInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "StopInstancesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.StopInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StopInstancesWithContext indicates an expected call of StopInstancesWithContext.
-func (mr *MockEC2APIMockRecorder) StopInstancesWithContext(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, "StopInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).StopInstancesWithContext), varargs...)
-}
-
-// TerminateClientVpnConnections mocks base method.
-func (m *MockEC2API) TerminateClientVpnConnections(arg0 *ec2.TerminateClientVpnConnectionsInput) (*ec2.TerminateClientVpnConnectionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "TerminateClientVpnConnections", arg0)
-	ret0, _ := ret[0].(*ec2.TerminateClientVpnConnectionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// TerminateClientVpnConnections indicates an expected call of TerminateClientVpnConnections.
-func (mr *MockEC2APIMockRecorder) TerminateClientVpnConnections(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateClientVpnConnections", reflect.TypeOf((*MockEC2API)(nil).TerminateClientVpnConnections), arg0)
-}
-
-// TerminateClientVpnConnectionsRequest mocks base method.
-func (m *MockEC2API) TerminateClientVpnConnectionsRequest(arg0 *ec2.TerminateClientVpnConnectionsInput) (*request.Request, *ec2.TerminateClientVpnConnectionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "TerminateClientVpnConnectionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.TerminateClientVpnConnectionsOutput)
-	return ret0, ret1
-}
-
-// TerminateClientVpnConnectionsRequest indicates an expected call of TerminateClientVpnConnectionsRequest.
-func (mr *MockEC2APIMockRecorder) TerminateClientVpnConnectionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateClientVpnConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).TerminateClientVpnConnectionsRequest), arg0)
-}
-
-// TerminateClientVpnConnectionsWithContext mocks base method.
-func (m *MockEC2API) TerminateClientVpnConnectionsWithContext(arg0 context.Context, arg1 *ec2.TerminateClientVpnConnectionsInput, arg2 ...request.Option) (*ec2.TerminateClientVpnConnectionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "TerminateClientVpnConnectionsWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.TerminateClientVpnConnectionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// TerminateClientVpnConnectionsWithContext indicates an expected call of TerminateClientVpnConnectionsWithContext.
-func (mr *MockEC2APIMockRecorder) TerminateClientVpnConnectionsWithContext(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, "TerminateClientVpnConnectionsWithContext", reflect.TypeOf((*MockEC2API)(nil).TerminateClientVpnConnectionsWithContext), varargs...)
-}
-
-// TerminateInstances mocks base method.
-func (m *MockEC2API) TerminateInstances(arg0 *ec2.TerminateInstancesInput) (*ec2.TerminateInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "TerminateInstances", arg0)
-	ret0, _ := ret[0].(*ec2.TerminateInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// TerminateInstances indicates an expected call of TerminateInstances.
-func (mr *MockEC2APIMockRecorder) TerminateInstances(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateInstances", reflect.TypeOf((*MockEC2API)(nil).TerminateInstances), arg0)
-}
-
-// TerminateInstancesRequest mocks base method.
-func (m *MockEC2API) TerminateInstancesRequest(arg0 *ec2.TerminateInstancesInput) (*request.Request, *ec2.TerminateInstancesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "TerminateInstancesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.TerminateInstancesOutput)
-	return ret0, ret1
-}
-
-// TerminateInstancesRequest indicates an expected call of TerminateInstancesRequest.
-func (mr *MockEC2APIMockRecorder) TerminateInstancesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).TerminateInstancesRequest), arg0)
-}
-
-// TerminateInstancesWithContext mocks base method.
-func (m *MockEC2API) TerminateInstancesWithContext(arg0 context.Context, arg1 *ec2.TerminateInstancesInput, arg2 ...request.Option) (*ec2.TerminateInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "TerminateInstancesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.TerminateInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// TerminateInstancesWithContext indicates an expected call of TerminateInstancesWithContext.
-func (mr *MockEC2APIMockRecorder) TerminateInstancesWithContext(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, "TerminateInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).TerminateInstancesWithContext), varargs...)
-}
-
-// UnassignIpv6Addresses mocks base method.
-func (m *MockEC2API) UnassignIpv6Addresses(arg0 *ec2.UnassignIpv6AddressesInput) (*ec2.UnassignIpv6AddressesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UnassignIpv6Addresses", arg0)
-	ret0, _ := ret[0].(*ec2.UnassignIpv6AddressesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UnassignIpv6Addresses indicates an expected call of UnassignIpv6Addresses.
-func (mr *MockEC2APIMockRecorder) UnassignIpv6Addresses(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignIpv6Addresses", reflect.TypeOf((*MockEC2API)(nil).UnassignIpv6Addresses), arg0)
-}
-
-// UnassignIpv6AddressesRequest mocks base method.
-func (m *MockEC2API) UnassignIpv6AddressesRequest(arg0 *ec2.UnassignIpv6AddressesInput) (*request.Request, *ec2.UnassignIpv6AddressesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UnassignIpv6AddressesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.UnassignIpv6AddressesOutput)
-	return ret0, ret1
-}
-
-// UnassignIpv6AddressesRequest indicates an expected call of UnassignIpv6AddressesRequest.
-func (mr *MockEC2APIMockRecorder) UnassignIpv6AddressesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignIpv6AddressesRequest", reflect.TypeOf((*MockEC2API)(nil).UnassignIpv6AddressesRequest), arg0)
-}
-
-// UnassignIpv6AddressesWithContext mocks base method.
-func (m *MockEC2API) UnassignIpv6AddressesWithContext(arg0 context.Context, arg1 *ec2.UnassignIpv6AddressesInput, arg2 ...request.Option) (*ec2.UnassignIpv6AddressesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "UnassignIpv6AddressesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.UnassignIpv6AddressesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UnassignIpv6AddressesWithContext indicates an expected call of UnassignIpv6AddressesWithContext.
-func (mr *MockEC2APIMockRecorder) UnassignIpv6AddressesWithContext(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, "UnassignIpv6AddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).UnassignIpv6AddressesWithContext), varargs...)
-}
-
-// UnassignPrivateIpAddresses mocks base method.
-func (m *MockEC2API) UnassignPrivateIpAddresses(arg0 *ec2.UnassignPrivateIpAddressesInput) (*ec2.UnassignPrivateIpAddressesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UnassignPrivateIpAddresses", arg0)
-	ret0, _ := ret[0].(*ec2.UnassignPrivateIpAddressesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UnassignPrivateIpAddresses indicates an expected call of UnassignPrivateIpAddresses.
-func (mr *MockEC2APIMockRecorder) UnassignPrivateIpAddresses(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateIpAddresses", reflect.TypeOf((*MockEC2API)(nil).UnassignPrivateIpAddresses), arg0)
-}
-
-// UnassignPrivateIpAddressesRequest mocks base method.
-func (m *MockEC2API) UnassignPrivateIpAddressesRequest(arg0 *ec2.UnassignPrivateIpAddressesInput) (*request.Request, *ec2.UnassignPrivateIpAddressesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UnassignPrivateIpAddressesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.UnassignPrivateIpAddressesOutput)
-	return ret0, ret1
-}
-
-// UnassignPrivateIpAddressesRequest indicates an expected call of UnassignPrivateIpAddressesRequest.
-func (mr *MockEC2APIMockRecorder) UnassignPrivateIpAddressesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateIpAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).UnassignPrivateIpAddressesRequest), arg0)
-}
-
-// UnassignPrivateIpAddressesWithContext mocks base method.
-func (m *MockEC2API) UnassignPrivateIpAddressesWithContext(arg0 context.Context, arg1 *ec2.UnassignPrivateIpAddressesInput, arg2 ...request.Option) (*ec2.UnassignPrivateIpAddressesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "UnassignPrivateIpAddressesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.UnassignPrivateIpAddressesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UnassignPrivateIpAddressesWithContext indicates an expected call of UnassignPrivateIpAddressesWithContext.
-func (mr *MockEC2APIMockRecorder) UnassignPrivateIpAddressesWithContext(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, "UnassignPrivateIpAddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).UnassignPrivateIpAddressesWithContext), varargs...)
-}
-
-// UnassignPrivateNatGatewayAddress mocks base method.
-func (m *MockEC2API) UnassignPrivateNatGatewayAddress(arg0 *ec2.UnassignPrivateNatGatewayAddressInput) (*ec2.UnassignPrivateNatGatewayAddressOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UnassignPrivateNatGatewayAddress", arg0)
-	ret0, _ := ret[0].(*ec2.UnassignPrivateNatGatewayAddressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UnassignPrivateNatGatewayAddress indicates an expected call of UnassignPrivateNatGatewayAddress.
-func (mr *MockEC2APIMockRecorder) UnassignPrivateNatGatewayAddress(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateNatGatewayAddress", reflect.TypeOf((*MockEC2API)(nil).UnassignPrivateNatGatewayAddress), arg0)
-}
-
-// UnassignPrivateNatGatewayAddressRequest mocks base method.
-func (m *MockEC2API) UnassignPrivateNatGatewayAddressRequest(arg0 *ec2.UnassignPrivateNatGatewayAddressInput) (*request.Request, *ec2.UnassignPrivateNatGatewayAddressOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UnassignPrivateNatGatewayAddressRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.UnassignPrivateNatGatewayAddressOutput)
-	return ret0, ret1
-}
-
-// UnassignPrivateNatGatewayAddressRequest indicates an expected call of UnassignPrivateNatGatewayAddressRequest.
-func (mr *MockEC2APIMockRecorder) UnassignPrivateNatGatewayAddressRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateNatGatewayAddressRequest", reflect.TypeOf((*MockEC2API)(nil).UnassignPrivateNatGatewayAddressRequest), arg0)
-}
-
-// UnassignPrivateNatGatewayAddressWithContext mocks base method.
-func (m *MockEC2API) UnassignPrivateNatGatewayAddressWithContext(arg0 context.Context, arg1 *ec2.UnassignPrivateNatGatewayAddressInput, arg2 ...request.Option) (*ec2.UnassignPrivateNatGatewayAddressOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "UnassignPrivateNatGatewayAddressWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.UnassignPrivateNatGatewayAddressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UnassignPrivateNatGatewayAddressWithContext indicates an expected call of UnassignPrivateNatGatewayAddressWithContext.
-func (mr *MockEC2APIMockRecorder) UnassignPrivateNatGatewayAddressWithContext(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, "UnassignPrivateNatGatewayAddressWithContext", reflect.TypeOf((*MockEC2API)(nil).UnassignPrivateNatGatewayAddressWithContext), varargs...)
-}
-
-// UnlockSnapshot mocks base method.
-func (m *MockEC2API) UnlockSnapshot(arg0 *ec2.UnlockSnapshotInput) (*ec2.UnlockSnapshotOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UnlockSnapshot", arg0)
-	ret0, _ := ret[0].(*ec2.UnlockSnapshotOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UnlockSnapshot indicates an expected call of UnlockSnapshot.
-func (mr *MockEC2APIMockRecorder) UnlockSnapshot(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnlockSnapshot", reflect.TypeOf((*MockEC2API)(nil).UnlockSnapshot), arg0)
-}
-
-// UnlockSnapshotRequest mocks base method.
-func (m *MockEC2API) UnlockSnapshotRequest(arg0 *ec2.UnlockSnapshotInput) (*request.Request, *ec2.UnlockSnapshotOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UnlockSnapshotRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.UnlockSnapshotOutput)
-	return ret0, ret1
-}
-
-// UnlockSnapshotRequest indicates an expected call of UnlockSnapshotRequest.
-func (mr *MockEC2APIMockRecorder) UnlockSnapshotRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnlockSnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).UnlockSnapshotRequest), arg0)
-}
-
-// UnlockSnapshotWithContext mocks base method.
-func (m *MockEC2API) UnlockSnapshotWithContext(arg0 context.Context, arg1 *ec2.UnlockSnapshotInput, arg2 ...request.Option) (*ec2.UnlockSnapshotOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "UnlockSnapshotWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.UnlockSnapshotOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UnlockSnapshotWithContext indicates an expected call of UnlockSnapshotWithContext.
-func (mr *MockEC2APIMockRecorder) UnlockSnapshotWithContext(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, "UnlockSnapshotWithContext", reflect.TypeOf((*MockEC2API)(nil).UnlockSnapshotWithContext), varargs...)
-}
-
-// UnmonitorInstances mocks base method.
-func (m *MockEC2API) UnmonitorInstances(arg0 *ec2.UnmonitorInstancesInput) (*ec2.UnmonitorInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UnmonitorInstances", arg0)
-	ret0, _ := ret[0].(*ec2.UnmonitorInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UnmonitorInstances indicates an expected call of UnmonitorInstances.
-func (mr *MockEC2APIMockRecorder) UnmonitorInstances(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmonitorInstances", reflect.TypeOf((*MockEC2API)(nil).UnmonitorInstances), arg0)
-}
-
-// UnmonitorInstancesRequest mocks base method.
-func (m *MockEC2API) UnmonitorInstancesRequest(arg0 *ec2.UnmonitorInstancesInput) (*request.Request, *ec2.UnmonitorInstancesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UnmonitorInstancesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.UnmonitorInstancesOutput)
-	return ret0, ret1
-}
-
-// UnmonitorInstancesRequest indicates an expected call of UnmonitorInstancesRequest.
-func (mr *MockEC2APIMockRecorder) UnmonitorInstancesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmonitorInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).UnmonitorInstancesRequest), arg0)
-}
-
-// UnmonitorInstancesWithContext mocks base method.
-func (m *MockEC2API) UnmonitorInstancesWithContext(arg0 context.Context, arg1 *ec2.UnmonitorInstancesInput, arg2 ...request.Option) (*ec2.UnmonitorInstancesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "UnmonitorInstancesWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.UnmonitorInstancesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UnmonitorInstancesWithContext indicates an expected call of UnmonitorInstancesWithContext.
-func (mr *MockEC2APIMockRecorder) UnmonitorInstancesWithContext(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, "UnmonitorInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).UnmonitorInstancesWithContext), varargs...)
-}
-
-// UpdateSecurityGroupRuleDescriptionsEgress mocks base method.
-func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsEgress(arg0 *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput) (*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsEgress", arg0)
-	ret0, _ := ret[0].(*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UpdateSecurityGroupRuleDescriptionsEgress indicates an expected call of UpdateSecurityGroupRuleDescriptionsEgress.
-func (mr *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsEgress(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsEgress", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsEgress), arg0)
-}
-
-// UpdateSecurityGroupRuleDescriptionsEgressRequest mocks base method.
-func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsEgressRequest(arg0 *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput) (*request.Request, *ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsEgressRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput)
-	return ret0, ret1
-}
-
-// UpdateSecurityGroupRuleDescriptionsEgressRequest indicates an expected call of UpdateSecurityGroupRuleDescriptionsEgressRequest.
-func (mr *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsEgressRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsEgressRequest", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsEgressRequest), arg0)
-}
-
-// UpdateSecurityGroupRuleDescriptionsEgressWithContext mocks base method.
-func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsEgressWithContext(arg0 context.Context, arg1 *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput, arg2 ...request.Option) (*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsEgressWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UpdateSecurityGroupRuleDescriptionsEgressWithContext indicates an expected call of UpdateSecurityGroupRuleDescriptionsEgressWithContext.
-func (mr *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsEgressWithContext(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, "UpdateSecurityGroupRuleDescriptionsEgressWithContext", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsEgressWithContext), varargs...)
-}
-
-// UpdateSecurityGroupRuleDescriptionsIngress mocks base method.
-func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsIngress(arg0 *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput) (*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsIngress", arg0)
-	ret0, _ := ret[0].(*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UpdateSecurityGroupRuleDescriptionsIngress indicates an expected call of UpdateSecurityGroupRuleDescriptionsIngress.
-func (mr *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsIngress(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsIngress", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsIngress), arg0)
-}
-
-// UpdateSecurityGroupRuleDescriptionsIngressRequest mocks base method.
-func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsIngressRequest(arg0 *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput) (*request.Request, *ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsIngressRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput)
-	return ret0, ret1
-}
-
-// UpdateSecurityGroupRuleDescriptionsIngressRequest indicates an expected call of UpdateSecurityGroupRuleDescriptionsIngressRequest.
-func (mr *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsIngressRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsIngressRequest", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsIngressRequest), arg0)
-}
-
-// UpdateSecurityGroupRuleDescriptionsIngressWithContext mocks base method.
-func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsIngressWithContext(arg0 context.Context, arg1 *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput, arg2 ...request.Option) (*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsIngressWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UpdateSecurityGroupRuleDescriptionsIngressWithContext indicates an expected call of UpdateSecurityGroupRuleDescriptionsIngressWithContext.
-func (mr *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsIngressWithContext(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, "UpdateSecurityGroupRuleDescriptionsIngressWithContext", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsIngressWithContext), varargs...)
-}
-
-// WaitUntilBundleTaskComplete mocks base method.
-func (m *MockEC2API) WaitUntilBundleTaskComplete(arg0 *ec2.DescribeBundleTasksInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilBundleTaskComplete", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilBundleTaskComplete indicates an expected call of WaitUntilBundleTaskComplete.
-func (mr *MockEC2APIMockRecorder) WaitUntilBundleTaskComplete(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilBundleTaskComplete", reflect.TypeOf((*MockEC2API)(nil).WaitUntilBundleTaskComplete), arg0)
-}
-
-// WaitUntilBundleTaskCompleteWithContext mocks base method.
-func (m *MockEC2API) WaitUntilBundleTaskCompleteWithContext(arg0 context.Context, arg1 *ec2.DescribeBundleTasksInput, 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, "WaitUntilBundleTaskCompleteWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilBundleTaskCompleteWithContext indicates an expected call of WaitUntilBundleTaskCompleteWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilBundleTaskCompleteWithContext(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, "WaitUntilBundleTaskCompleteWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilBundleTaskCompleteWithContext), varargs...)
-}
-
-// WaitUntilConversionTaskCancelled mocks base method.
-func (m *MockEC2API) WaitUntilConversionTaskCancelled(arg0 *ec2.DescribeConversionTasksInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilConversionTaskCancelled", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilConversionTaskCancelled indicates an expected call of WaitUntilConversionTaskCancelled.
-func (mr *MockEC2APIMockRecorder) WaitUntilConversionTaskCancelled(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskCancelled", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskCancelled), arg0)
-}
-
-// WaitUntilConversionTaskCancelledWithContext mocks base method.
-func (m *MockEC2API) WaitUntilConversionTaskCancelledWithContext(arg0 context.Context, arg1 *ec2.DescribeConversionTasksInput, 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, "WaitUntilConversionTaskCancelledWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilConversionTaskCancelledWithContext indicates an expected call of WaitUntilConversionTaskCancelledWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilConversionTaskCancelledWithContext(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, "WaitUntilConversionTaskCancelledWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskCancelledWithContext), varargs...)
-}
-
-// WaitUntilConversionTaskCompleted mocks base method.
-func (m *MockEC2API) WaitUntilConversionTaskCompleted(arg0 *ec2.DescribeConversionTasksInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilConversionTaskCompleted", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilConversionTaskCompleted indicates an expected call of WaitUntilConversionTaskCompleted.
-func (mr *MockEC2APIMockRecorder) WaitUntilConversionTaskCompleted(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskCompleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskCompleted), arg0)
-}
-
-// WaitUntilConversionTaskCompletedWithContext mocks base method.
-func (m *MockEC2API) WaitUntilConversionTaskCompletedWithContext(arg0 context.Context, arg1 *ec2.DescribeConversionTasksInput, 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, "WaitUntilConversionTaskCompletedWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilConversionTaskCompletedWithContext indicates an expected call of WaitUntilConversionTaskCompletedWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilConversionTaskCompletedWithContext(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, "WaitUntilConversionTaskCompletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskCompletedWithContext), varargs...)
-}
-
-// WaitUntilConversionTaskDeleted mocks base method.
-func (m *MockEC2API) WaitUntilConversionTaskDeleted(arg0 *ec2.DescribeConversionTasksInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilConversionTaskDeleted", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilConversionTaskDeleted indicates an expected call of WaitUntilConversionTaskDeleted.
-func (mr *MockEC2APIMockRecorder) WaitUntilConversionTaskDeleted(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskDeleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskDeleted), arg0)
-}
-
-// WaitUntilConversionTaskDeletedWithContext mocks base method.
-func (m *MockEC2API) WaitUntilConversionTaskDeletedWithContext(arg0 context.Context, arg1 *ec2.DescribeConversionTasksInput, 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, "WaitUntilConversionTaskDeletedWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilConversionTaskDeletedWithContext indicates an expected call of WaitUntilConversionTaskDeletedWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilConversionTaskDeletedWithContext(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, "WaitUntilConversionTaskDeletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskDeletedWithContext), varargs...)
-}
-
-// WaitUntilCustomerGatewayAvailable mocks base method.
-func (m *MockEC2API) WaitUntilCustomerGatewayAvailable(arg0 *ec2.DescribeCustomerGatewaysInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilCustomerGatewayAvailable", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilCustomerGatewayAvailable indicates an expected call of WaitUntilCustomerGatewayAvailable.
-func (mr *MockEC2APIMockRecorder) WaitUntilCustomerGatewayAvailable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilCustomerGatewayAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilCustomerGatewayAvailable), arg0)
-}
-
-// WaitUntilCustomerGatewayAvailableWithContext mocks base method.
-func (m *MockEC2API) WaitUntilCustomerGatewayAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeCustomerGatewaysInput, 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, "WaitUntilCustomerGatewayAvailableWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilCustomerGatewayAvailableWithContext indicates an expected call of WaitUntilCustomerGatewayAvailableWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilCustomerGatewayAvailableWithContext(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, "WaitUntilCustomerGatewayAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilCustomerGatewayAvailableWithContext), varargs...)
-}
-
-// WaitUntilExportTaskCancelled mocks base method.
-func (m *MockEC2API) WaitUntilExportTaskCancelled(arg0 *ec2.DescribeExportTasksInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilExportTaskCancelled", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilExportTaskCancelled indicates an expected call of WaitUntilExportTaskCancelled.
-func (mr *MockEC2APIMockRecorder) WaitUntilExportTaskCancelled(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilExportTaskCancelled", reflect.TypeOf((*MockEC2API)(nil).WaitUntilExportTaskCancelled), arg0)
-}
-
-// WaitUntilExportTaskCancelledWithContext mocks base method.
-func (m *MockEC2API) WaitUntilExportTaskCancelledWithContext(arg0 context.Context, arg1 *ec2.DescribeExportTasksInput, 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, "WaitUntilExportTaskCancelledWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilExportTaskCancelledWithContext indicates an expected call of WaitUntilExportTaskCancelledWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilExportTaskCancelledWithContext(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, "WaitUntilExportTaskCancelledWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilExportTaskCancelledWithContext), varargs...)
-}
-
-// WaitUntilExportTaskCompleted mocks base method.
-func (m *MockEC2API) WaitUntilExportTaskCompleted(arg0 *ec2.DescribeExportTasksInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilExportTaskCompleted", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilExportTaskCompleted indicates an expected call of WaitUntilExportTaskCompleted.
-func (mr *MockEC2APIMockRecorder) WaitUntilExportTaskCompleted(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilExportTaskCompleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilExportTaskCompleted), arg0)
-}
-
-// WaitUntilExportTaskCompletedWithContext mocks base method.
-func (m *MockEC2API) WaitUntilExportTaskCompletedWithContext(arg0 context.Context, arg1 *ec2.DescribeExportTasksInput, 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, "WaitUntilExportTaskCompletedWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilExportTaskCompletedWithContext indicates an expected call of WaitUntilExportTaskCompletedWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilExportTaskCompletedWithContext(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, "WaitUntilExportTaskCompletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilExportTaskCompletedWithContext), varargs...)
-}
-
-// WaitUntilImageAvailable mocks base method.
-func (m *MockEC2API) WaitUntilImageAvailable(arg0 *ec2.DescribeImagesInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilImageAvailable", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilImageAvailable indicates an expected call of WaitUntilImageAvailable.
-func (mr *MockEC2APIMockRecorder) WaitUntilImageAvailable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilImageAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilImageAvailable), arg0)
-}
-
-// WaitUntilImageAvailableWithContext mocks base method.
-func (m *MockEC2API) WaitUntilImageAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeImagesInput, 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, "WaitUntilImageAvailableWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilImageAvailableWithContext indicates an expected call of WaitUntilImageAvailableWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilImageAvailableWithContext(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, "WaitUntilImageAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilImageAvailableWithContext), varargs...)
-}
-
-// WaitUntilImageExists mocks base method.
-func (m *MockEC2API) WaitUntilImageExists(arg0 *ec2.DescribeImagesInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilImageExists", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilImageExists indicates an expected call of WaitUntilImageExists.
-func (mr *MockEC2APIMockRecorder) WaitUntilImageExists(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilImageExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilImageExists), arg0)
-}
-
-// WaitUntilImageExistsWithContext mocks base method.
-func (m *MockEC2API) WaitUntilImageExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeImagesInput, 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, "WaitUntilImageExistsWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilImageExistsWithContext indicates an expected call of WaitUntilImageExistsWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilImageExistsWithContext(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, "WaitUntilImageExistsWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilImageExistsWithContext), varargs...)
-}
-
-// WaitUntilInstanceExists mocks base method.
-func (m *MockEC2API) WaitUntilInstanceExists(arg0 *ec2.DescribeInstancesInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilInstanceExists", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilInstanceExists indicates an expected call of WaitUntilInstanceExists.
-func (mr *MockEC2APIMockRecorder) WaitUntilInstanceExists(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceExists), arg0)
-}
-
-// WaitUntilInstanceExistsWithContext mocks base method.
-func (m *MockEC2API) WaitUntilInstanceExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, 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, "WaitUntilInstanceExistsWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilInstanceExistsWithContext indicates an expected call of WaitUntilInstanceExistsWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilInstanceExistsWithContext(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, "WaitUntilInstanceExistsWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceExistsWithContext), varargs...)
-}
-
-// WaitUntilInstanceRunning mocks base method.
-func (m *MockEC2API) WaitUntilInstanceRunning(arg0 *ec2.DescribeInstancesInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilInstanceRunning", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilInstanceRunning indicates an expected call of WaitUntilInstanceRunning.
-func (mr *MockEC2APIMockRecorder) WaitUntilInstanceRunning(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceRunning", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceRunning), arg0)
-}
-
-// WaitUntilInstanceRunningWithContext mocks base method.
-func (m *MockEC2API) WaitUntilInstanceRunningWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, 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, "WaitUntilInstanceRunningWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilInstanceRunningWithContext indicates an expected call of WaitUntilInstanceRunningWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilInstanceRunningWithContext(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, "WaitUntilInstanceRunningWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceRunningWithContext), varargs...)
-}
-
-// WaitUntilInstanceStatusOk mocks base method.
-func (m *MockEC2API) WaitUntilInstanceStatusOk(arg0 *ec2.DescribeInstanceStatusInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilInstanceStatusOk", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilInstanceStatusOk indicates an expected call of WaitUntilInstanceStatusOk.
-func (mr *MockEC2APIMockRecorder) WaitUntilInstanceStatusOk(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceStatusOk", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceStatusOk), arg0)
-}
-
-// WaitUntilInstanceStatusOkWithContext mocks base method.
-func (m *MockEC2API) WaitUntilInstanceStatusOkWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceStatusInput, 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, "WaitUntilInstanceStatusOkWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilInstanceStatusOkWithContext indicates an expected call of WaitUntilInstanceStatusOkWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilInstanceStatusOkWithContext(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, "WaitUntilInstanceStatusOkWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceStatusOkWithContext), varargs...)
-}
-
-// WaitUntilInstanceStopped mocks base method.
-func (m *MockEC2API) WaitUntilInstanceStopped(arg0 *ec2.DescribeInstancesInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilInstanceStopped", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilInstanceStopped indicates an expected call of WaitUntilInstanceStopped.
-func (mr *MockEC2APIMockRecorder) WaitUntilInstanceStopped(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceStopped", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceStopped), arg0)
-}
-
-// WaitUntilInstanceStoppedWithContext mocks base method.
-func (m *MockEC2API) WaitUntilInstanceStoppedWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, 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, "WaitUntilInstanceStoppedWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilInstanceStoppedWithContext indicates an expected call of WaitUntilInstanceStoppedWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilInstanceStoppedWithContext(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, "WaitUntilInstanceStoppedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceStoppedWithContext), varargs...)
-}
-
-// WaitUntilInstanceTerminated mocks base method.
-func (m *MockEC2API) WaitUntilInstanceTerminated(arg0 *ec2.DescribeInstancesInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilInstanceTerminated", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilInstanceTerminated indicates an expected call of WaitUntilInstanceTerminated.
-func (mr *MockEC2APIMockRecorder) WaitUntilInstanceTerminated(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceTerminated", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceTerminated), arg0)
-}
-
-// WaitUntilInstanceTerminatedWithContext mocks base method.
-func (m *MockEC2API) WaitUntilInstanceTerminatedWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, 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, "WaitUntilInstanceTerminatedWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilInstanceTerminatedWithContext indicates an expected call of WaitUntilInstanceTerminatedWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilInstanceTerminatedWithContext(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, "WaitUntilInstanceTerminatedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceTerminatedWithContext), varargs...)
-}
-
-// WaitUntilInternetGatewayExists mocks base method.
-func (m *MockEC2API) WaitUntilInternetGatewayExists(arg0 *ec2.DescribeInternetGatewaysInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilInternetGatewayExists", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilInternetGatewayExists indicates an expected call of WaitUntilInternetGatewayExists.
-func (mr *MockEC2APIMockRecorder) WaitUntilInternetGatewayExists(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInternetGatewayExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInternetGatewayExists), arg0)
-}
-
-// WaitUntilInternetGatewayExistsWithContext mocks base method.
-func (m *MockEC2API) WaitUntilInternetGatewayExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeInternetGatewaysInput, 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, "WaitUntilInternetGatewayExistsWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilInternetGatewayExistsWithContext indicates an expected call of WaitUntilInternetGatewayExistsWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilInternetGatewayExistsWithContext(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, "WaitUntilInternetGatewayExistsWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInternetGatewayExistsWithContext), varargs...)
-}
-
-// WaitUntilKeyPairExists mocks base method.
-func (m *MockEC2API) WaitUntilKeyPairExists(arg0 *ec2.DescribeKeyPairsInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilKeyPairExists", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilKeyPairExists indicates an expected call of WaitUntilKeyPairExists.
-func (mr *MockEC2APIMockRecorder) WaitUntilKeyPairExists(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilKeyPairExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilKeyPairExists), arg0)
-}
-
-// WaitUntilKeyPairExistsWithContext mocks base method.
-func (m *MockEC2API) WaitUntilKeyPairExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeKeyPairsInput, 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, "WaitUntilKeyPairExistsWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilKeyPairExistsWithContext indicates an expected call of WaitUntilKeyPairExistsWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilKeyPairExistsWithContext(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, "WaitUntilKeyPairExistsWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilKeyPairExistsWithContext), varargs...)
-}
-
-// WaitUntilNatGatewayAvailable mocks base method.
-func (m *MockEC2API) WaitUntilNatGatewayAvailable(arg0 *ec2.DescribeNatGatewaysInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilNatGatewayAvailable", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilNatGatewayAvailable indicates an expected call of WaitUntilNatGatewayAvailable.
-func (mr *MockEC2APIMockRecorder) WaitUntilNatGatewayAvailable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilNatGatewayAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilNatGatewayAvailable), arg0)
-}
-
-// WaitUntilNatGatewayAvailableWithContext mocks base method.
-func (m *MockEC2API) WaitUntilNatGatewayAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeNatGatewaysInput, 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, "WaitUntilNatGatewayAvailableWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilNatGatewayAvailableWithContext indicates an expected call of WaitUntilNatGatewayAvailableWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilNatGatewayAvailableWithContext(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, "WaitUntilNatGatewayAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilNatGatewayAvailableWithContext), varargs...)
-}
-
-// WaitUntilNatGatewayDeleted mocks base method.
-func (m *MockEC2API) WaitUntilNatGatewayDeleted(arg0 *ec2.DescribeNatGatewaysInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilNatGatewayDeleted", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilNatGatewayDeleted indicates an expected call of WaitUntilNatGatewayDeleted.
-func (mr *MockEC2APIMockRecorder) WaitUntilNatGatewayDeleted(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilNatGatewayDeleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilNatGatewayDeleted), arg0)
-}
-
-// WaitUntilNatGatewayDeletedWithContext mocks base method.
-func (m *MockEC2API) WaitUntilNatGatewayDeletedWithContext(arg0 context.Context, arg1 *ec2.DescribeNatGatewaysInput, 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, "WaitUntilNatGatewayDeletedWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilNatGatewayDeletedWithContext indicates an expected call of WaitUntilNatGatewayDeletedWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilNatGatewayDeletedWithContext(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, "WaitUntilNatGatewayDeletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilNatGatewayDeletedWithContext), varargs...)
-}
-
-// WaitUntilNetworkInterfaceAvailable mocks base method.
-func (m *MockEC2API) WaitUntilNetworkInterfaceAvailable(arg0 *ec2.DescribeNetworkInterfacesInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilNetworkInterfaceAvailable", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilNetworkInterfaceAvailable indicates an expected call of WaitUntilNetworkInterfaceAvailable.
-func (mr *MockEC2APIMockRecorder) WaitUntilNetworkInterfaceAvailable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilNetworkInterfaceAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilNetworkInterfaceAvailable), arg0)
-}
-
-// WaitUntilNetworkInterfaceAvailableWithContext mocks base method.
-func (m *MockEC2API) WaitUntilNetworkInterfaceAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfacesInput, 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, "WaitUntilNetworkInterfaceAvailableWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilNetworkInterfaceAvailableWithContext indicates an expected call of WaitUntilNetworkInterfaceAvailableWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilNetworkInterfaceAvailableWithContext(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, "WaitUntilNetworkInterfaceAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilNetworkInterfaceAvailableWithContext), varargs...)
-}
-
-// WaitUntilPasswordDataAvailable mocks base method.
-func (m *MockEC2API) WaitUntilPasswordDataAvailable(arg0 *ec2.GetPasswordDataInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilPasswordDataAvailable", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilPasswordDataAvailable indicates an expected call of WaitUntilPasswordDataAvailable.
-func (mr *MockEC2APIMockRecorder) WaitUntilPasswordDataAvailable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilPasswordDataAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilPasswordDataAvailable), arg0)
-}
-
-// WaitUntilPasswordDataAvailableWithContext mocks base method.
-func (m *MockEC2API) WaitUntilPasswordDataAvailableWithContext(arg0 context.Context, arg1 *ec2.GetPasswordDataInput, 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, "WaitUntilPasswordDataAvailableWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilPasswordDataAvailableWithContext indicates an expected call of WaitUntilPasswordDataAvailableWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilPasswordDataAvailableWithContext(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, "WaitUntilPasswordDataAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilPasswordDataAvailableWithContext), varargs...)
-}
-
-// WaitUntilSecurityGroupExists mocks base method.
-func (m *MockEC2API) WaitUntilSecurityGroupExists(arg0 *ec2.DescribeSecurityGroupsInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilSecurityGroupExists", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilSecurityGroupExists indicates an expected call of WaitUntilSecurityGroupExists.
-func (mr *MockEC2APIMockRecorder) WaitUntilSecurityGroupExists(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSecurityGroupExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSecurityGroupExists), arg0)
-}
-
-// WaitUntilSecurityGroupExistsWithContext mocks base method.
-func (m *MockEC2API) WaitUntilSecurityGroupExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupsInput, 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, "WaitUntilSecurityGroupExistsWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilSecurityGroupExistsWithContext indicates an expected call of WaitUntilSecurityGroupExistsWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilSecurityGroupExistsWithContext(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, "WaitUntilSecurityGroupExistsWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSecurityGroupExistsWithContext), varargs...)
-}
-
-// WaitUntilSnapshotCompleted mocks base method.
-func (m *MockEC2API) WaitUntilSnapshotCompleted(arg0 *ec2.DescribeSnapshotsInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilSnapshotCompleted", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilSnapshotCompleted indicates an expected call of WaitUntilSnapshotCompleted.
-func (mr *MockEC2APIMockRecorder) WaitUntilSnapshotCompleted(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSnapshotCompleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSnapshotCompleted), arg0)
-}
-
-// WaitUntilSnapshotCompletedWithContext mocks base method.
-func (m *MockEC2API) WaitUntilSnapshotCompletedWithContext(arg0 context.Context, arg1 *ec2.DescribeSnapshotsInput, 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, "WaitUntilSnapshotCompletedWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilSnapshotCompletedWithContext indicates an expected call of WaitUntilSnapshotCompletedWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilSnapshotCompletedWithContext(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, "WaitUntilSnapshotCompletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSnapshotCompletedWithContext), varargs...)
-}
-
-// WaitUntilSnapshotImported mocks base method.
-func (m *MockEC2API) WaitUntilSnapshotImported(arg0 *ec2.DescribeImportSnapshotTasksInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilSnapshotImported", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilSnapshotImported indicates an expected call of WaitUntilSnapshotImported.
-func (mr *MockEC2APIMockRecorder) WaitUntilSnapshotImported(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSnapshotImported", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSnapshotImported), arg0)
-}
-
-// WaitUntilSnapshotImportedWithContext mocks base method.
-func (m *MockEC2API) WaitUntilSnapshotImportedWithContext(arg0 context.Context, arg1 *ec2.DescribeImportSnapshotTasksInput, 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, "WaitUntilSnapshotImportedWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilSnapshotImportedWithContext indicates an expected call of WaitUntilSnapshotImportedWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilSnapshotImportedWithContext(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, "WaitUntilSnapshotImportedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSnapshotImportedWithContext), varargs...)
-}
-
-// WaitUntilSpotInstanceRequestFulfilled mocks base method.
-func (m *MockEC2API) WaitUntilSpotInstanceRequestFulfilled(arg0 *ec2.DescribeSpotInstanceRequestsInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilSpotInstanceRequestFulfilled", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilSpotInstanceRequestFulfilled indicates an expected call of WaitUntilSpotInstanceRequestFulfilled.
-func (mr *MockEC2APIMockRecorder) WaitUntilSpotInstanceRequestFulfilled(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSpotInstanceRequestFulfilled", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSpotInstanceRequestFulfilled), arg0)
-}
-
-// WaitUntilSpotInstanceRequestFulfilledWithContext mocks base method.
-func (m *MockEC2API) WaitUntilSpotInstanceRequestFulfilledWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotInstanceRequestsInput, 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, "WaitUntilSpotInstanceRequestFulfilledWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilSpotInstanceRequestFulfilledWithContext indicates an expected call of WaitUntilSpotInstanceRequestFulfilledWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilSpotInstanceRequestFulfilledWithContext(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, "WaitUntilSpotInstanceRequestFulfilledWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSpotInstanceRequestFulfilledWithContext), varargs...)
-}
-
-// WaitUntilStoreImageTaskComplete mocks base method.
-func (m *MockEC2API) WaitUntilStoreImageTaskComplete(arg0 *ec2.DescribeStoreImageTasksInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilStoreImageTaskComplete", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilStoreImageTaskComplete indicates an expected call of WaitUntilStoreImageTaskComplete.
-func (mr *MockEC2APIMockRecorder) WaitUntilStoreImageTaskComplete(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilStoreImageTaskComplete", reflect.TypeOf((*MockEC2API)(nil).WaitUntilStoreImageTaskComplete), arg0)
-}
-
-// WaitUntilStoreImageTaskCompleteWithContext mocks base method.
-func (m *MockEC2API) WaitUntilStoreImageTaskCompleteWithContext(arg0 context.Context, arg1 *ec2.DescribeStoreImageTasksInput, 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, "WaitUntilStoreImageTaskCompleteWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilStoreImageTaskCompleteWithContext indicates an expected call of WaitUntilStoreImageTaskCompleteWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilStoreImageTaskCompleteWithContext(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, "WaitUntilStoreImageTaskCompleteWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilStoreImageTaskCompleteWithContext), varargs...)
-}
-
-// WaitUntilSubnetAvailable mocks base method.
-func (m *MockEC2API) WaitUntilSubnetAvailable(arg0 *ec2.DescribeSubnetsInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilSubnetAvailable", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilSubnetAvailable indicates an expected call of WaitUntilSubnetAvailable.
-func (mr *MockEC2APIMockRecorder) WaitUntilSubnetAvailable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSubnetAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSubnetAvailable), arg0)
-}
-
-// WaitUntilSubnetAvailableWithContext mocks base method.
-func (m *MockEC2API) WaitUntilSubnetAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeSubnetsInput, 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, "WaitUntilSubnetAvailableWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilSubnetAvailableWithContext indicates an expected call of WaitUntilSubnetAvailableWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilSubnetAvailableWithContext(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, "WaitUntilSubnetAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSubnetAvailableWithContext), varargs...)
-}
-
-// WaitUntilSystemStatusOk mocks base method.
-func (m *MockEC2API) WaitUntilSystemStatusOk(arg0 *ec2.DescribeInstanceStatusInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilSystemStatusOk", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilSystemStatusOk indicates an expected call of WaitUntilSystemStatusOk.
-func (mr *MockEC2APIMockRecorder) WaitUntilSystemStatusOk(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSystemStatusOk", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSystemStatusOk), arg0)
-}
-
-// WaitUntilSystemStatusOkWithContext mocks base method.
-func (m *MockEC2API) WaitUntilSystemStatusOkWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceStatusInput, 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, "WaitUntilSystemStatusOkWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilSystemStatusOkWithContext indicates an expected call of WaitUntilSystemStatusOkWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilSystemStatusOkWithContext(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, "WaitUntilSystemStatusOkWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSystemStatusOkWithContext), varargs...)
-}
-
-// WaitUntilVolumeAvailable mocks base method.
-func (m *MockEC2API) WaitUntilVolumeAvailable(arg0 *ec2.DescribeVolumesInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilVolumeAvailable", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilVolumeAvailable indicates an expected call of WaitUntilVolumeAvailable.
-func (mr *MockEC2APIMockRecorder) WaitUntilVolumeAvailable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeAvailable), arg0)
-}
-
-// WaitUntilVolumeAvailableWithContext mocks base method.
-func (m *MockEC2API) WaitUntilVolumeAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesInput, 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, "WaitUntilVolumeAvailableWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilVolumeAvailableWithContext indicates an expected call of WaitUntilVolumeAvailableWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilVolumeAvailableWithContext(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, "WaitUntilVolumeAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeAvailableWithContext), varargs...)
-}
-
-// WaitUntilVolumeDeleted mocks base method.
-func (m *MockEC2API) WaitUntilVolumeDeleted(arg0 *ec2.DescribeVolumesInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilVolumeDeleted", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilVolumeDeleted indicates an expected call of WaitUntilVolumeDeleted.
-func (mr *MockEC2APIMockRecorder) WaitUntilVolumeDeleted(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeDeleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeDeleted), arg0)
-}
-
-// WaitUntilVolumeDeletedWithContext mocks base method.
-func (m *MockEC2API) WaitUntilVolumeDeletedWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesInput, 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, "WaitUntilVolumeDeletedWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilVolumeDeletedWithContext indicates an expected call of WaitUntilVolumeDeletedWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilVolumeDeletedWithContext(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, "WaitUntilVolumeDeletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeDeletedWithContext), varargs...)
-}
-
-// WaitUntilVolumeInUse mocks base method.
-func (m *MockEC2API) WaitUntilVolumeInUse(arg0 *ec2.DescribeVolumesInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilVolumeInUse", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilVolumeInUse indicates an expected call of WaitUntilVolumeInUse.
-func (mr *MockEC2APIMockRecorder) WaitUntilVolumeInUse(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeInUse", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeInUse), arg0)
-}
-
-// WaitUntilVolumeInUseWithContext mocks base method.
-func (m *MockEC2API) WaitUntilVolumeInUseWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesInput, 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, "WaitUntilVolumeInUseWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilVolumeInUseWithContext indicates an expected call of WaitUntilVolumeInUseWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilVolumeInUseWithContext(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, "WaitUntilVolumeInUseWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeInUseWithContext), varargs...)
-}
-
-// WaitUntilVpcAvailable mocks base method.
-func (m *MockEC2API) WaitUntilVpcAvailable(arg0 *ec2.DescribeVpcsInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilVpcAvailable", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilVpcAvailable indicates an expected call of WaitUntilVpcAvailable.
-func (mr *MockEC2APIMockRecorder) WaitUntilVpcAvailable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcAvailable), arg0)
-}
-
-// WaitUntilVpcAvailableWithContext mocks base method.
-func (m *MockEC2API) WaitUntilVpcAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcsInput, 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, "WaitUntilVpcAvailableWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilVpcAvailableWithContext indicates an expected call of WaitUntilVpcAvailableWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilVpcAvailableWithContext(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, "WaitUntilVpcAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcAvailableWithContext), varargs...)
-}
-
-// WaitUntilVpcExists mocks base method.
-func (m *MockEC2API) WaitUntilVpcExists(arg0 *ec2.DescribeVpcsInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilVpcExists", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilVpcExists indicates an expected call of WaitUntilVpcExists.
-func (mr *MockEC2APIMockRecorder) WaitUntilVpcExists(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcExists), arg0)
-}
-
-// WaitUntilVpcExistsWithContext mocks base method.
-func (m *MockEC2API) WaitUntilVpcExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcsInput, 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, "WaitUntilVpcExistsWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilVpcExistsWithContext indicates an expected call of WaitUntilVpcExistsWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilVpcExistsWithContext(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, "WaitUntilVpcExistsWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcExistsWithContext), varargs...)
-}
-
-// WaitUntilVpcPeeringConnectionDeleted mocks base method.
-func (m *MockEC2API) WaitUntilVpcPeeringConnectionDeleted(arg0 *ec2.DescribeVpcPeeringConnectionsInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilVpcPeeringConnectionDeleted", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilVpcPeeringConnectionDeleted indicates an expected call of WaitUntilVpcPeeringConnectionDeleted.
-func (mr *MockEC2APIMockRecorder) WaitUntilVpcPeeringConnectionDeleted(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcPeeringConnectionDeleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcPeeringConnectionDeleted), arg0)
-}
-
-// WaitUntilVpcPeeringConnectionDeletedWithContext mocks base method.
-func (m *MockEC2API) WaitUntilVpcPeeringConnectionDeletedWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcPeeringConnectionsInput, 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, "WaitUntilVpcPeeringConnectionDeletedWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilVpcPeeringConnectionDeletedWithContext indicates an expected call of WaitUntilVpcPeeringConnectionDeletedWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilVpcPeeringConnectionDeletedWithContext(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, "WaitUntilVpcPeeringConnectionDeletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcPeeringConnectionDeletedWithContext), varargs...)
-}
-
-// WaitUntilVpcPeeringConnectionExists mocks base method.
-func (m *MockEC2API) WaitUntilVpcPeeringConnectionExists(arg0 *ec2.DescribeVpcPeeringConnectionsInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilVpcPeeringConnectionExists", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilVpcPeeringConnectionExists indicates an expected call of WaitUntilVpcPeeringConnectionExists.
-func (mr *MockEC2APIMockRecorder) WaitUntilVpcPeeringConnectionExists(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcPeeringConnectionExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcPeeringConnectionExists), arg0)
-}
-
-// WaitUntilVpcPeeringConnectionExistsWithContext mocks base method.
-func (m *MockEC2API) WaitUntilVpcPeeringConnectionExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcPeeringConnectionsInput, 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, "WaitUntilVpcPeeringConnectionExistsWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilVpcPeeringConnectionExistsWithContext indicates an expected call of WaitUntilVpcPeeringConnectionExistsWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilVpcPeeringConnectionExistsWithContext(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, "WaitUntilVpcPeeringConnectionExistsWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcPeeringConnectionExistsWithContext), varargs...)
-}
-
-// WaitUntilVpnConnectionAvailable mocks base method.
-func (m *MockEC2API) WaitUntilVpnConnectionAvailable(arg0 *ec2.DescribeVpnConnectionsInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilVpnConnectionAvailable", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilVpnConnectionAvailable indicates an expected call of WaitUntilVpnConnectionAvailable.
-func (mr *MockEC2APIMockRecorder) WaitUntilVpnConnectionAvailable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpnConnectionAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpnConnectionAvailable), arg0)
-}
-
-// WaitUntilVpnConnectionAvailableWithContext mocks base method.
-func (m *MockEC2API) WaitUntilVpnConnectionAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeVpnConnectionsInput, 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, "WaitUntilVpnConnectionAvailableWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilVpnConnectionAvailableWithContext indicates an expected call of WaitUntilVpnConnectionAvailableWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilVpnConnectionAvailableWithContext(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, "WaitUntilVpnConnectionAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpnConnectionAvailableWithContext), varargs...)
-}
-
-// WaitUntilVpnConnectionDeleted mocks base method.
-func (m *MockEC2API) WaitUntilVpnConnectionDeleted(arg0 *ec2.DescribeVpnConnectionsInput) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitUntilVpnConnectionDeleted", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilVpnConnectionDeleted indicates an expected call of WaitUntilVpnConnectionDeleted.
-func (mr *MockEC2APIMockRecorder) WaitUntilVpnConnectionDeleted(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpnConnectionDeleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpnConnectionDeleted), arg0)
-}
-
-// WaitUntilVpnConnectionDeletedWithContext mocks base method.
-func (m *MockEC2API) WaitUntilVpnConnectionDeletedWithContext(arg0 context.Context, arg1 *ec2.DescribeVpnConnectionsInput, 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, "WaitUntilVpnConnectionDeletedWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// WaitUntilVpnConnectionDeletedWithContext indicates an expected call of WaitUntilVpnConnectionDeletedWithContext.
-func (mr *MockEC2APIMockRecorder) WaitUntilVpnConnectionDeletedWithContext(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, "WaitUntilVpnConnectionDeletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpnConnectionDeletedWithContext), varargs...)
-}
-
-// WithdrawByoipCidr mocks base method.
-func (m *MockEC2API) WithdrawByoipCidr(arg0 *ec2.WithdrawByoipCidrInput) (*ec2.WithdrawByoipCidrOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WithdrawByoipCidr", arg0)
-	ret0, _ := ret[0].(*ec2.WithdrawByoipCidrOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// WithdrawByoipCidr indicates an expected call of WithdrawByoipCidr.
-func (mr *MockEC2APIMockRecorder) WithdrawByoipCidr(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithdrawByoipCidr", reflect.TypeOf((*MockEC2API)(nil).WithdrawByoipCidr), arg0)
-}
-
-// WithdrawByoipCidrRequest mocks base method.
-func (m *MockEC2API) WithdrawByoipCidrRequest(arg0 *ec2.WithdrawByoipCidrInput) (*request.Request, *ec2.WithdrawByoipCidrOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WithdrawByoipCidrRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*ec2.WithdrawByoipCidrOutput)
-	return ret0, ret1
-}
-
-// WithdrawByoipCidrRequest indicates an expected call of WithdrawByoipCidrRequest.
-func (mr *MockEC2APIMockRecorder) WithdrawByoipCidrRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithdrawByoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).WithdrawByoipCidrRequest), arg0)
-}
-
-// WithdrawByoipCidrWithContext mocks base method.
-func (m *MockEC2API) WithdrawByoipCidrWithContext(arg0 context.Context, arg1 *ec2.WithdrawByoipCidrInput, arg2 ...request.Option) (*ec2.WithdrawByoipCidrOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "WithdrawByoipCidrWithContext", varargs...)
-	ret0, _ := ret[0].(*ec2.WithdrawByoipCidrOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// WithdrawByoipCidrWithContext indicates an expected call of WithdrawByoipCidrWithContext.
-func (mr *MockEC2APIMockRecorder) WithdrawByoipCidrWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// TerminateInstances indicates an expected call of TerminateInstances.
+func (mr *MockEC2APIMockRecorder) TerminateInstances(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, "WithdrawByoipCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).WithdrawByoipCidrWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateInstances", reflect.TypeOf((*MockEC2API)(nil).TerminateInstances), varargs...)
 }
diff --git a/test/mocks/generate_aws.go b/test/mocks/generate_aws.go
index f5e551547..3eef99513 100644
--- a/test/mocks/generate_aws.go
+++ b/test/mocks/generate_aws.go
@@ -22,8 +22,6 @@ limitations under the License.
 //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 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 ../../hack/tools/bin/mockgen -destination aws_ec2api_mock.go -package mocks sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/common 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"
-//go:generate ../../hack/tools/bin/mockgen -destination aws_ec2apiv2_mock.go -package mocks sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope EC2API
-//go:generate /usr/bin/env bash -c "cat ../../hack/boilerplate/boilerplate.generatego.txt aws_ec2apiv2_mock.go > _aws_ec2apiv2_mock.go && mv _aws_ec2apiv2_mock.go v2/aws_ec2api_mock.go && rm aws_ec2apiv2_mock.go"
 package mocks